def init(base): config = pman.get_config() if not pman.is_frozen() and base.appRunner is None and config.getboolean('run', 'auto_build'): pman.build(config) # Add export directory to model path exportdir = pman.get_abs_path(config, config.get('build', 'export_dir')) exportdir = p3d.Filename.from_os_specific(exportdir) p3d.get_model_path().prepend_directory(exportdir) base._bpbase = BPBase(base, config)
def init(base): config = pman.get_config() if base.appRunner is None and config.getboolean('run', 'auto_build'): pman.build(config) # Add export directory to model path exportdir = pman.get_abs_path(config, config.get('build', 'export_dir')) exportdir = p3d.Filename.from_os_specific(exportdir) p3d.get_model_path().prepend_directory(exportdir) base._bpbase = BPBase(base, config)
def __init__(self): super().__init__() # we are running from a sub directory # but we still want to load the models/textures without the extra '../' # so we put the up directory on the model path p3d.get_model_path().append_directory('..') self.disable_mouse() self.set_background_color(0.0, 0.0, 0.0) self.render.set_shader_auto() self.render.set_antialias(M_MSAA)
def init(base): config = pman.get_config() if not pman.is_frozen( ) and base.appRunner is None and config['run']['auto_build']: pman.build(config) # Add export directory to model path exportdir = pman.get_abs_path(config, config['build']['export_dir']) maindir = os.path.dirname( pman.get_abs_path(config, config['run']['main_file'])) if pman.is_frozen(): exportdir = os.path.relpath(exportdir, maindir) exportdir = p3d.Filename.from_os_specific(exportdir) p3d.get_model_path().prepend_directory(exportdir)
def init(base): config = pman.get_config() if not pman.is_frozen() and base.appRunner is None and config.getboolean('run', 'auto_build'): pman.build(config) # Add export directory to model path exportdir = pman.get_abs_path(config, config.get('build', 'export_dir')) maindir = os.path.dirname(pman.get_abs_path(config, config.get('run', 'main_file'))) if pman.is_frozen(): exportdir = os.path.relpath(exportdir, maindir) exportdir = p3d.Filename.from_os_specific(exportdir) p3d.get_model_path().prepend_directory(exportdir) base._bpbase = BPBase(base, config)
def init(_base): assetdir_rel = p3d.Filename('assets') config = None if not pman.is_frozen(): config = pman.get_config() if config['run']['auto_build']: pman.build(config) assetdir_rel = p3d.Filename.from_os_specific( config['build']['export_dir']) # Add assets directory to model path assetdir = p3d.Filename(p3d.Filename.expand_from('$MAIN_DIR'), assetdir_rel) p3d.get_model_path().prepend_directory(assetdir)
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 __resolve_vfs_relative_path(self, file_path, okMissing=False, file_type=''): """ Resolves a file path to a VFS relative Filename object for use in resource loading """ if not isinstance(file_path, core.Filename): file_name = core.Filename(file_path) else: file_name = file_path vfs = core.VirtualFileSystem.get_global_ptr() search_path = core.get_model_path().get_value() # Verify the file exists found = vfs.resolve_filename(file_name, search_path) if not found: # Notify the user message = 'Failed to load %s file: %s' % (file_type, file_name.c_str()) sprite_notify.warning('Search Path: %s' % str(search_path.get_directories())) if not okMissing: sprite_notify.error(message) else: sprite_notify.warning(message) return None return file_name
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 append_subdirectories_to_search(root_dir: str, mount_root: bool = True) -> None: """ Walks through a root directory and mounts all subdirectorys to the search path. Generally used for development source version of an application or servers. """ model_path = get_model_path() folders = [ os.path.join(root_dir, o) for o in os.listdir(root_dir) if os.path.isdir(os.path.join(root_dir, o)) ] if mount_root: if not root_dir.endswith('/'): root_dir += '/' folders.append(root_dir) for folder in folders: # Ignore invalid folders base_name = os.path.basename(folder) if base_name.startswith('.'): continue folder = Filename.from_os_specific(os.path.abspath(folder)) __file_notify.debug('Mounting (%s) to search path' % (folder)) model_path.append_directory(folder)
def vfs_mount_directory(mount_point: str, directory: str) -> bool: """ Mounts the directory to the requested mount point. Returning the result of the mounting operation """ result = _vfs.mount(Filename(directory), Filename(mount_point), VirtualFileSystem.MF_read_only) if not result: __file_notify.warning('Failed to mount directory (%s) to (%s)!' % (directory, mount_point)) get_model_path().append_directory(directory) switch_file_functions_to_vfs() return result
def vfs_mount_url(mount_point: str, url: str) -> bool: """ Mounts a http directory to the requested mount point. Returning the result of the mounting operation. Best used with CDN or download like servers """ m = VirtualFileMountHTTP('%s%s' % (url, mount_point)) __file_notify.info('Mounting remote directory (%s) to (%s)' % (url, mount_point)) result = _vfs.mount(m, mount_point, VirtualFileSystem.MFReadOnly) if not result: __file_notify.warning('Failed to mount url (%s) to (%s)!' % (url, mount_point)) get_model_path().append_directory(mount_point) switch_file_functions_to_vfs() return result
def __init__(self, scene_root_np, render_np): # Setup model path so shaders can be loaded fafnir_dir = os.path.dirname(os.path.realpath(__file__)) p3d.get_model_path().prepend_directory(fafnir_dir) self.data = DataManager(scene_root_np, render_np) # Setup stages self.stages = [ StageGather(self.data), StageDraw(self.data), ] self.enable_stages(2) self.enable_debug_bindings() # Hook into task manager def task_update(task): self.update() return task.cont taskMgr.add(task_update, 'Fafnir update')
def get_search_path() -> DSearchPath: """ Returns the configured panda3d model search path """ search_path = get_model_path().value search_path.append_directory('.') return search_path #----------------------------------------------------------------------------------------------------------------------------------#
def execute(self, context): import panda3d.core as p3d blender_converter = BTFConverter() panda_converter = converter.Converter() # Setup model path to find textures p3d.get_model_path().clear() p3d.get_model_path().prepend_directory(os.path.dirname(bpy.data.filepath)) def convert_cb(data): panda_converter.update(data, writing_bam=True) #panda_converter.active_scene.ls() # Copy images for img in data.get('images', {}).values(): src = os.path.join(os.path.dirname(bpy.data.filepath), img['uri']) dst = os.path.dirname(self.filepath) print('Copying image from "{}" to "{}"'.format(src, dst)) shutil.copy(src, dst) blender_converter.convert(*self._collect_deltas(), callback=convert_cb) panda_converter.active_scene.write_bam_file(self.filepath) # Clean up the model path p3d.get_model_path().clear() return {'FINISHED'}
def vfs_mount_multifile(mount_point: str, multifile: str) -> bool: """ Mounts the multifile to the requested mount point if it exists. Returning the result of the mounting operation """ if not os_path_exists(multifile): return False m = Multifile() m.openReadWrite(multifile) __file_notify.info('Mounting MF "%s" at "%s"' % (multifile, mount_point)) result = _vfs.mount(m, mount_point, VirtualFileSystem.MFReadOnly) if not result: __file_notify.warning('Failed to mount multifile (%s) to (%s)!' % (multifile, mount_point)) get_model_path().append_directory(mount_point) switch_file_functions_to_vfs() return result
def main(): try: options = parameters.get_parameters() core.load_prc_file_data("", "sync-video #f") core.load_prc_file_data("", "show-frame-rate-meter #t") core.load_prc_file_data("", "disable-message-loop #t") core.load_prc_file_data("", "audio-library-name p3openal_audio") core.load_prc_file_data("", "tk-frame-rate 1000") if options.performance_stats: core.load_prc_file_data("", "want-pstats 1") if options.direct_tools: raise NotImplementedError() # core.load_prc_file_data('', 'want-tk #t') # core.load_prc_file_data('', 'want-directtools #t') working_directory = pathlib.Path.cwd() drive_letter = None if working_directory.drive: drive_letter = working_directory.drive[0].lower() working_directory = pathlib.Path(f"/{drive_letter}", *working_directory.parts[1:]) working_directory = working_directory.as_posix() core.get_model_path().append_directory(working_directory) if constants.DEBUG: log_level = logging.DEBUG else: log_level = logging.INFO logging.basicConfig( level=log_level, format="%(asctime)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler()], ) app = bloom_app.Bloom(options.map_path) app.run() except Exception as error: print(f"Error running application: {error}")
def __init__(self): if len(sys.argv) < 2: print("Missing input file") sys.exit(1) super().__init__() simplepbr.init() gltf.patch_loader(self.loader) infile = p3d.Filename.from_os_specific(os.path.abspath(sys.argv[1])) p3d.get_model_path().prepend_directory(infile.get_dirname()) self.model_root = self.loader.load_model(infile, noCache=True) self.accept('escape', sys.exit) self.accept('q', sys.exit) self.accept('w', self.toggle_wireframe) self.accept('t', self.toggle_texture) self.accept('shift-l', self.model_root.ls) self.accept('shift-a', self.model_root.analyze) if not self.model_root.find('**/+Light'): self.light = self.render.attach_new_node(p3d.PointLight('light')) self.light.set_pos(-5, 5, 5) self.render.set_light(self.light) self.cam.set_pos(-6, 6, 6) self.cam.look_at(self.model_root) self.model_root.reparent_to(self.render) if self.model_root.find('**/+Character'): self.anims = p3d.AnimControlCollection() p3d.autoBind(self.model_root.node(), self.anims, ~0) if self.anims.get_num_anims() > 0: self.anims.get_anim(0).loop(True)
def reset(self, workingdir): self.bg = p3d.LVector4(0.0, 0.0, 0.0, 1.0) p3d.get_model_path().clear() pman_conf = None if workingdir: p3d.get_model_path().prepend_directory(workingdir) try: pman_conf = pman.get_config(workingdir) except pman.NoConfigError: pass if self.converter is not None: self.converter.active_scene.remove_node() self.converter = converter.Converter() if self.render is not None: self.render.remove_node self.render = p3d.NodePath('render') self.render_manager = rendermanager.create_render_manager(self, pman_conf)
def __init__(self): if len(sys.argv) < 2: print("Missing input file") sys.exit(1) super().__init__() self.setup_shaders(self.render) gltf.patch_loader(self.loader) infile = p3d.Filename.from_os_specific(os.path.abspath(sys.argv[1])) p3d.get_model_path().prepend_directory(infile.get_dirname()) self.model_root = self.loader.load_model(infile) self.accept('escape', sys.exit) self.accept('q', sys.exit) self.light = self.render.attach_new_node(p3d.PointLight('light')) self.light.set_pos(-5, 5, 5) self.render.set_light(self.light) self.cam.set_pos(-10, 10, 10) if self.model_root.find('**/+Character'): self.actor = Actor(self.model_root) self.actor.reparent_to(self.render) anims = self.actor.get_anim_names() if anims: self.actor.loop(anims[0]) self.cam.look_at(self.actor) else: self.model_root.reparent_to(self.render) self.cam.look_at(self.model_root)
def __init__(self, mdt, model_path, antialiasing): Gfx.__init__(self, mdt) get_model_path().append_directory(model_path) if base.appRunner: root_dir = base.appRunner.p3dFilename.get_dirname() get_model_path().append_directory(root_dir + '/' + model_path) get_model_path().append_directory(root_dir) mdt.base.enableParticles() render.set_shader_auto() render.set_two_sided(True) if antialiasing: render.set_antialias(AntialiasAttrib.MAuto) self.root = None
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(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. 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 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. 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")
def __init__(self, workingdir, conn_addr): ShowBase.__init__(self) self.view_lens = p3d.MatrixLens() self.cam = p3d.NodePath(p3d.Camera('view')) self.cam.node().set_lens(self.view_lens) self.cam.node().set_active(True) self.cam.reparent_to(self.render) self.pipe = p3d.GraphicsPipeSelection.get_global_ptr().make_module_pipe('pandagl') self.bg_color = p3d.LVecBase4(0.0, 0.0, 0.0, 1.0) p3d.get_model_path().prepend_directory(workingdir) self.workingdir = workingdir self.texture = p3d.Texture() self.win = None self.renderer = None self.make_offscreen(1, 1) self.disableMouse() self.setFrameRateMeter(True) self.image_width = 1 self.image_height = 1 self.image_data = struct.pack('=BBB', 0, 0, 0) self.scene = self.render.attach_new_node(p3d.PandaNode("Empty Scene")) self.connection = BlenderConnection(conn_addr) def set_bg_clear_color(task): # Keep bg color working even if DisplayRegions get switched around # (e.g., from FilterManager) for win in self.graphicsEngine.windows: for dispregion in win.display_regions: if dispregion.get_camera() == self.cam: dispregion.set_clear_color_active(True) dispregion.set_clear_color(self.bg_color) return task.cont self.taskMgr.add(set_bg_clear_color, 'Set BG Clear Color') def do_updates(task): if not self.connection.running: sys.exit() latest_scene_update = None for update in self.connection.get_updates(): # print('update: {}'.format(update)) update_type = update['type'] if update_type == 'view': self.update_view( update['width'], update['height'], self.load_matrix(update['projection_matrix']), self.load_matrix(update['view_matrix']), ) elif update_type == 'scene': latest_scene_update = update elif update_type == 'background_color': self.bg_color = p3d.LVector4(*update['color']) else: raise RuntimeError('Unknown update type: {}'.format(update_type)) if latest_scene_update is not None: self.update_scene(latest_scene_update['path']) return task.cont self.taskMgr.add(do_updates, 'Updates') def image_updates(task): if self.texture.has_ram_image(): #start = time.perf_counter() self.connection.send_image( self.texture.get_x_size(), self.texture.get_y_size(), memoryview(self.texture.get_ram_image_as('BGR')) ) #print('Extern: Updated image data in {}ms'.format((time.perf_counter() - start) * 1000)) return task.cont self.taskMgr.add(image_updates, 'Upload Images')
def __init__(self, workingdir, conn_addr): ShowBase.__init__(self) self.view_lens = p3d.MatrixLens() self.cam = p3d.NodePath(p3d.Camera('view')) self.cam.node().set_lens(self.view_lens) self.cam.node().set_active(True) self.cam.reparent_to(self.render) self.pipe = p3d.GraphicsPipeSelection.get_global_ptr().make_module_pipe('pandagl') self.bg_color = p3d.LVecBase4(0.0, 0.0, 0.0, 1.0) p3d.get_model_path().prepend_directory(workingdir) self.workingdir = workingdir self.texture = p3d.Texture() self.win = None self.renderer = None self.make_offscreen(1, 1) self.disableMouse() self.setFrameRateMeter(True) self.image_width = 1 self.image_height = 1 self.image_data = struct.pack('=BBB', 0, 0, 0) self.scene = self.render.attach_new_node(p3d.PandaNode("Empty Scene")) self.connection = BlenderConnection(conn_addr) def set_bg_clear_color(task): # Keep bg color working even if DisplayRegions get switched around # (e.g., from FilterManager) for win in self.graphicsEngine.windows: for dispregion in win.display_regions: if dispregion.get_camera() == self.cam: dispregion.set_clear_color_active(True) dispregion.set_clear_color(self.bg_color) return task.cont self.taskMgr.add(set_bg_clear_color, 'Set BG Clear Color') def do_updates(task): if not self.connection.running: sys.exit() latest_scene_update = None for update in self.connection.get_updates(): # print('update: {}'.format(update)) update_type = update['type'] if update_type == 'view': self.update_view( update['width'], update['height'], self.load_matrix(update['projection_matrix']), self.load_matrix(update['view_matrix']), ) elif update_type == 'scene': latest_scene_update = update elif update_type == 'background_color': self.bg_color = p3d.LVector4(*update['color']) else: raise RuntimeError('Unknown update type: {}'.format(update_type)) if latest_scene_update is not None: self.update_scene(latest_scene_update['path']) return task.cont self.taskMgr.add(do_updates, 'Updates') def image_updates(task): if self.texture.has_ram_image(): #start = time.perf_counter() self.connection.send_image( self.texture.get_x_size(), self.texture.get_y_size(), memoryview(self.texture.get_ram_image_as('BGR')) ) #print('Extern: Updated image data in {}ms'.format((time.perf_counter() - start) * 1000)) return task.cont self.taskMgr.add(image_updates, 'Upload Images')
def __init__(self, workingdir): ShowBase.__init__(self) self.view_lens = p3d.MatrixLens() self.cam = p3d.NodePath(p3d.Camera('view')) self.cam.node().set_lens(self.view_lens) self.cam.node().set_active(True) self.cam.reparent_to(self.render) self.pipe = p3d.GraphicsPipeSelection.get_global_ptr( ).make_module_pipe('pandagl') self.bg_color = p3d.LVecBase4(0.0, 0.0, 0.0, 1.0) p3d.get_model_path().prepend_directory(workingdir) self.workingdir = workingdir self.texture = p3d.Texture() self.win = None self.rendermanager = None self.make_offscreen(1, 1) self.disableMouse() self.setFrameRateMeter(True) self.image_width = 1 self.image_height = 1 self.image_data = struct.pack('=BBB', 0, 0, 0) # Setup conversion logic self.converter = Converter() self.conversion_queue = queue.Queue() def conversion(task): while not self.conversion_queue.empty(): data = self.conversion_queue.get() #print(data) if 'extras' in data and 'view' in data['extras']: viewd = data['extras']['view'] if 'width' in viewd: width = viewd['width'] height = viewd['height'] self.make_offscreen(width, height) if 'projection_matrix' in viewd: proj_mat = self.converter.load_matrix( viewd['projection_matrix']) self.view_lens.set_user_mat(proj_mat) if 'view_matrix' in viewd: view_mat = self.converter.load_matrix( viewd['view_matrix']) # Panda wants an OpenGL model matrix instead of an OpenGL view matrix view_mat.invert_in_place() self.view_lens.set_view_mat(view_mat) self.converter.update(data) bg_color = self.converter.background_color self.bg_color = p3d.LVector4(bg_color[0], bg_color[1], bg_color[2], 1) self.view_region.set_clear_color(self.bg_color) self.converter.active_scene.reparent_to(self.render) #self.render.ls() if self.texture.has_ram_image(): #start = time.perf_counter() self.server.image_lock.acquire() self.image_width = self.texture.get_x_size() self.image_height = self.texture.get_y_size() self.image_data = memoryview( self.texture.get_ram_image_as("BGR")) self.server.image_lock.release() #print('Extern: Updated image data in {}ms'.format((time.perf_counter() - start) * 1000)) #self.texture.write('tex.png') return task.cont self.taskMgr.add(conversion, 'Conversion') # Setup communication with Blender self.server = Server(self.handle_data, self.get_img) if USE_THREAD: self.server.start() def server_mon(task): if not self.server.is_alive(): print('Server thread has terminated, closing program') sys.exit() return task.cont self.taskMgr.add(server_mon, 'Server Monitor') else: def server_task(task): self.server.run() return task.cont self.taskMgr.add(server_task, 'Server Communication')
def __init__(self, workingdir): ShowBase.__init__(self) self.view_lens = p3d.MatrixLens() self.cam = p3d.NodePath(p3d.Camera('view')) self.cam.node().set_lens(self.view_lens) self.cam.node().set_active(True) self.cam.reparent_to(self.render) self.pipe = p3d.GraphicsPipeSelection.get_global_ptr().make_module_pipe('pandagl') self.bg = p3d.LVecBase4(0.0, 0.0, 0.0, 1.0) p3d.get_model_path().prepend_directory(workingdir) self.texture = p3d.Texture() self.win = None self.make_offscreen(1, 1) self.disableMouse() self.setFrameRateMeter(True) self.image_width = 1 self.image_height = 1 self.image_data = struct.pack('=BBB', 0, 0, 0) # Setup conversion logic self.converter = Converter() self.conversion_queue = queue.Queue() def conversion(task): while not self.conversion_queue.empty(): data = self.conversion_queue.get() #print(data) if 'extras' in data and 'view' in data['extras']: viewd = data['extras']['view'] if 'width' in viewd: width = viewd['width'] height = viewd['height'] self.make_offscreen(width, height) if 'projection_matrix' in viewd: proj_mat = self.converter.load_matrix(viewd['projection_matrix']) self.view_lens.set_user_mat(proj_mat) if 'view_matrix' in viewd: view_mat = self.converter.load_matrix(viewd['view_matrix']) # Panda wants an OpenGL model matrix instead of an OpenGL view matrix view_mat.invert_in_place() self.view_lens.set_view_mat(view_mat) self.converter.update(data) bg = self.converter.background_color self.bg = p3d.LVector4(bg[0], bg[1], bg[2], 1) self.view_region.set_clear_color(self.bg) self.converter.active_scene.reparent_to(self.render) #self.render.ls() if self.texture.has_ram_image(): #start = time.perf_counter() self.server.image_lock.acquire() self.image_width = self.texture.get_x_size() self.image_height = self.texture.get_y_size() self.image_data = memoryview(self.texture.get_ram_image_as("BGR")) self.server.image_lock.release() #print('Extern: Updated image data in {}ms'.format((time.perf_counter() - start) * 1000)) #self.texture.write('tex.png') return task.cont self.taskMgr.add(conversion, 'Conversion') # Setup communication with Blender self.server = Server(self.handle_data, self.get_img) if USE_THREAD: self.server.start() def server_mon(task): if not self.server.is_alive(): print('Server thread has terminated, closing program') self.server.destroy() time.sleep(0.1) sys.exit() return task.cont self.taskMgr.add(server_mon, 'Server Monitor') else: def server_task(task): self.server.run() return task.cont self.taskMgr.add(server_task, 'Server Communication') try: pman_conf = pman.get_config(workingdir) except pman.NoConfigError: pman_conf = None self.rendermanager = rendermanager.create_render_manager(self, pman_conf)
def __init__(self): if len(sys.argv) < 2: print("Missing input file") sys.exit(1) super().__init__() self.pipeline = simplepbr.init() gltf.patch_loader(self.loader) infile = p3d.Filename.from_os_specific(os.path.abspath(sys.argv[1])) p3d.get_model_path().prepend_directory(infile.get_dirname()) self.model_root = self.loader.load_model(infile, noCache=True) self.accept('escape', sys.exit) self.accept('q', sys.exit) self.accept('w', self.toggle_wireframe) self.accept('t', self.toggle_texture) self.accept('n', self.toggle_normal_maps) self.accept('e', self.toggle_emission_maps) self.accept('o', self.toggle_occlusion_maps) self.accept('a', self.toggle_ambient_light) self.accept('shift-l', self.model_root.ls) self.accept('shift-a', self.model_root.analyze) self.model_root.reparent_to(self.render) bounds = self.model_root.getBounds() center = bounds.get_center() if bounds.is_empty(): radius = 1 else: radius = bounds.get_radius() fov = self.camLens.get_fov() distance = radius / math.tan(math.radians(min(fov[0], fov[1]) / 2.0)) self.camLens.set_near(min(self.camLens.get_default_near(), radius / 2)) self.camLens.set_far(max(self.camLens.get_default_far(), distance + radius * 2)) trackball = self.trackball.node() trackball.set_origin(center) trackball.set_pos(0, distance, 0) trackball.setForwardScale(distance * 0.006) # Create a light if the model does not have one if not self.model_root.find('**/+Light'): self.light = self.render.attach_new_node(p3d.PointLight('light')) self.light.set_pos(0, -distance, distance) self.render.set_light(self.light) # Move lights to render self.model_root.clear_light() for light in self.model_root.find_all_matches('**/+Light'): light.parent.wrt_reparent_to(self.render) self.render.set_light(light) # Add some ambient light self.ambient = self.render.attach_new_node(p3d.AmbientLight('ambient')) self.ambient.node().set_color((.2, .2, .2, 1)) self.render.set_light(self.ambient) if self.model_root.find('**/+Character'): self.anims = p3d.AnimControlCollection() p3d.autoBind(self.model_root.node(), self.anims, ~0) if self.anims.get_num_anims() > 0: self.anims.get_anim(0).loop(True)
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)