def load_base_settings(self, plugin_dir): """ Loads the base settings of all plugins, even of disabled plugins. This is required to verify all overrides. """ for entry in listdir(plugin_dir): abspath = join(plugin_dir, entry) if isdir(abspath) and entry not in ("__pycache__", "plugin_prefab"): self.load_plugin_settings(entry, abspath)
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): load_prc_file_data("", """ textures-power-2 none window-type offscreen win-size 100 100 gl-coordinate-system default notify-level-display error print-pipe-types #f """) ShowBase.__init__(self) base_path = realpath(dirname(__file__)) os.chdir(base_path) filter_dir = join(base_path, "tmp/") if isdir(filter_dir): shutil.rmtree(filter_dir) os.makedirs(filter_dir) cubemap = self.loader.loadCubeMap(Filename.from_os_specific(join(base_path, "source/#.jpg"))) mipmap, size = -1, 512 cshader = Shader.load_compute(Shader.SL_GLSL, "filter.compute.glsl") while size > 1: size = size // 2 mipmap += 1 print("Filtering mipmap", mipmap) dest_cubemap = Texture("Dest") dest_cubemap.setup_cube_map(size, Texture.T_float, Texture.F_rgba16) node = NodePath("") for i in range(6): node.set_shader(cshader) node.set_shader_input("SourceTex", cubemap) node.set_shader_input("DestTex", dest_cubemap) node.set_shader_input("currentSize", size) node.set_shader_input("currentMip", mipmap) node.set_shader_input("currentFace", i) attr = node.get_attrib(ShaderAttrib) self.graphicsEngine.dispatch_compute( ( (size + 15) // 16, (size+15) // 16, 1), attr, self.win.get_gsg()) print(" Extracting data ..") self.graphicsEngine.extract_texture_data(dest_cubemap, self.win.get_gsg()) print(" Writing data ..") dest_cubemap.write(join(filter_dir, "{}-#.png".format(mipmap)), 0, 0, True, False) print("Reading in data back in ..") tex = self.loader.loadCubeMap(Filename.from_os_specific(join(base_path, "tmp/#-#.png")), readMipmaps="True") print("Writing txo ..") tex.write("cubemap.txo.pz") shutil.rmtree(join(base_path, "tmp"))
def glob0(dirname, basename): if basename == '': if file.isdir(dirname): return [basename] else: if file.lexists(os.path.join(dirname, basename)): return [basename] return []
def glob0(dirname, basename): if basename == '': # repr(os.path.split()) returns an empty basename for paths ending with a # directory separator. 'q*x/' should match only directories. if file.isdir(dirname): return [basename] else: if file.lexists(os.path.join(dirname, basename)): return [basename] return []
def get_available_plugins(self): """ Returns a list of all installed plugins, no matter if they are enabled or not. This also does no check if the plugin names are valid. """ plugins = [] files = listdir(join(self._base_dir, "Plugins")) for fname in files: abspath = join(self._base_dir, "Plugins", fname) if isdir(abspath) and fname not in ["PluginPrefab"]: plugins.append(fname) return plugins
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 _writeDebugShader(self, name, content): """ Internal method to dump shader for debugging """ if not self._DumpShaders: return cachePath = "PipelineTemp" if not isdir(cachePath): print "Cache path does not exist!:", cachePath print "Disabling shader dump" self._DumpShaders = False return writeName = name.strip().replace("/", "-").replace(".", "_") + ".bin" with open(join(cachePath, writeName), "w") as handle: handle.write(str(content))
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 __init__(self): load_prc_file_data("", """ textures-power-2 none window-type offscreen win-size 100 100 gl-coordinate-system default notify-level-display error print-pipe-types #f """) ShowBase.__init__(self) base_path = realpath(dirname(__file__)) os.chdir(base_path) slice_dir = join(base_path, "slices/") if isdir(slice_dir): shutil.rmtree(slice_dir) os.makedirs(slice_dir) node = NodePath("") w, h, d = 512, 512, 64 self.voxel_grid = Texture("voxels") self.voxel_grid.setup_3d_texture(w, h, d, Texture.T_unsigned_byte, Texture.F_rgba8) # Generate grid cshader = Shader.load_compute(Shader.SL_GLSL, "generate_grid.compute.glsl") node.set_shader(cshader) node.set_shader_input("DestTex", self.voxel_grid) attr = node.get_attrib(ShaderAttrib) self.graphicsEngine.dispatch_compute( ((w + 7) // 8, (h + 7) // 8, (d + 3) // 4), attr, self.win.get_gsg()) self.graphicsEngine.extract_texture_data(self.voxel_grid, self.win.get_gsg()) print("Writing data ..") self.voxel_grid.write(Filename.from_os_specific(join(slice_dir, "#.png")), 0, 0, True, False)
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 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) vfs.mountLoop(join(self.basePath, 'Effects'), 'Effects', 0) # Mount shaders under a different name to access them from the effects vfs.mountLoop(join(self.basePath, 'Shader'), 'ShaderMount', 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 __init__(self): """ Creates a new Scattering object with default settings """ DebugObject.__init__(self, "AtmosphericScattering") self.settings = { "radiusGround": 6360.0, "radiusAtmosphere": 6420.0, "averageGroundReflectance": 0.1, # AVERAGE_GROUND_REFLECTANCE "rayleighFactor": 8.0, # HR "betaRayleigh": Vec3(5.8e-3, 1.35e-2, 3.31e-2), # betaR "mieFactor": 1.2, # HM "betaMieScattering": Vec3(4e-3), # betaMSca "betaMieScatteringAdjusted": (Vec3(2e-3) * (1.0 / 0.9)), "mieG": 0.8, # mieG "transmittanceNonLinear": True, "inscatterNonLinear": True, # Parameters to adjust rendering of the atmosphere. # The position is computed by: # (inputPosition-atmosphereOffset) * atmosphereScale "atmosphereOffset": Vec3(0), "atmosphereScale": Vec3(1) } self.settingsPTA = {} self.targets = {} self.textures = {} self.writeOutput = False self.precomputed = False if self.writeOutput and not isdir("ScatteringDump"): try: makedirs("ScatteringDump") except: self.debug("Failed to create dump dir!") self.writeOutput = False
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 __init__(self): load_prc_file_data( "", """ textures-power-2 none window-type offscreen win-size 100 100 gl-coordinate-system default notify-level-display error print-pipe-types #f """) ShowBase.__init__(self) base_path = realpath(dirname(__file__)) os.chdir(base_path) filter_dir = join(base_path, "tmp/") if isdir(filter_dir): shutil.rmtree(filter_dir) os.makedirs(filter_dir) source_path = join(base_path, "source") extension = ".jpg" if isfile(join(source_path, "1.png")): extension = ".png" cubemap = self.loader.loadCubeMap( Filename.from_os_specific(join(source_path, "#" + extension))) mipmap, size = -1, 1024 cshader = Shader.load_compute(Shader.SL_GLSL, "filter.compute.glsl") while size > 1: size = size // 2 mipmap += 1 print("Filtering mipmap", mipmap) dest_cubemap = Texture("Dest") dest_cubemap.setup_cube_map(size, Texture.T_float, Texture.F_rgba16) node = NodePath("") for i in range(6): node.set_shader(cshader) node.set_shader_input("SourceTex", cubemap) node.set_shader_input("DestTex", dest_cubemap) node.set_shader_input("currentSize", size) node.set_shader_input("currentMip", mipmap) node.set_shader_input("currentFace", i) attr = node.get_attrib(ShaderAttrib) self.graphicsEngine.dispatch_compute( ((size + 15) // 16, (size + 15) // 16, 1), attr, self.win.gsg) print(" Extracting data ..") self.graphicsEngine.extract_texture_data(dest_cubemap, self.win.gsg) print(" Writing data ..") dest_cubemap.write(join(filter_dir, "{}-#.png".format(mipmap)), 0, 0, True, False) print("Reading in data back in ..") tex = self.loader.loadCubeMap(Filename.from_os_specific( join(base_path, "tmp/#-#.png")), readMipmaps="True") print("Writing txo ..") tex.write("cubemap.txo.pz") shutil.rmtree(join(base_path, "tmp"))
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 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")