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 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 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 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 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 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 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/rpcore/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 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 tex_handle = cls.load_texture(fname) source = PNMImage() tex_handle.store(source) 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 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 load_yaml_file(filepath): """ This method is a wrapper arround yaml_load, and provides error checking """ # import time # start = time.process_time() try: vfs = VirtualFileSystem.get_global_ptr() if vfs.exists(filepath): # load from VFS handle = io.BytesIO(vfs.read_file(filepath, False)) else: # load from zipped package if filepath.startswith('/$$rp/'): filepath = filepath.replace('/$$rp/', '') modpath = os.path.dirname(filepath).replace('/', '.') filename = os.path.basename(filepath) handle = io.BytesIO(pkgutil.get_data(modpath, filename)) parsed_yaml = yaml_load(handle, Loader=SafeLoader) handle.close() except IOError as msg: RPObject.global_error("YAMLLoader", "Could not find or open file:", filename) RPObject.global_error("YAMLLoader", msg) raise Exception("Failed to load YAML file: File not found") except YAMLError as msg: RPObject.global_error("YAMLLoader", "Invalid yaml-syntax in file:", filename) RPObject.global_error("YAMLLoader", msg) raise Exception("Failed to load YAML file: Invalid syntax") # duration = (time.process_time() - start) * 1000.0 # Optionally print out profiling information # print("Took", round(duration, 2), "ms to load", filename) return parsed_yaml
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 vfs(): return VirtualFileSystem.get_global_ptr()
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 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")
# test zip mount if os.path.exists('test.txt'): os.remove('test.txt') with open('test.txt', 'w') as f: f.write('test') if os.path.exists('test.zip'): os.remove('test.zip') with zipfile.ZipFile('test.zip', mode='x', compression=zipfile.ZIP_DEFLATED) as f: f.write('test.txt') vfs = VirtualFileSystem.get_global_ptr() assert vfs.mount('test.zip', '', 0) is True # test freetype load_prc_file_data( '', ''' audio-library-name null window-type none model-path . ''') from direct.showbase.ShowBase import ShowBase base = ShowBase() wfont = os.path.join(os.getenv('RECIPE_DIR'), 'Ubuntu-R.ttf')
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 convert_path = lambda pth: 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")