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")