def __init__(self, shared): loadPrcFileData("", """load-display pandagl sync-video #t fullscreen #f win-origin 0 0 undecorated #t cursor-hidden #t win-size 7680 1080 show-frame-rate-meter #t auto-single-cpu-affinity #f """) TrueClock.getGlobalPtr().setCpuAffinity(0xFFFFFFFF) self.shared = shared ShowBase.__init__(self) self.global_time = 0.0 self.statustex1 = create_color_texture([0, 0, 0]) self.statustex2 = create_color_texture([255, 255, 255]) self.statusimage1 = OnscreenImage(self.statustex1, scale=(0.015, 0.015, 0.015), sort=20, pos=(self.getAspectRatio() - 0.01, 0, -1 + 0.01)) self.taskMgr.add(self.loop, "Primary loop") # Calibration details: self.calibrated_length = 4 * 56.9
def __speedHackCheckTask(task): global lastSpeedHackCheck global lastTrueClockTime global speedHackBeginTime global speedHackMaxTime now = time.time() elapsed = now - lastSpeedHackCheck tcElapsed = TrueClock.getGlobalPtr().getLongTime() - lastTrueClockTime if tcElapsed > (elapsed + timeEpsilon): # Possible speed hacking. if speedHackBeginTime == -1: speedHackBeginTime = now elif now - speedHackBeginTime >= speedHackMaxTime: # The clock discrepancy has been going on for a bit, # they are more than likely speed hacking. print "Detected speed hacks, closing game." sys.exit() return task.done else: speedHackBeginTime = -1 lastSpeedHackCheck = time.time() lastTrueClockTime = TrueClock.getGlobalPtr().getLongTime() return task.cont
def __speedHackCheckTask(task): global lastSpeedHackCheck global lastTrueClockTime elapsed = time.time() - lastSpeedHackCheck tcElapsed = TrueClock.getGlobalPtr().getLongTime() - lastTrueClockTime if tcElapsed > elapsed + 0.05: print 'Detected speed hacks, closing game.' sys.exit() return task.done lastSpeedHackCheck = time.time() lastTrueClockTime = TrueClock.getGlobalPtr().getLongTime() return task.cont
def __init__(self): self.config = getConfigShowbase() vfs = VirtualFileSystem.getGlobalPtr() self.eventMgr = eventMgr self.messenger = messenger self.bboard = bulletinBoard self.taskMgr = taskMgr self.AISleep = self.config.GetFloat('ai-sleep', 0.04) Task.TaskManager.taskTimerVerbose = self.config.GetBool( 'task-timer-verbose', 0) Task.TaskManager.extendedExceptions = self.config.GetBool( 'extended-exceptions', 0) self.sfxManagerList = None self.musicManager = None self.jobMgr = jobMgr self.hidden = NodePath('hidden') self.graphicsEngine = GraphicsEngine.getGlobalPtr() globalClock = ClockObject.getGlobalClock() self.trueClock = TrueClock.getGlobalPtr() globalClock.setRealTime(self.trueClock.getShortTime()) globalClock.setAverageFrameRateInterval(30.0) globalClock.tick() taskMgr.globalClock = globalClock __builtins__['ostream'] = Notify.out() __builtins__['globalClock'] = globalClock __builtins__['vfs'] = vfs __builtins__['hidden'] = self.hidden self.restart()
def startShow(self, cr, launcherServer=None): self.cr = cr if self.display.antialias: render.setAntialias(AntialiasAttrib.MAuto) base.graphicsEngine.renderFrame() self.downloadWatcher = ToontownDownloadWatcher.ToontownDownloadWatcher( TTLocalizer.LauncherPhaseNames) if launcher.isDownloadComplete(): self.cleanupDownloadWatcher() else: self.acceptOnce( 'launcherAllPhasesComplete', self.cleanupDownloadWatcher) gameServer = config.GetString('game-server', '') if gameServer: self.notify.info( 'Using game-server from Configrc: %s ' % gameServer) elif launcherServer: gameServer = launcherServer self.notify.info( 'Using gameServer from launcher: %s ' % gameServer) else: gameServer = 'localhost' serverPort = config.GetInt('server-port', 7198) serverList = [] for name in gameServer.split(';'): url = URLSpec(name, 1) if config.GetBool('server-force-ssl', False): url.setScheme('s') if not url.hasPort(): url.setPort(serverPort) serverList.append(url) if len(serverList) == 1: failover = config.GetString('server-failover', '') serverURL = serverList[0] for arg in failover.split(): try: port = int(arg) url = URLSpec(serverURL) url.setPort(port) except: url = URLSpec(arg, 1) if url != serverURL: serverList.append(url) cr.loginFSM.request('connect', [serverList]) self.ttAccess = ToontownAccess.ToontownAccess() self.ttAccess.initModuleInfo() if config.GetBool('want-speedhack-fix', False): # Start checking for speedhacks. self.lastSpeedhackCheck = time.time() self.trueClock = TrueClock.getGlobalPtr() self.lastTrueClockTime = self.trueClock.getLongTime() taskMgr.add(self.__speedhackCheckTick, 'speedhack-tick')
def startShow(self, cr, launcherServer=None): self.cr = cr if self.display.antialias: render.setAntialias(AntialiasAttrib.MAuto) base.graphicsEngine.renderFrame() self.downloadWatcher = ToontownDownloadWatcher.ToontownDownloadWatcher( TTLocalizer.LauncherPhaseNames) if launcher.isDownloadComplete(): self.cleanupDownloadWatcher() else: self.acceptOnce('launcherAllPhasesComplete', self.cleanupDownloadWatcher) gameServer = config.GetString('game-server', '') if gameServer: self.notify.info('Using game-server from Configrc: %s ' % gameServer) elif launcherServer: gameServer = launcherServer self.notify.info('Using gameServer from launcher: %s ' % gameServer) else: gameServer = 'localhost' serverPort = config.GetInt('server-port', 7198) serverList = [] for name in gameServer.split(';'): url = URLSpec(name, 1) if config.GetBool('server-force-ssl', False): url.setScheme('s') if not url.hasPort(): url.setPort(serverPort) serverList.append(url) if len(serverList) == 1: failover = config.GetString('server-failover', '') serverURL = serverList[0] for arg in failover.split(): try: port = int(arg) url = URLSpec(serverURL) url.setPort(port) except: url = URLSpec(arg, 1) if url != serverURL: serverList.append(url) cr.loginFSM.request('connect', [serverList]) self.ttAccess = ToontownAccess.ToontownAccess() self.ttAccess.initModuleInfo() if config.GetBool('want-speedhack-fix', False): # Start checking for speedhacks. self.lastSpeedhackCheck = time.time() self.trueClock = TrueClock.getGlobalPtr() self.lastTrueClockTime = self.trueClock.getLongTime() taskMgr.add(self.__speedhackCheckTick, 'speedhack-tick')
def __init__(self): self.config = DConfig self.graphicsEngine = GraphicsEngine() globalClock = ClockObject.getGlobalClock() self.trueClock = TrueClock.getGlobalPtr() globalClock.setRealTime(self.trueClock.getShortTime()) globalClock.setAverageFrameRateInterval(30.0) globalClock.tick() __builtins__['globalClock'] = globalClock taskMgr.globalClock = globalClock self.vfs = VirtualFileSystem.getGlobalPtr() __builtins__['vfs'] = self.vfs
######################################## # Filename: SpeedHackChecker.py # Created by: blach (19Apr15) ######################################## import sys import time from panda3d.core import TrueClock lastSpeedHackCheck = time.time() lastTrueClockTime = TrueClock.getGlobalPtr().getLongTime() def __speedHackCheckTask(task): global lastSpeedHackCheck global lastTrueClockTime elapsed = time.time() - lastSpeedHackCheck tcElapsed = TrueClock.getGlobalPtr().getLongTime() - lastTrueClockTime if tcElapsed > (elapsed + 0.05): print "Detected speed hacks, closing game." sys.exit() return task.done lastSpeedHackCheck = time.time() lastTrueClockTime = TrueClock.getGlobalPtr().getLongTime() return task.cont def startChecking(): taskMgr.add(__speedHackCheckTask, "speedHackCheckTask")
class ProfileSession: # class that encapsulates a profile of a single callable using Python's standard # 'profile' module # # defers formatting of profile results until they are requested # # implementation sidesteps memory leak in Python profile module, # and redirects file output to RAM file for efficiency TrueClock = TrueClock.getGlobalPtr() notify = directNotify.newCategory("ProfileSession") def __init__(self, name, func=None, logAfterProfile=False): self._func = func self._name = name self._logAfterProfile = logAfterProfile self._filenameBase = 'profileData-%s-%s' % (self._name, id(self)) self._refCount = 0 # if true, accumulate profile results every time we run # if false, throw out old results every time we run self._aggregate = False self._lines = 500 self._sorts = ['cumulative', 'time', 'calls'] self._callInfo = True self._totalTime = None self._reset() self.acquire() def getReference(self): # call this when you want to store a new reference to this session that will # manage its acquire/release reference count independently of an existing reference self.acquire() return self def acquire(self): self._refCount += 1 def release(self): self._refCount -= 1 if not self._refCount: self._destroy() def _destroy(self): del self._func del self._name del self._filenameBase del self._filenameCounter del self._filenames del self._duration del self._filename2ramFile del self._resultCache del self._successfulProfiles def _reset(self): self._filenameCounter = 0 self._filenames = [] # index of next file to be added to stats object self._statFileCounter = 0 self._successfulProfiles = 0 self._duration = None self._filename2ramFile = {} self._stats = None self._resultCache = {} def _getNextFilename(self): filename = '%s-%s' % (self._filenameBase, self._filenameCounter) self._filenameCounter += 1 return filename def run(self): # make sure this instance doesn't get destroyed inside self._func self.acquire() if not self._aggregate: self._reset() # if we're already profiling, just run the func and don't profile if 'globalProfileSessionFunc' in __builtin__.__dict__: self.notify.warning('could not profile %s' % self._func) result = self._func() if self._duration is None: self._duration = 0. else: # put the function in the global namespace so that profile can find it assert hasattr(self._func, '__call__') __builtin__.globalProfileSessionFunc = self._func __builtin__.globalProfileSessionResult = [None] # set up the RAM file self._filenames.append(self._getNextFilename()) filename = self._filenames[-1] _installProfileCustomFuncs(filename) # do the profiling Profile = profile.Profile statement = 'globalProfileSessionResult[0]=globalProfileSessionFunc()' sort = -1 retVal = None # this is based on profile.run, the code is replicated here to allow us to # eliminate a memory leak prof = Profile() try: prof = prof.run(statement) except SystemExit: pass # this has to be run immediately after profiling for the timings to be accurate # tell the Profile object to generate output to the RAM file prof.dump_stats(filename) # eliminate the memory leak del prof.dispatcher # store the RAM file for later profData = _getProfileResultFileInfo(filename) self._filename2ramFile[filename] = profData # calculate the duration (this is dependent on the internal Python profile data format. # see profile.py and pstats.py, this was copied from pstats.Stats.strip_dirs) maxTime = 0. for cc, nc, tt, ct, callers in profData[1].itervalues(): if ct > maxTime: maxTime = ct self._duration = maxTime # clean up the RAM file support _removeProfileCustomFuncs(filename) # clean up the globals result = globalProfileSessionResult[0] del __builtin__.__dict__['globalProfileSessionFunc'] del __builtin__.__dict__['globalProfileSessionResult'] self._successfulProfiles += 1 if self._logAfterProfile: self.notify.info(self.getResults()) self.release() return result def getDuration(self): return self._duration def profileSucceeded(self): return self._successfulProfiles > 0 def _restoreRamFile(self, filename): # set up the RAM file _installProfileCustomFuncs(filename) # install the stored RAM file from self.run() _setProfileResultsFileInfo(filename, self._filename2ramFile[filename]) def _discardRamFile(self, filename): # take down the RAM file _removeProfileCustomFuncs(filename) # and discard it del self._filename2ramFile[filename] def setName(self, name): self._name = name def getName(self): return self._name def setFunc(self, func): self._func = func def getFunc(self): return self._func def setAggregate(self, aggregate): self._aggregate = aggregate def getAggregate(self): return self._aggregate def setLogAfterProfile(self, logAfterProfile): self._logAfterProfile = logAfterProfile def getLogAfterProfile(self): return self._logAfterProfile def setLines(self, lines): self._lines = lines def getLines(self): return self._lines def setSorts(self, sorts): self._sorts = sorts def getSorts(self): return self._sorts def setShowCallInfo(self, showCallInfo): self._showCallInfo = showCallInfo def getShowCallInfo(self): return self._showCallInfo def setTotalTime(self, totalTime=None): self._totalTime = totalTime def resetTotalTime(self): self._totalTime = None def getTotalTime(self): return self._totalTime def aggregate(self, other): # pull in stats from another ProfileSession other._compileStats() self._compileStats() self._stats.add(other._stats) def _compileStats(self): # make sure our stats object exists and is up-to-date statsChanged = (self._statFileCounter < len(self._filenames)) if self._stats is None: for filename in self._filenames: self._restoreRamFile(filename) self._stats = PercentStats(*self._filenames) self._statFileCounter = len(self._filenames) for filename in self._filenames: self._discardRamFile(filename) else: while self._statFileCounter < len(self._filenames): filename = self._filenames[self._statFileCounter] self._restoreRamFile(filename) self._stats.add(filename) self._discardRamFile(filename) if statsChanged: self._stats.strip_dirs() # throw out any cached result strings self._resultCache = {} return statsChanged def getResults(self, lines=Default, sorts=Default, callInfo=Default, totalTime=Default): if not self.profileSucceeded(): output = '%s: profiler already running, could not profile' % self._name else: if lines is Default: lines = self._lines if sorts is Default: sorts = self._sorts if callInfo is Default: callInfo = self._callInfo if totalTime is Default: totalTime = self._totalTime self._compileStats() if totalTime is None: totalTime = self._stats.total_tt # make sure the arguments will hash efficiently if callers provide different types lines = int(lines) sorts = list(sorts) callInfo = bool(callInfo) totalTime = float(totalTime) k = str((lines, sorts, callInfo, totalTime)) if k in self._resultCache: # we've already created this output string, get it from the cache output = self._resultCache[k] else: # now get human-readable output from the profile stats # capture print output to a string sc = StdoutCapture() # print the info to stdout s = self._stats # make sure our percentages are relative to the correct total time s.setTotalTime(totalTime) for sort in sorts: s.sort_stats(sort) s.print_stats(lines) if callInfo: s.print_callees(lines) s.print_callers(lines) # make a copy of the print output output = sc.getString() # restore stdout to what it was before sc.destroy() # cache this result self._resultCache[k] = output return output
class ProfileSession: TrueClock = TrueClock.getGlobalPtr() notify = directNotify.newCategory('ProfileSession') def __init__(self, name, func=None, logAfterProfile=False): self._func = func self._name = name self._logAfterProfile = logAfterProfile self._filenameBase = 'profileData-%s-%s' % (self._name, id(self)) self._refCount = 0 self._aggregate = False self._lines = 500 self._sorts = ['cumulative', 'time', 'calls'] self._callInfo = True self._totalTime = None self._reset() self.acquire() return def getReference(self): self.acquire() return self def acquire(self): self._refCount += 1 def release(self): self._refCount -= 1 if not self._refCount: self._destroy() def _destroy(self): del self._func del self._name del self._filenameBase del self._filenameCounter del self._filenames del self._duration del self._filename2ramFile del self._resultCache del self._successfulProfiles def _reset(self): self._filenameCounter = 0 self._filenames = [] self._statFileCounter = 0 self._successfulProfiles = 0 self._duration = None self._filename2ramFile = {} self._stats = None self._resultCache = {} return def _getNextFilename(self): filename = '%s-%s' % (self._filenameBase, self._filenameCounter) self._filenameCounter += 1 return filename def run(self): self.acquire() if not self._aggregate: self._reset() if 'globalProfileSessionFunc' in __builtin__.__dict__: self.notify.warning('could not profile %s' % self._func) result = self._func() if self._duration is None: self._duration = 0.0 else: __builtin__.globalProfileSessionFunc = self._func __builtin__.globalProfileSessionResult = [None] self._filenames.append(self._getNextFilename()) filename = self._filenames[-1] _installProfileCustomFuncs(filename) Profile = profile.Profile statement = 'globalProfileSessionResult[0]=globalProfileSessionFunc()' sort = -1 retVal = None prof = Profile() try: prof = prof.run(statement) except SystemExit: pass prof.dump_stats(filename) del prof.dispatcher profData = _getProfileResultFileInfo(filename) self._filename2ramFile[filename] = profData maxTime = 0.0 for cc, nc, tt, ct, callers in profData[1].itervalues(): if ct > maxTime: maxTime = ct self._duration = maxTime _removeProfileCustomFuncs(filename) result = globalProfileSessionResult[0] del __builtin__.__dict__['globalProfileSessionFunc'] del __builtin__.__dict__['globalProfileSessionResult'] self._successfulProfiles += 1 if self._logAfterProfile: self.notify.info(self.getResults()) self.release() return result def getDuration(self): return self._duration def profileSucceeded(self): return self._successfulProfiles > 0 def _restoreRamFile(self, filename): _installProfileCustomFuncs(filename) _setProfileResultsFileInfo(filename, self._filename2ramFile[filename]) def _discardRamFile(self, filename): _removeProfileCustomFuncs(filename) del self._filename2ramFile[filename] def setName(self, name): self._name = name def getName(self): return self._name def setFunc(self, func): self._func = func def getFunc(self): return self._func def setAggregate(self, aggregate): self._aggregate = aggregate def getAggregate(self): return self._aggregate def setLogAfterProfile(self, logAfterProfile): self._logAfterProfile = logAfterProfile def getLogAfterProfile(self): return self._logAfterProfile def setLines(self, lines): self._lines = lines def getLines(self): return self._lines def setSorts(self, sorts): self._sorts = sorts def getSorts(self): return self._sorts def setShowCallInfo(self, showCallInfo): self._showCallInfo = showCallInfo def getShowCallInfo(self): return self._showCallInfo def setTotalTime(self, totalTime=None): self._totalTime = totalTime def resetTotalTime(self): self._totalTime = None return def getTotalTime(self): return self._totalTime def aggregate(self, other): other._compileStats() self._compileStats() self._stats.add(other._stats) def _compileStats(self): statsChanged = self._statFileCounter < len(self._filenames) if self._stats is None: for filename in self._filenames: self._restoreRamFile(filename) self._stats = PercentStats(*self._filenames) self._statFileCounter = len(self._filenames) for filename in self._filenames: self._discardRamFile(filename) else: while self._statFileCounter < len(self._filenames): filename = self._filenames[self._statFileCounter] self._restoreRamFile(filename) self._stats.add(filename) self._discardRamFile(filename) if statsChanged: self._stats.strip_dirs() self._resultCache = {} return statsChanged def getResults(self, lines=Default, sorts=Default, callInfo=Default, totalTime=Default): if not self.profileSucceeded(): output = '%s: profiler already running, could not profile' % self._name else: if lines is Default: lines = self._lines if sorts is Default: sorts = self._sorts if callInfo is Default: callInfo = self._callInfo if totalTime is Default: totalTime = self._totalTime self._compileStats() if totalTime is None: totalTime = self._stats.total_tt lines = int(lines) sorts = list(sorts) callInfo = bool(callInfo) totalTime = float(totalTime) k = str((lines, sorts, callInfo, totalTime)) if k in self._resultCache: output = self._resultCache[k] else: sc = StdoutCapture() s = self._stats s.setTotalTime(totalTime) for sort in sorts: s.sort_stats(sort) s.print_stats(lines) if callInfo: s.print_callees(lines) s.print_callers(lines) output = sc.getString() sc.destroy() self._resultCache[k] = output return output
def __init__(self): DirectObject.__init__(self) if ConfigVariableBool("want-pstats", False): PStatClient.connect() self.docTitle = "" self.viewportName = "" self.renderRequested = False ################################################################### # Minimal emulation of ShowBase glue code. Note we're not using # ShowBase because there's too much going on in there that assumes # too much (one camera, one lens, one aspect2d, lots of bloat). self.graphicsEngine = GraphicsEngine.getGlobalPtr() self.pipe = GraphicsPipeSelection.getGlobalPtr().makeDefaultPipe() if not self.pipe: self.notify.error("No graphics pipe is available!") return self.globalClock = ClockObject.getGlobalClock() # Since we have already started up a TaskManager, and probably # a number of tasks; and since the TaskManager had to use the # TrueClock to tell time until this moment, make sure the # globalClock object is exactly in sync with the TrueClock. trueClock = TrueClock.getGlobalPtr() self.globalClock.setRealTime(trueClock.getShortTime()) self.globalClock.tick() builtins.globalClock = self.globalClock self.loader = CogInvasionLoader(self) self.graphicsEngine.setDefaultLoader(self.loader.loader) builtins.loader = self.loader self.taskMgr = taskMgr builtins.taskMgr = self.taskMgr self.dgTrav = DataGraphTraverser() self.dataRoot = NodePath("data") self.hidden = NodePath("hidden") self.aspect2d = NodePath("aspect2d") builtins.aspect2d = self.aspect2d # Messages that are sent regardless of the active document. self.messenger = messenger builtins.messenger = self.messenger builtins.base = self builtins.hidden = self.hidden ################################################################### self.clickTrav = CollisionTraverser() # All open documents. self.documents = [] # The focused document. self.document = None TextNode.setDefaultFont( loader.loadFont("resources/models/fonts/consolas.ttf")) self.initialize()
# Embedded file name: lib.coginvasion.base.SpeedHackChecker """ Filename: SpeedHackChecker.py Created by: blach (19Apr15) """ import sys import time from panda3d.core import TrueClock lastSpeedHackCheck = time.time() lastTrueClockTime = TrueClock.getGlobalPtr().getLongTime() def __speedHackCheckTask(task): global lastSpeedHackCheck global lastTrueClockTime elapsed = time.time() - lastSpeedHackCheck tcElapsed = TrueClock.getGlobalPtr().getLongTime() - lastTrueClockTime if tcElapsed > elapsed + 0.05: print 'Detected speed hacks, closing game.' sys.exit() return task.done lastSpeedHackCheck = time.time() lastTrueClockTime = TrueClock.getGlobalPtr().getLongTime() return task.cont def startChecking(): taskMgr.add(__speedHackCheckTask, 'speedHackCheckTask')
def __init__(self): #: The directory containing the main Python file of this application. self.mainDir = ExecutionEnvironment.getEnvironmentVariable("MAIN_DIR") self.main_dir = self.mainDir self.wantStats = self.config.GetBool('want-pstats', 0) # Do you want to enable a fixed simulation timestep? Setting this true # only means that the builtin resetPrevTransform and collisionLoop # tasks are added onto the simTaskMgr instead of taskMgr, which runs at # a fixed time step. You can still add your own fixed timestep tasks # when this is false, it only has to do with builtin simulation tasks. self.fixedSimulationStep = self.config.GetBool( 'want-fixed-simulation-step', 0) #: The global event manager, as imported from `.EventManagerGlobal`. self.eventMgr = eventMgr #: The global messenger, as imported from `.MessengerGlobal`. self.messenger = messenger #: The global bulletin board, as imported from `.BulletinBoardGlobal`. self.bboard = bulletinBoard #: The global task manager, as imported from `.TaskManagerGlobal`. self.taskMgr = taskMgr self.task_mgr = taskMgr #: The global simulation task manager, as imported from `.TaskManagerGlobal` self.simTaskMgr = simTaskMgr self.sim_task_mgr = simTaskMgr #: The global job manager, as imported from `.JobManagerGlobal`. self.jobMgr = jobMgr #: `.Loader.Loader` object. self.loader = Loader(self) # Get a pointer to Panda's global ClockObject, used for # synchronizing events between Python and C. globalClock = ClockObject.getGlobalClock() # We will manually manage the clock globalClock.setMode(ClockObject.MSlave) self.globalClock = globalClock # Since we have already started up a TaskManager, and probably # a number of tasks; and since the TaskManager had to use the # TrueClock to tell time until this moment, make sure the # globalClock object is exactly in sync with the TrueClock. trueClock = TrueClock.getGlobalPtr() self.trueClock = trueClock globalClock.setRealTime(trueClock.getShortTime()) globalClock.tick() # Now we can make the TaskManager start using the new globalClock. taskMgr.globalClock = globalClock simTaskMgr.globalClock = globalClock vfs = VirtualFileSystem.getGlobalPtr() self.vfs = vfs # Make sure we're not making more than one HostBase. if hasattr(builtins, 'base'): raise Exception("Attempt to spawn multiple HostBase instances!") # DO NOT ADD TO THIS LIST. We're trying to phase out the use of # built-in variables by ShowBase. Use a Global module if necessary. builtins.base = self builtins.taskMgr = self.taskMgr builtins.simTaskMgr = self.simTaskMgr builtins.jobMgr = self.jobMgr builtins.eventMgr = self.eventMgr builtins.messenger = self.messenger builtins.bboard = self.bboard builtins.loader = self.loader # Config needs to be defined before ShowBase is constructed #builtins.config = self.config builtins.ostream = Notify.out() builtins.directNotify = directNotify builtins.giveNotify = giveNotify builtins.globalClock = globalClock builtins.vfs = vfs builtins.cpMgr = ConfigPageManager.getGlobalPtr() builtins.cvMgr = ConfigVariableManager.getGlobalPtr() builtins.pandaSystem = PandaSystem.getGlobalPtr() # Now add this instance to the ShowBaseGlobal module scope. from . import ShowBaseGlobal builtins.run = ShowBaseGlobal.run ShowBaseGlobal.base = self # What is the current frame number? self.frameCount = 0 # Time at beginning of current frame self.frameTime = self.globalClock.getRealTime() # How long did the last frame take. self.deltaTime = 0 # # Variables pertaining to simulation ticks. # self.prevRemainder = 0 self.remainder = 0 # What is the current overall simulation tick? self.tickCount = 0 # How many ticks are we going to run this frame? self.totalTicksThisFrame = 0 # How many ticks have we run so far this frame? self.currentTicksThisFrame = 0 # What tick are we currently on this frame? self.currentFrameTick = 0 # How many simulations ticks are we running per-second? self.ticksPerSec = 60 self.intervalPerTick = 1.0 / self.ticksPerSec self.taskMgr.finalInit()
########### fish_index = 0 user_prefix = 'LS100_' ##!! ########### # -*- coding: utf-8 -*- if __name__ == "__main__": import sys import numpy as np from multiprocessing import Value, Array, Queue from panda3d.core import TrueClock TrueClock.getGlobalPtr().setCpuAffinity(0xFFFFFFFF) from camera_alignment_gui import GUI_Process gui = GUI_Process(fish_index) gui.start() from direct.showbase.ShowBase import ShowBase from panda3d.core import * import numpy as np import sys import time import os import pickle import socket