def __init__(self, filename): vfs = VirtualFileSystem.getGlobalPtr() self.material = BSPMaterial.getFromFile(filename) self.filename = filename if self.material.hasKeyvalue("$basetexture"): baseTexturePath = Filename( self.material.getKeyvalue("$basetexture")) if vfs.resolveFilename(baseTexturePath, getModelPath().getValue()): imageData = bytes(VirtualFileSystem.getGlobalPtr().readFile( baseTexturePath, True)) byteArray = QtCore.QByteArray.fromRawData(imageData) image = QtGui.QImage.fromData(byteArray) self.pixmap = QtGui.QPixmap.fromImage(image) self.icon = QtGui.QIcon(self.pixmap) self.size = LVector2i(image.width(), image.height()) else: self.texture = None self.size = LVector2i(64, 64) self.icon = None self.pixmap = None else: self.texture = None self.size = LVector2i(64, 64) self.icon = None self.pixmap = None
def __init__(self, scale, position, function, default=0): VirtualFileSystem.getGlobalPtr().mount(Filename("mf/checkbox.mf"), ".", VirtualFileSystem.MFReadOnly) self.egg = loader.loadModel("checkbox/checkbox.egg") box_image = (self.egg.find("**/check-empty"), self.egg.find("**/check-checked"), None) self.button = DirectCheckButton(boxImage=box_image, boxRelief=None, relief=None, command=function, scale=scale, pos=position)
def destroy(self): VirtualFileSystem.getGlobalPtr().unmount("mf/alert.mf") VirtualFileSystem.getGlobalPtr().unmount("mf/ok_small.mf") self.bg_frame.destroy() self.frame.destroy() self.button.destroy() self.text.cleanup() self.text.destroy() del self.frame del self.button del self.text del self
def __init__(self, style): """ Timer class with fun pictures @param style: 0 = SUN, 1 = MOON, 2 = GUN @type style: int """ self.style = style VirtualFileSystem.getGlobalPtr().mount(Filename("mf/timer.mf"), ".", VirtualFileSystem.MFReadOnly) self.egg = loader.loadModel("timer.egg") self.img = None self.interval = None self.types[style](self)
def mount(self): """ Inits the VFS Mounts """ self.debug("Setting up virtual filesystem.") vfs = VirtualFileSystem.getGlobalPtr() # Mount shaders vfs.mountLoop( join(self.basePath, 'Shader'), 'Shader', 0) # Mount data and models vfs.mountLoop(join(self.basePath, 'Data'), 'Data', 0) vfs.mountLoop(join(self.basePath, 'Models'), 'Models', 0) vfs.mountLoop(join(self.basePath, 'Config'), 'Config', 0) vfs.mountLoop(join(self.basePath, 'Demoscene.ignore'), 'Demoscene.ignore', 0) # Just mount everything # vfs.mountLoop(self.basePath, '.', 0) if not isdir(self.writePath): self.debug("Creating temp path, as it does not exist yet") try: makedirs(self.writePath) except Exception, msg: self.error("Failed to create temp path:",msg) import sys sys.exit(0)
def __init__(self, filename): vfs = VirtualFileSystem.getGlobalPtr() #self.material = BSPMaterial.getFromFile(filename) self.material = TexturePool.loadTexture(filename) self.filename = filename if self.material: #.hasKeyvalue("$basetexture"): # baseTexturePath = self.material.getKeyvalue("$basetexture") if True: #vfs.exists(baseTexturePath): #imageData = bytes(VirtualFileSystem.getGlobalPtr().readFile(baseTexturePath, True)) pimage = PNMImage() self.material.store(pimage, 0, 0) ss = StringStream() pimage.write(ss, "tmp.png") imageData = bytes(ss) byteArray = QtCore.QByteArray.fromRawData(imageData) image = QtGui.QImage.fromData(byteArray) self.pixmap = QtGui.QPixmap.fromImage(image) self.icon = QtGui.QIcon(self.pixmap) self.size = LVector2i(pimage.getXSize(), pimage.getYSize()) print(pimage, self.size) else: self.size = LVector2i(64, 64) self.icon = None self.pixmap = None else: self.size = LVector2i(64, 64) self.icon = None self.pixmap = None
def reloadTextures(textureName=""): """ Artfart command to reload all of the textures. TODO: A panel that says "Reloading textures... Please wait!" ...though it's not important since it's a staff command and only staff will see it. Stolen from ToontownStart.py Remount all phase files. This maybe might work? Idk. Lets see if Panda craps itself. Place raw files in /resources/non-mf/phase_*/ and they will be mounted without needing to multify! """ # Lock ... vfs = VirtualFileSystem.getGlobalPtr() for file in glob.glob("resources/non-mf/phase_*/"): # Slightly hacky. We remove the trailing slash so we have a tail, # and select the tail value from the returned tuple. Finally we # prepend a slash for the mount point. mount_point = "/" + str(os.path.split(file[:-1])[1]) vfs.mount(Filename(file), Filename(mount_point), 0) # ... and load. if textureName: pool = TexturePool.findAllTextures("*" + textureName + "*") else: pool = TexturePool.findAllTextures() for texture in pool: texture.reload() if textureName: return "Reloaded all textures matching '%s'" % textureName return "Reloaded all of the textures!"
def main(): args = parse_args() if args.frames: animations_frames = map(int, args.frames.split(',')) else: animations_frames = [len(args.input)] kwargs = {} if args.fps: kwargs['fps'] = args.fps if args.scale: kwargs['scale'] = args.scale if args.type: kwargs['type'] = args.type if args.empty: kwargs['empty'] = args.empty if args.prefix: kwargs['prefix'] = args.prefix if args.prefix: vfs = VirtualFileSystem.get_global_ptr() vfs.mount( Filename.from_os_specific('.').get_fullpath(), args.prefix.rstrip('/'), 0) mp = get_model_path() mp.prepend_directory(args.prefix.rstrip('/')) cm = CardMaker(animations_frames, args.input, **kwargs) cm.make(args.output)
def __init__(self, app=None, dt=None): self.app = app or ShowBase() self.app.accept('escape', sys.exit) self.root_node = self.app.render self._dt = 0.1 if dt is None else dt # setup visualization camera vfov = 45 hfov = vfov * float(self.app.win.getSize()[0]) / float( self.app.win.getSize()[1]) self.app.camLens.setFov(hfov, vfov) self.app.camLens.set_near_far(0.01, 10000.0) # 1cm to 10km # The VirtualFileSystem, which has already initialized, doesn't see the mount # directives in the config(s) yet. We have to force it to load those manually: vfs = VirtualFileSystem.getGlobalPtr() mounts = ConfigVariableList('vfs-mount') for mount_desc in mounts: mount_desc = mount_desc.split(' ') physical_filename, mount_point = mount_desc[:2] physical_filename = os.path.expandvars(physical_filename) mount_point = os.path.expandvars(mount_point) if len(mount_desc) > 2: options = mount_desc[2] else: options = '' vfs.mount(Filename(physical_filename), Filename(mount_point), *parse_options(options))
def reloadTextures(textureName=''): """ Artfart command to reload all of the textures. TODO: A panel that says "Reloading textures... Please wait!" ...though it's not important since it's a staff command and only staff will see it. Stolen from ToontownStart.py Remount all phase files. This maybe might work? Idk. Lets see if Panda craps itself. Place raw files in /resources/non-mf/phase_*/ and they will be mounted without needing to multify! """ # Lock ... vfs = VirtualFileSystem.getGlobalPtr() for file in glob.glob('resources/non-mf/phase_*/'): # Slightly hacky. We remove the trailing slash so we have a tail, # and select the tail value from the returned tuple. Finally we # prepend a slash for the mount point. mount_point = '/' + str(os.path.split(file[:-1])[1]) vfs.mount(Filename(file), Filename(mount_point), 0) # ... and load. if textureName: pool = TexturePool.findAllTextures('*' + textureName + '*') else: pool = TexturePool.findAllTextures() for texture in pool: texture.reload() if textureName: return "Reloaded all textures matching '%s'" % textureName return "Reloaded all of the textures!"
def load(self, filename): """ Loads a profile from a given filename """ # Make filename unique fname = Filename.from_os_specific(filename) if not VirtualFileSystem.get_global_ptr().resolve_filename(fname, get_model_path().get_value(), "ies"): self.error("Could not resolve", filename) return -1 fname = fname.get_fullpath() # Check for cache entries if fname in self._entries: return self._entries.index(fname) # Check for out of bounds if len(self._entries) >= self._max_entries: # TODO: Could remove unused profiles here or regenerate texture self.warn("Cannot load IES Profile, too many loaded! (Maximum: 32)") # Try loading the dataset, and see what happes try: dataset = self._loader.load(fname) except IESLoaderException as msg: self.warn("Failed to load profile from", filename, ":", msg) return -1 if not dataset: return -1 # Dataset was loaded successfully, now copy it dataset.generate_dataset_texture_into(self._storage_tex, len(self._entries)) self._entries.append(fname) return len(self._entries) - 1
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 __init__(self): self.loadDefaultConfig() self.loadLocalConfig() if ConfigVariableBool("want-pstats", False): PStatClient.connect() # Set up some global objects self.globalClock = ClockObject.getGlobalClock() # We will manually manage the clock self.globalClock.setMode(ClockObject.MSlave) builtins.globalClock = self.globalClock self.vfs = VirtualFileSystem.getGlobalPtr() # For tasks that run every application frame self.taskMgr = TaskManagerGlobal.taskMgr builtins.taskMgr = self.taskMgr # For tasks that run every simulation tick self.simTaskMgr = Task.TaskManager() self.simTaskMgr.mgr = AsyncTaskManager("sim") builtins.simTaskmgr = self.simTaskMgr self.eventMgr = EventManagerGlobal.eventMgr builtins.eventMgr = self.eventMgr self.messenger = MessengerGlobal.messenger builtins.messenger = self.messenger self.loader = Loader(self) builtins.loader = self.loader builtins.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
def load_assets(self): filename = "assets.mf" correct_md5 = '9f733c91cc681a1d1c8108d238a0a50b' read_md5 = y_md5_check.md5_sum(filename) assert read_md5 == correct_md5 vfs = VirtualFileSystem.getGlobalPtr() if vfs.mount(filename, ".", VirtualFileSystem.MFReadOnly): print('mounted')
def mount_multifile(self): mf = Multifile() mf.open_read(Filename.from_os_specific('phase_1.ef')) mf.set_encryption_flag(True) mf.set_encryption_password(self.PW) if not VirtualFileSystem.get_global_ptr().mount(mf, Filename('/'), 0): raise Exception('Multifile could not be mounted.')
def dummyAppRunner(tokens=[], argv=None): """ This function creates a dummy global AppRunner object, which is useful for testing running in a packaged environment without actually bothering to package up the application. Call this at the start of your application to enable it. It places the current working directory under /mf, as if it were mounted from a packed multifile. It doesn't convert egg files to bam files, of course; and there are other minor differences from running in an actual packaged environment. But it can be a useful first-look sanity check. """ if AppRunnerGlobal.appRunner: print("Already have AppRunner, not creating a new one.") return AppRunnerGlobal.appRunner appRunner = AppRunner() appRunner.dummy = True AppRunnerGlobal.appRunner = appRunner platform = PandaSystem.getPlatform() version = PandaSystem.getPackageVersionString() hostUrl = PandaSystem.getPackageHostUrl() if platform.startswith('win'): rootDir = Filename(Filename.getUserAppdataDirectory(), 'Panda3D') elif platform.startswith('osx'): rootDir = Filename(Filename.getHomeDirectory(), 'Library/Caches/Panda3D') else: rootDir = Filename(Filename.getHomeDirectory(), '.panda3d') appRunner.rootDir = rootDir appRunner.logDirectory = Filename(rootDir, 'log') # Of course we will have the panda3d application loaded. appRunner.addPackageInfo('panda3d', platform, version, hostUrl) appRunner.tokens = tokens appRunner.tokenDict = dict(tokens) if argv is None: argv = sys.argv appRunner.argv = argv appRunner.altHost = appRunner.tokenDict.get('alt_host', None) appRunner.p3dInfo = None appRunner.p3dPackage = None # Mount the current directory under the multifileRoot, as if it # were coming from a multifile. cwd = ExecutionEnvironment.getCwd() vfs = VirtualFileSystem.getGlobalPtr() vfs.mount(cwd, appRunner.multifileRoot, vfs.MFReadOnly) appRunner.initPackedAppEnvironment() return appRunner
def qtResolvePath(filename): """ Resolves a filename path using the Panda model-path and returns an OS-specific absolute path. Used to load Qt icons from stuff on model-path. """ filename = Filename.fromOsSpecific(filename) vfs = VirtualFileSystem.getGlobalPtr() vfs.resolveFilename(filename, getModelPath().getValue()) return filename.toOsSpecific()
def loadWhiteListData(): global WhiteListData if WhiteListData is None: vfs = VirtualFileSystem.getGlobalPtr() whitelistFile = vfs.readFile('phase_3/etc/ciwhitelist.dat', False) WhiteListData = set() for word in whitelistFile.split(): WhiteListData.add(word) del whitelistFile
def load(self): DistributedEntityAI.load(self) from panda3d.core import VirtualFileSystem vfs = VirtualFileSystem.getGlobalPtr() self.scriptSrc = vfs.readFile(self.scriptFilename, True) self.target = self.bspLoader.getPyEntityByTargetName( self.getEntityValue("scriptTarget"))
def dummyAppRunner(tokens = [], argv = None): """ This function creates a dummy global AppRunner object, which is useful for testing running in a packaged environment without actually bothering to package up the application. Call this at the start of your application to enable it. It places the current working directory under /mf, as if it were mounted from a packed multifile. It doesn't convert egg files to bam files, of course; and there are other minor differences from running in an actual packaged environment. But it can be a useful first-look sanity check. """ if AppRunnerGlobal.appRunner: print("Already have AppRunner, not creating a new one.") return AppRunnerGlobal.appRunner appRunner = AppRunner() appRunner.dummy = True AppRunnerGlobal.appRunner = appRunner platform = PandaSystem.getPlatform() version = PandaSystem.getPackageVersionString() hostUrl = PandaSystem.getPackageHostUrl() if platform.startswith('win'): rootDir = Filename(Filename.getUserAppdataDirectory(), 'Panda3D') elif platform.startswith('osx'): rootDir = Filename(Filename.getHomeDirectory(), 'Library/Caches/Panda3D') else: rootDir = Filename(Filename.getHomeDirectory(), '.panda3d') appRunner.rootDir = rootDir appRunner.logDirectory = Filename(rootDir, 'log') # Of course we will have the panda3d application loaded. appRunner.addPackageInfo('panda3d', platform, version, hostUrl) appRunner.tokens = tokens appRunner.tokenDict = dict(tokens) if argv is None: argv = sys.argv appRunner.argv = argv appRunner.altHost = appRunner.tokenDict.get('alt_host', None) appRunner.p3dInfo = None appRunner.p3dPackage = None # Mount the current directory under the multifileRoot, as if it # were coming from a multifile. cwd = ExecutionEnvironment.getCwd() vfs = VirtualFileSystem.getGlobalPtr() vfs.mount(cwd, appRunner.multifileRoot, vfs.MFReadOnly) appRunner.initPackedAppEnvironment() return appRunner
def __init__(self): self.packPath = 'resources/contentpacks/' if not os.path.exists(self.packPath): os.makedirs(self.packPath) self.sortFile = os.path.join(self.packPath, 'pack-load-order.yaml') if not os.path.exists(self.sortFile): open(self.sortFile, 'a').close() self.mountPoint = '/' self.vfSys = VirtualFileSystem.getGlobalPtr() self.sort = []
def __init__(self, reason): Notifier.__init__(self, "alert") VirtualFileSystem.getGlobalPtr().mount(Filename("mf/alert.mf"), ".", VirtualFileSystem.MFReadOnly) ok = loader.loadModel("alert.egg") if reason not in LOCAL_EN: reason = GENERAL self.reason = reason self.bg_frame = DirectFrame(frameColor=(0, 0, 0, 0), frameSize=(-1, 1, -1, 1), suppressMouse=1, state=DGG.NORMAL, sortOrder=1000) self.frame = DirectFrame(frameSize=(1, 1, 1, 1), image=ok.find('**/alert'), image_scale=(1, 0, 0.6), state=DGG.NORMAL, parent=self.bg_frame) self.text = OnscreenText(text=LOCAL_EN[reason], fg=(1, 1, 1, 1), pos=(0, 0.15, 0), align=TextNode.ACenter, wordwrap=13, parent=self.frame) self.button = DirectButton(geom=(ok.find('**/ok-ready'), ok.find('**/ok-click'), ok.find('**/ok-hover'), ok.find('**/ok-click')), relief=None, geom_scale=(0.3, 0, 0.15), geom_pos=(0, 0, -0.175), pressEffect=0, command=self.destroy, parent=self.frame) self.notify.debug( f"[__init__] Created Alert with reason {self.reason}") loader.unloadModel(ok)
def ramdir(): """Fixture yielding a fresh ramdisk directory.""" from panda3d.core import VirtualFileMountRamdisk, Filename vfs = VirtualFileSystem.get_global_ptr() mount = VirtualFileMountRamdisk() dir = Filename.temporary("/virtual", "ram.") assert vfs.mount(mount, dir, 0) yield dir vfs.unmount(mount)
def __init__(self, filepath): self.filepath = filepath self.vfs = VirtualFileSystem.getGlobalPtr() if __debug__: self.mountPoint = "../resources" else: self.mountPoint = "/" self.sortOrder = []
def loadText(self): # Load database vfs = VirtualFileSystem.getGlobalPtr() #print "Virtual fs" ,vfs.lsAll('/mf') path = vfs.findFile('TXT_UI_Common.yaml', '.') if not path: path = vfs.findFile('TXT_UI_Common.yaml', '/mf') stream = vfs.readFile(path.getFilename(), True) textDictionary = yaml.load(stream) for key in textDictionary: self.database[key] = textDictionary[key]
def exit_game(self): """ Use this to close the game. Closes connection and tells server we're leaving """ VirtualFileSystem.getGlobalPtr().unmount("mf/pawns.mf") VirtualFileSystem.getGlobalPtr().unmount("mf/timer.mf") for level in self.levels: self.levels[level].destroy() if self.console is not None: self.console.destroy() if self.messager.my_connection is None or self.messager.pid is None: sys.exit() # tell server self.write(dg_goodbye(self.messager.pid)) self.messager.cManager.closeConnection(self.messager.my_connection) sys.exit()
def precacheMusicDir(musicDir, extension = "ogg"): global Cache vfs = VirtualFileSystem.getGlobalPtr() songList = vfs.scanDirectory(musicDir) if not songList: print("No music in {0}".format(musicDir)) return for vFile in songList.getFiles(): fn = vFile.getFilename() if fn.getExtension() == extension: Cache[fn.getBasenameWoExtension()] = fn.getFullpath()
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
def __init__(self, filepath='contentpacks/', sortFilename='sort.yaml'): self.filepath = filepath self.sortFilename = os.path.join(self.filepath, sortFilename) if __debug__: self.mountPoint = '../resources' else: self.mountPoint = '/' self.vfs = VirtualFileSystem.getGlobalPtr() self.sort = [] self.ambience = {}
def ReadResponse(self, dataOut, bytesToRead, bytesReadOut, callback): if self.contents is None: self.contents = VirtualFileSystem.getGlobalPtr().readFile(self.filePath, False) if self.offset < len(self.contents): dataOut[0] = self.contents[self.offset:self.offset + bytesToRead] bytesReadOut[0] = bytesToRead self.offset += bytesToRead return True # We are done self.clientHandler._ReleaseStrongReference(self) return False
def reloadTextures(textureName=''): vfs = VirtualFileSystem.getGlobalPtr() for file in glob.glob('resources/non-mf/phase_*/'): mount_point = '/' + str(os.path.split(file[:-1])[1]) vfs.mount(Filename(file), Filename(mount_point), 0) if textureName: pool = TexturePool.findAllTextures('*' + textureName + '*') else: pool = TexturePool.findAllTextures() for texture in pool: texture.reload() if textureName: return "Reloaded all textures matching '%s'" % textureName return 'Reloaded all of the textures!'
def GetResponseHeaders(self, response, responseLengthOut, redirectUrlOut): """ :type response: cefpython.PyResponse """ response.SetMimeType(getMimeType(self.url)) file = VirtualFileSystem.getGlobalPtr().getFile(self.filePath) if file is None: response.SetStatus(404) response.SetStatusText("File not found") return responseLengthOut[0] = file.getFileSize()
def load_3d_texture(cls, fname, tile_size_x, tile_size_y=None, num_tiles=None): """ Loads a texture from the given filename and dimensions. If only one dimensions is specified, the other dimensions are assumed to be equal. This internally loads the texture into ram, splits it into smaller sub-images, and then calls the load_3d_texture from the Panda loader """ # Generate a unique name to prevent caching tempfile_name = "$$SliceLoaderTemp-" + str(time.time()) + "/" # For quaddratic textures tile_size_y = tile_size_x if tile_size_y is None else tile_size_y num_tiles = tile_size_x if num_tiles is None else num_tiles # Load sliced image from disk source = PNMImage(fname) width = source.get_x_size() # Find slice properties num_cols = width // tile_size_x temp = PNMImage( tile_size_x, tile_size_y, source.get_num_channels(), source.get_maxval()) # Construct a ramdisk to write the files to vfs = VirtualFileSystem.get_global_ptr() ramdisk = VirtualFileMountRamdisk() vfs.mount(ramdisk, tempfile_name, 0) # Extract all slices and write them to the virtual disk for z_slice in range(num_tiles): slice_x = (z_slice % num_cols) * tile_size_x slice_y = (z_slice // num_cols) * tile_size_y temp.copy_sub_image(source, 0, 0, slice_x, slice_y, tile_size_x, tile_size_y) temp.write(tempfile_name + str(z_slice) + ".png") # Load the de-sliced texture from the ramdisk texture_handle = Globals.loader.load3DTexture(tempfile_name + "/#.png") # This should never trigger, but can't hurt to have assert texture_handle.get_x_size() == tile_size_x assert texture_handle.get_y_size() == tile_size_y assert texture_handle.get_z_size() == num_tiles # Finally unmount the ramdisk vfs.unmount(ramdisk) return texture_handle
def __init__(self, menu): base.transitions.fadeScreen(1.0) vfs = VirtualFileSystem.getGlobalPtr() creditsTextStr = str(vfs.readFile("scripts/credits.txt", True)) self.creditsText = OnscreenText(text=creditsTextStr, fg=(1, 1, 1, 1), align=TextNode.ACenter, mayChange=False, scale=0.06) self.creditsText.reparentTo(aspect2d, DGG.FADE_SORT_INDEX + 1) self.creditsText.setZ(-1) self.ival = Sequence( LerpPosInterval(self.creditsText, 20.0, (0, 0, 2.6), (0, 0, -1.0)), Func(self.done)) self.ival.start() self.acceptOnce('space', self.done) self.menu = menu
def mount(self): """ Inits the VFS Mounts. This creates the following virtual directory structure, from which all files can be located: /$$rp/ (Mounted from the render pipeline base directory) + config/ + data/ + rpcore/ + shader/ + ... /$$rptemp/ (Either ramdisk or user specified) + day_time_config + shader_auto_config + ... """ self.debug("Setting up virtual filesystem") self._mounted = True def convert_path(pth): return Filename.from_os_specific(pth).get_fullpath() vfs = VirtualFileSystem.get_global_ptr() # Mount the pipeline temp path: # If no write path is specified, use a virtual ramdisk if self._write_path is None: self.debug("Mounting ramdisk as /$$rptemp") vfs.mount(VirtualFileMountRamdisk(), "/$$rptemp", 0) else: # In case an actual write path is specified: # Ensure the pipeline write path exists, and if not, create it if not isdir(self._write_path): self.debug( "Creating temporary path, since it does not exist yet") try: os.makedirs(self._write_path) except IOError as msg: self.fatal("Failed to create temporary path:", msg) self.debug("Mounting", self._write_path, "as /$$rptemp") vfs.mount(convert_path(self._write_path), '/$$rptemp', 0) get_model_path().prepend_directory("/$$rp") get_model_path().prepend_directory("/$$rp/shader") get_model_path().prepend_directory("/$$rptemp")
def readFavIcon(self): vfs = VirtualFileSystem.getGlobalPtr() filename = Filename('favicon.ico') searchPath = DSearchPath() searchPath.appendDirectory(Filename('.')) searchPath.appendDirectory(Filename('etc')) searchPath.appendDirectory(Filename.fromOsSpecific(os.path.expandvars('$DIRECT/src/http'))) searchPath.appendDirectory(Filename.fromOsSpecific(os.path.expandvars('direct/src/http'))) searchPath.appendDirectory(Filename.fromOsSpecific(os.path.expandvars('direct/http'))) searchPath.appendDirectory(Filename('game/resources/http')) searchPath.appendDirectory(Filename('resources/http')) found = vfs.resolveFilename(filename,searchPath) if not found: raise Exception("Couldn't find direct/http/favicon.ico") return vfs.readFile(filename, 1)
def findAllModelFilesInVFS(phase_array): models = [] vfs = VirtualFileSystem.getGlobalPtr() for phase in phase_array: fileList = vfs.scanDirectory(Filename(phase)) for fileName in fileList: if fileName.get_filename().get_fullpath().endswith('.bam') or fileName.get_filename().get_fullpath().endswith('.egg') or fileName.get_filename().get_fullpath().endswith('.pz'): if fileName.get_filename().get_fullpath() not in models: models.append(fileName.get_filename().get_fullpath()) else: fileList2 = vfs.scanDirectory(Filename(fileName.get_filename().get_fullpath())) for fileName2 in fileList2: if fileName2.get_filename().get_fullpath().endswith('.bam') or fileName2.get_filename().get_fullpath().endswith('.egg') or fileName2.get_filename().get_fullpath().endswith('.pz'): if fileName2.get_filename().get_fullpath() not in models: models.append(fileName2.get_filename().get_fullpath()) return models
def fromFile(self, packageDir, filename, pathname = None, st = None): """ Reads the file information from the indicated file. If st is supplied, it is the result of os.stat on the filename. """ vfs = VirtualFileSystem.getGlobalPtr() filename = Filename(filename) if pathname is None: pathname = Filename(packageDir, filename) self.filename = str(filename) self.basename = filename.getBasename() if st is None: st = os.stat(pathname.toOsSpecific()) self.size = st.st_size self.timestamp = int(st.st_mtime) self.readHash(pathname)
def initPackedAppEnvironment(self): """ This function sets up the Python environment suitably for running a packed app. It should only run once in any given session (and it includes logic to ensure this). """ if self.packedAppEnvironmentInitialized: return self.packedAppEnvironmentInitialized = True vfs = VirtualFileSystem.getGlobalPtr() # Now set up Python to import this stuff. VFSImporter.register() sys.path.append(self.multifileRoot) # Make sure that $MAIN_DIR is set to the p3d root before we # start executing the code in this file. ExecutionEnvironment.setEnvironmentVariable("MAIN_DIR", Filename(self.multifileRoot).toOsSpecific()) # Put our root directory on the model-path, too. getModelPath().appendDirectory(self.multifileRoot) if not self.trueFileIO: # Replace the builtin open and file symbols so user code will get # our versions by default, which can open and read files out of # the multifile. builtins.open = file.open if sys.version_info < (3, 0): builtins.file = file.open builtins.execfile = file.execfile os.listdir = file.listdir os.walk = file.walk os.path.join = file.join os.path.isfile = file.isfile os.path.isdir = file.isdir os.path.exists = file.exists os.path.lexists = file.lexists os.path.getmtime = file.getmtime os.path.getsize = file.getsize sys.modules["glob"] = glob self.checkDiskUsage()
def mount(self): """ Inits the VFS Mounts """ self.debug("Setting up virtual filesystem.") vfs = VirtualFileSystem.getGlobalPtr() # Mount data and models vfs.mountLoop(join(self.basePath, 'Data'), 'Data', 0) vfs.mountLoop(join(self.basePath, 'Models'), 'Models', 0) vfs.mountLoop(join(self.basePath, 'Config'), 'Config', 0) # Ensure the pipeline write path exists, and if not, create it if not isdir(self.writePath): self.debug("Creating temp path, as it does not exist yet") try: os.makedirs(self.writePath, 0777) except Exception, msg: self.error("Failed to create temp path:",msg) import sys sys.exit(0)
def load(self, filename): """ Loads a profile from a given filename and returns the internal used index which can be assigned to a light.""" # Make sure the user can load profiles directly from the ies profile folder data_path = join("/$$rp/data/ies_profiles/", filename) if isfile(data_path): filename = data_path # Make filename unique fname = Filename.from_os_specific(filename) if not VirtualFileSystem.get_global_ptr().resolve_filename( fname, get_model_path().get_value(), "ies"): self.error("Could not resolve", filename) return -1 fname = fname.get_fullpath() # Check for cache entries if fname in self._entries: return self._entries.index(fname) # Check for out of bounds if len(self._entries) >= self._max_entries: # TODO: Could remove unused profiles here or regenerate texture self.warn("Cannot load IES Profile, too many loaded! (Maximum: 32)") # Try loading the dataset, and see what happes try: dataset = self._load_and_parse_file(fname) except InvalidIESProfileException as msg: self.warn("Failed to load profile from", filename, ":", msg) return -1 if not dataset: return -1 # Dataset was loaded successfully, now copy it dataset.generate_dataset_texture_into(self._storage_tex, len(self._entries)) self._entries.append(fname) return len(self._entries) - 1
def mount(self): """ Inits the VFS Mounts """ self.debug("Setting up virtual filesystem.") vfs = VirtualFileSystem.getGlobalPtr() # Mount shaders vfs.mountLoop( join(self.basePath, 'Shader'), 'Shader', 0) # Mount data vfs.mountLoop(join(self.basePath, 'Data'), 'Data', 0) # TODO: Mount core if not isdir(self.writePath): self.debug("Creating temp path, as it does not exist yet") try: makedirs(self.writePath) except Exception, msg: self.error("Failed to create temp path:",msg) import sys sys.exit(0)
def load_sliced_3d_texture(cls, fname, tile_size_x, tile_size_y=None, num_tiles=None): """ Loads a texture from the given filename and dimensions. If only one dimensions is specified, the other dimensions are assumed to be equal. This internally loads the texture into ram, splits it into smaller sub-images, and then calls the load_3d_texture from the Panda loader """ tempfile_name = "/$$slice_loader_temp-" + str(time.time()) + "/" tile_size_y = tile_size_x if tile_size_y is None else tile_size_y num_tiles = tile_size_x if num_tiles is None else num_tiles # Load sliced image from disk source = PNMImage(fname) width = source.get_x_size() # Find slice properties num_cols = width // tile_size_x temp_img = PNMImage( tile_size_x, tile_size_y, source.get_num_channels(), source.get_maxval()) # Construct a ramdisk to write the files to vfs = VirtualFileSystem.get_global_ptr() ramdisk = VirtualFileMountRamdisk() vfs.mount(ramdisk, tempfile_name, 0) # Extract all slices and write them to the virtual disk for z_slice in range(num_tiles): slice_x = (z_slice % num_cols) * tile_size_x slice_y = (z_slice // num_cols) * tile_size_y temp_img.copy_sub_image(source, 0, 0, slice_x, slice_y, tile_size_x, tile_size_y) temp_img.write(tempfile_name + str(z_slice) + ".png") # Load the de-sliced texture from the ramdisk texture_handle = cls.load_3d_texture(tempfile_name + "/#.png") vfs.unmount(ramdisk) return texture_handle
def createVFS(): '''Generates vfs. First loads program VFS, then user directory overrides''' global vfs vfs = VirtualFileSystem() vfs.mount(Filename('.'), Filename('.'), 0) vfs.mount(Filename(getHome()), Filename('.'), 0)
__builtins__['jobMgr'] = simbase.jobMgr __builtins__['eventMgr'] = simbase.eventMgr __builtins__['messenger'] = simbase.messenger __builtins__['bboard'] = simbase.bboard __builtins__['config'] = simbase.config __builtins__['directNotify'] = directNotify from direct.showbase import Loader simbase.loader = Loader.Loader(simbase) __builtins__['loader'] = simbase.loader directNotify.setDconfigLevels() def inspect(anObject): from direct.tkpanels import Inspector Inspector.inspect(anObject) __builtins__['inspect'] = inspect if not __debug__ and __dev__: notify = directNotify.newCategory('ShowBaseGlobal') notify.error("You must set 'want-dev' to false in non-debug mode.") taskMgr.finalInit() # The VirtualFileSystem, which has already initialized, doesn't see the mount # directives in the config(s) yet. We have to force it to load those manually: from panda3d.core import VirtualFileSystem, ConfigVariableList, Filename vfs = VirtualFileSystem.getGlobalPtr() mounts = ConfigVariableList('vfs-mount') for mount in mounts: mountfile, mountpoint = (mount.split(' ', 2) + [None, None, None])[:2] vfs.mount(Filename(mountfile), Filename(mountpoint), 0)
def installPackage(self, appRunner): """ Mounts the package and sets up system paths so it becomes available for use. Returns true on success, false on failure. """ assert self.hasPackage if self.installed: # Already installed. return True assert self not in appRunner.installedPackages mfPathname = Filename(self.getPackageDir(), self.uncompressedArchive.filename) mf = Multifile() if not mf.openRead(mfPathname): self.notify.warning("Couldn't open %s" % (mfPathname)) return False # We mount it under its actual location on disk. root = self.getPackageDir() vfs = VirtualFileSystem.getGlobalPtr() vfs.mount(mf, root, vfs.MFReadOnly) # Add this to the Python search path, if it's not already # there. We have to take a bit of care to check if it's # already there, since there can be some ambiguity in # os-specific path strings. osRoot = self.getPackageDir().toOsSpecific() foundOnPath = False for p in sys.path: if osRoot == p: # Already here, exactly. foundOnPath = True break elif osRoot == Filename.fromOsSpecific(p).toOsSpecific(): # Already here, with some futzing. foundOnPath = True break if not foundOnPath: # Not already here; add it. sys.path.append(osRoot) # Put it on the model-path, too. We do this indiscriminantly, # because the Panda3D runtime won't be adding things to the # model-path, so it shouldn't be already there. getModelPath().appendDirectory(self.getPackageDir()) # Set the environment variable to reference the package root. envvar = '%s_ROOT' % (self.packageName.upper()) ExecutionEnvironment.setEnvironmentVariable(envvar, osRoot) # Add the package root to the system paths. if sys.platform.startswith('win'): path = os.environ.get('PATH', '') os.environ['PATH'] = "%s;%s" % (osRoot, path) else: path = os.environ.get('PATH', '') os.environ['PATH'] = "%s:%s" % (osRoot, path) path = os.environ.get('LD_LIBRARY_PATH', '') os.environ['LD_LIBRARY_PATH'] = "%s:%s" % (osRoot, path) if sys.platform == "darwin": path = os.environ.get('DYLD_LIBRARY_PATH', '') os.environ['DYLD_LIBRARY_PATH'] = "%s:%s" % (osRoot, path) # Now that the environment variable is set, read all of the # prc files in the package. appRunner.loadMultifilePrcFiles(mf, self.getPackageDir()) # Also, find any toplevel Python packages, and add these as # shared packages. This will allow different packages # installed in different directories to share Python files as # if they were all in the same directory. for filename in mf.getSubfileNames(): if filename.endswith('/__init__.pyc') or \ filename.endswith('/__init__.pyo') or \ filename.endswith('/__init__.py'): components = filename.split('/')[:-1] moduleName = '.'.join(components) VFSImporter.sharedPackages[moduleName] = True # Fix up any shared directories so we can load packages from # disparate locations. VFSImporter.reloadSharedPackages() self.installed = True appRunner.installedPackages.append(self) self.markUsed() return True
def findDataFilename(name, extract=False, executable=False): """ Resolve a filename along Panda's model-path. :param name: :return: filename or None """ from panda3d.core import Filename, getModelPath from panda3d.core import VirtualFileSystem logging.debug("findDataFilename: "+ name +" on: \n" + str(getModelPath().getValue())) vfs = VirtualFileSystem.getGlobalPtr() fileName = Filename(name) vfile = vfs.findFile(fileName, getModelPath().getValue()) if not vfile: if extract and name.endswith(".exe"): fileName = Filename(name[:-4]) vfile = vfs.findFile(fileName, getModelPath().getValue()) if not vfile: return None fileName = vfile.getFilename() if extract: # see if the file is embedded in some virtual place OR has the wrong perms from panda3d.core import SubfileInfo info = SubfileInfo() needsCopy = not vfile.getSystemInfo(info) or info.getFilename() != fileName if not needsCopy: if executable: # see if on Linux or OSX and not executable try: stat = os.stat(fileName.toOsSpecific()) if (stat.st_mode & 0111) == 0: logging.error("Found %s locally, but not marked executable!", fileName) needsCopy = True except: needsCopy = True if needsCopy: # virtual file needs to be copied out global _tempDir if not _tempDir: import tempfile _tempDir = os.path.realpath(tempfile.mkdtemp()) #print "Temp dir:",_tempDir xpath = _tempDir + '/' + fileName.getBasename() xTarg = Filename.fromOsSpecific(xpath) # on Windows, case-sensitivity must be honored for the following to work xTarg.makeCanonical() print "extracting",fileName,"to",xTarg if not xTarg.exists(): if not vfs.copyFile(fileName, xTarg): raise IOError("extraction failed when copying " + str(fileName) + " to " + str(xTarg)) fileName = xTarg os.chmod(fileName.toOsSpecific(), 0777) return fileName
def __init__(self, browser, texture): self.browser = browser self.texture = texture self.vfs = VirtualFileSystem.getGlobalPtr()
def setP3DFilename(self, p3dFilename, tokens, argv, instanceId, interactiveConsole, p3dOffset = 0, p3dUrl = None): """ Called by the browser to specify the p3d file that contains the application itself, along with the web tokens and/or command-line arguments. Once this method has been called, the application is effectively started. """ # One day we will have support for multiple instances within a # Python session. Against that day, we save the instance ID # for this instance. self.instanceId = instanceId self.tokens = tokens self.argv = argv # We build up a token dictionary with care, so that if a given # token appears twice in the token list, we record only the # first value, not the second or later. This is consistent # with the internal behavior of the core API. self.tokenDict = {} for token, keyword in tokens: self.tokenDict.setdefault(token, keyword) # Also store the arguments on sys, for applications that # aren't instance-ready. sys.argv = argv # That means we now know the altHost in effect. self.altHost = self.tokenDict.get('alt_host', None) # Tell the browser that Python is up and running, and ready to # respond to queries. self.notifyRequest('onpythonload') # Now go load the applet. fname = Filename.fromOsSpecific(p3dFilename) vfs = VirtualFileSystem.getGlobalPtr() if not vfs.exists(fname): raise ArgumentError, "No such file: %s" % (p3dFilename) fname.makeAbsolute() fname.setBinary() mf = Multifile() if p3dOffset == 0: if not mf.openRead(fname): raise ArgumentError, "Not a Panda3D application: %s" % (p3dFilename) else: if not mf.openRead(fname, p3dOffset): raise ArgumentError, "Not a Panda3D application: %s at offset: %s" % (p3dFilename, p3dOffset) # Now load the p3dInfo file. self.p3dInfo = None self.p3dPackage = None self.p3dConfig = None self.allowPythonDev = False i = mf.findSubfile('p3d_info.xml') if i >= 0 and hasattr(core, 'readXmlStream'): stream = mf.openReadSubfile(i) self.p3dInfo = core.readXmlStream(stream) mf.closeReadSubfile(stream) if self.p3dInfo: self.p3dPackage = self.p3dInfo.FirstChildElement('package') if self.p3dPackage: self.p3dConfig = self.p3dPackage.FirstChildElement('config') xhost = self.p3dPackage.FirstChildElement('host') while xhost: self.__readHostXml(xhost) xhost = xhost.NextSiblingElement('host') if self.p3dConfig: allowPythonDev = self.p3dConfig.Attribute('allow_python_dev') if allowPythonDev: self.allowPythonDev = int(allowPythonDev) guiApp = self.p3dConfig.Attribute('gui_app') if guiApp: self.guiApp = int(guiApp) trueFileIO = self.p3dConfig.Attribute('true_file_io') if trueFileIO: self.trueFileIO = int(trueFileIO) # The interactiveConsole flag can only be set true if the # application has allow_python_dev set. if not self.allowPythonDev and interactiveConsole: raise StandardError, "Impossible, interactive_console set without allow_python_dev." self.interactiveConsole = interactiveConsole if self.allowPythonDev: # Set the fps text to remind the user that # allow_python_dev is enabled. ConfigVariableString('frame-rate-meter-text-pattern').setValue('allow_python_dev %0.1f fps') if self.guiApp: init_app_for_gui() self.initPackedAppEnvironment() # Mount the Multifile under self.multifileRoot. vfs.mount(mf, self.multifileRoot, vfs.MFReadOnly) self.p3dMultifile = mf VFSImporter.reloadSharedPackages() self.loadMultifilePrcFiles(mf, self.multifileRoot) self.gotP3DFilename = True self.p3dFilename = fname if p3dUrl: # The url from which the p3d file was downloaded is # provided if available. It is only for documentation # purposes; the actual p3d file has already been # downloaded to p3dFilename. self.p3dUrl = core.URLSpec(p3dUrl) # Send this call to the main thread; don't call it directly. messenger.send('AppRunner_startIfReady', taskChain = 'default')
def mount(self): """ Inits the VFS Mounts. This creates the following virtual directory structure, from which all files can be located: /$$rp/ (Mounted from the render pipeline base directory) + rpcore/ + shader/ + ... /$rpconfig/ (Mounted from config/, may be set by user) + pipeline.yaml + ... /$$rptemp/ (Either ramdisk or user specified) + day_time_config + shader_auto_config + ... /$$rpshader/ (Link to /$$rp/rpcore/shader) """ self.debug("Setting up virtual filesystem") self._mounted = True def convert_path(pth): return Filename.from_os_specific(pth).get_fullpath() vfs = VirtualFileSystem.get_global_ptr() # Mount config dir as $$rpconf if self._config_dir is None: config_dir = convert_path(join(self._base_path, "config/")) self.debug("Mounting auto-detected config dir:", config_dir) vfs.mount(config_dir, "/$$rpconfig", 0) else: self.debug("Mounting custom config dir:", self._config_dir) vfs.mount(convert_path(self._config_dir), "/$$rpconfig", 0) # Mount directory structure vfs.mount(convert_path(self._base_path), "/$$rp", 0) vfs.mount(convert_path(join(self._base_path, "rpcore/shader")), "/$$rp/shader", 0) vfs.mount(convert_path(join(self._base_path, "effects")), "effects", 0) # Mount the pipeline temp path: # If no write path is specified, use a virtual ramdisk if self._write_path is None: self.debug("Mounting ramdisk as /$$rptemp") vfs.mount(VirtualFileMountRamdisk(), "/$$rptemp", 0) else: # In case an actual write path is specified: # Ensure the pipeline write path exists, and if not, create it if not isdir(self._write_path): self.debug("Creating temporary path, since it does not exist yet") try: os.makedirs(self._write_path) except IOError as msg: self.fatal("Failed to create temporary path:", msg) self.debug("Mounting", self._write_path, "as /$$rptemp") vfs.mount(convert_path(self._write_path), '/$$rptemp', 0) get_model_path().prepend_directory("/$$rp") get_model_path().prepend_directory("/$$rp/shader") get_model_path().prepend_directory("/$$rptemp")
def mount(self): """ Inits the VFS Mounts """ self.debug("Setting up virtual filesystem.") self._mounted = True vfs = VirtualFileSystem.get_global_ptr() # Mount data and models dirs_to_mount = ["Data", "Effects", "Plugins", "Shader"] for directory in dirs_to_mount: vfs.mount_loop(join(self._base_path, directory), directory, 0) if isdir(join(self._base_path, "Models")): vfs.mount_loop(join(self._base_path, 'Models'), 'Models', 0) # Mount config dir if self._config_dir is None: config_dir = join(self._base_path, "Config/") vfs.mount_loop(config_dir, "$$Config/", 0) self.debug("Auto-Detected config dir:", config_dir) else: vfs.mount_loop(self._config_dir, "$$Config/", 0) self.debug("Config dir:", self._config_dir) # Convert the base path to something the os can work with sys_base_path = Filename(self._base_path).to_os_specific() # Add plugin folder to the include path sys.path.insert(0, join(sys_base_path, 'Plugins')) # Add current folder to the include path sys.path.insert(0, sys_base_path) # Mount the pipeline temp path: # If no write path is specified, use a virtual ramdisk if self._write_path is None: self.debug("Mounting ramdisk as $$PipelineTemp/") vfs.mount(VirtualFileMountRamdisk(), "$$PipelineTemp/", 0) else: # In case an actual write path is specified: # Ensure the pipeline write path exists, and if not, create it if not isdir(self._write_path): self.debug("Creating temp path, it does not exist yet") try: os.makedirs(self._write_path) except IOError as msg: self.fatal("Failed to create temp path:", msg) self.debug("Mounting", self._write_path, "as $$PipelineTemp/") vfs.mount_loop(self._write_path, '$$PipelineTemp/', 0) # #pragma include "something" searches in current directory first, # and then on the model-path. Append the Shader directory to the # modelpath to ensure the shader includes can be found. self._model_paths.append(join(self._base_path, "Shader")) # Add the pipeline root directory to the model path as well self._model_paths.append(self._base_path) self._model_paths.append(".") # Append the write path to the model directory to make pragma include # find the ShaderAutoConfig.include self._model_paths.append("$$PipelineTemp") # Add the plugins dir to the model path so plugins can include their # own resources more easily self._model_paths.append(join(self._base_path, "Plugins")) # Write the model paths to the global model path for pth in self._model_paths: get_model_path().append_directory(pth)
def read(self, levelFilename, isInsideMF=True): """This function reads the given level file and store the data for further use inside the self.levelPhysics and self.levelPhysics.level variables""" # use try except block for reading the xml file # if something happen, we simply return False to # indicate the loading failed try: if isInsideMF: # as we can't parse files which are inside multifiles, # we need to read them with the vfs and then parse the String from panda3d.core import VirtualFileSystem vfs = VirtualFileSystem.getGlobalPtr() lvlFile = vfs.readFile(levelFilename, False) levelTree = ElementTree.XML(lvlFile) else: lvlFile = levelFilename levelTree = ElementTree.parse(lvlFile) # read some basic informations of the level like # author name and creation date author = levelTree.find("author") if author != None: self.leveldata.author = author.text date = levelTree.find("date") if date != None: self.leveldata.date = date.text name = levelTree.find("name") if name != None: self.leveldata.name = name.text model = self.__readModel(levelTree.find("baseModel")) if model != None: self.leveldata.model = model else: # We have a problem with loading the base model return False collision = levelTree.find("collisionModel") if collision != None: colModel = self.__readModel(levelTree.find("collisionModel")) if colModel != None: self.leveldata.colModel = colModel walls = levelTree.find("wallCollision") if walls != None: colWall = self.__readCollisionModel(walls) if colWall != None: self.leveldata.colWall = colWall colGround = self.__readCollisionModel( levelTree.find("groundCollision")) if colGround != None: self.leveldata.colGround = colGround wallRunSensor = SensorWallRun() wallRunSensor.sensorID = "wallrun" if self.leveldata.colWall != None: wallRunSensor.model = self.leveldata.colWall elif self.leveldata.colModel != None: wallRunSensor.model = self.leveldata.colModel elif self.leveldata.colGround != None: wallRunSensor.model = self.leveldata.colGround wallRunSensor.sensorType = "wallRuns" self.leveldata.sensors.append(wallRunSensor) startPos = levelTree.find("startPos") if startPos != None: pos = self.__readPos(startPos) self.leveldata.playerStartPos = pos hpr = self.__readHpr(startPos) self.leveldata.playerStartHpr = hpr if levelTree.find("exit") is not None: colExit = self.__readCollisionModel(levelTree.find("exit")) if colExit != None: sensor = SensorExit() sensor.sensorID = "exit" sensor.model = colExit sensor.sensorType = "exit" self.leveldata.sensors.append(sensor) objects = levelTree.find("objects") if objects != None: self.__readObjects(objects) sensors = levelTree.find("sensors") if sensors != None: self.__readSensors(sensors) lights = levelTree.find("lights") if lights != None: self.__readLights(lights) aiUnits = levelTree.find("aiUnits") if aiUnits != None: self.__readAIUnits(aiUnits) except: logging.error("Error while loading level: %s %s", levelFilename, sys.exc_info()) return False return True