def test_vmf_rotation(py_c_vec):
"""Complex test.
Use a compiled map to check the functionality of Vec.rotate().
"""
from srctools.bsp import BSP
import srctools.test
with import_file_path(srctools.test, 'rot_main.bsp') as bsp_path:
bsp = BSP(bsp_path)
vmf = bsp.read_ent_data()
del bsp
for ent in vmf.entities:
if ent['classname'] != 'info_target':
continue
angle_str = ent['angles']
angles = Vec.from_str(angle_str)
local_vec = Vec(
float(ent['local_x']),
float(ent['local_y']),
float(ent['local_z']),
)
x, y, z = round(Vec.from_str(ent['origin']) / 128, 3)
msg = '{} @ {} => ({}, {}, {})'.format(local_vec, angles, x, y, z)
assert_vec(Vec(local_vec).rotate_by_str(angle_str), x, y, z, msg)
assert_vec(Vec(local_vec).rotate(*angles), x, y, z, msg)
def pack_from_bsp(self, bsp: BSP) -> None:
"""Pack files found in BSP data (excluding entities)."""
for static_prop in bsp.static_prop_models():
self.pack_file(static_prop, FileType.MODEL)
for mat in bsp.read_texture_names():
self.pack_file('materials/{}.vmt'.format(mat.lower()), FileType.MATERIAL)
def pack_from_bsp(self, bsp: BSP) -> None:
"""Pack files found in BSP data (excluding entities)."""
for static_prop in bsp.static_prop_models():
self.pack_file(static_prop, FileType.MODEL)
for mat in bsp.read_texture_names():
self.pack_file('materials/{}.vmt'.format(mat.lower()),
FileType.MATERIAL)
def pack_from_bsp(self, bsp: BSP) -> None:
"""Pack files found in BSP data (excluding entities)."""
for prop in bsp.static_props():
# Static props obviously only use one skin.
self.pack_file(prop.model, FileType.MODEL, skinset={prop.skin})
for mat in bsp.read_texture_names():
self.pack_file('materials/{}.vmt'.format(mat.lower()), FileType.MATERIAL)
def main(argv):
LOGGER.info('Srctools VRAD hook started!')
game_info = find_gameinfo(argv)
fsys = game_info.get_filesystem()
fsys.open_ref()
packlist = PackList(fsys)
LOGGER.info('Gameinfo: {}\nSearch path: \n{}', game_info.path, '\n'.join([sys[0].path for sys in fsys.systems]))
fgd = load_fgd()
LOGGER.info('Loading soundscripts...')
packlist.load_soundscript_manifest('srctools_sndscript_data.vdf')
LOGGER.info('Done! ({} sounds)', len(packlist.soundscripts))
# The path is the last argument to VRAD
# Hammer adds wrong slashes sometimes, so fix that.
path = os.path.normpath(argv[-1])
LOGGER.info("Map path is " + path)
if path == "":
raise Exception("No map passed!")
if not path.endswith(".bsp"):
path += ".bsp"
LOGGER.info('Reading BSP...')
bsp_file = BSP(path)
bsp_file.read_header()
bsp_file.read_game_lumps()
LOGGER.info('Reading entities...')
vmf = bsp_file.read_ent_data()
LOGGER.info('Done!')
run_transformations(vmf, fsys, packlist)
bsp_file.replace_lump(
bsp_file.filename,
BSP_LUMPS.ENTITIES,
bsp_file.write_ent_data(vmf),
)
LOGGER.info('Finished writing entities.')
packlist.pack_fgd(vmf, fgd)
packlist.pack_from_bsp(bsp_file)
packlist.eval_dependencies()
with bsp_file.packfile() as pak_zip:
packlist.pack_into_zip(pak_zip)
LOGGER.info("srctools VRAD hook finished!")
def dump_files(bsp: BSP):
"""Dump packed files to a location.
"""
dump_folder = CONF['packfile_dump', '']
if not dump_folder:
return
dump_folder = os.path.abspath(dump_folder)
LOGGER.info('Dumping packed files to "{}"...', dump_folder)
# Delete files in the folder, but don't delete the folder itself.
try:
files = os.listdir(dump_folder)
except FileNotFoundError:
return
for name in files:
name = os.path.join(dump_folder, name)
if os.path.isdir(name):
try:
shutil.rmtree(name)
except OSError:
# It's possible to fail here, if the window is open elsewhere.
# If so, just skip removal and fill the folder.
pass
else:
os.remove(name)
with bsp.packfile() as zipfile:
for zipinfo in zipfile.infolist():
zipfile.extract(zipinfo, dump_folder)
def main(argv: List[str]) -> None:
parser = argparse.ArgumentParser(
description="Modifies the BSP file, allowing additional entities "
"and bugfixes.", )
parser.add_argument("--nopack",
dest="allow_pack",
action="store_false",
help="Prevent packing of files found in the map.")
parser.add_argument(
"--propcombine",
action="store_true",
help="Allow merging static props together.",
)
parser.add_argument(
"--showgroups",
action="store_true",
help="Show propcombined props, by setting their tint to random groups",
)
parser.add_argument(
"--dumpgroups",
action="store_true",
help="Write all props without propcombine groups to a new VMF.",
)
parser.add_argument(
"map",
help="The path to the BSP file.",
)
args = parser.parse_args(argv)
# The path is the last argument to the compiler.
# Hammer adds wrong slashes sometimes, so fix that.
# Also if it's the VMF file, make it the BSP.
path = Path(args.map).with_suffix('.bsp')
# Open and start writing to the map's log file.
handler = FileHandler(path.with_suffix('.log'))
handler.setFormatter(
Formatter(
# One letter for level name
'[{levelname}] {module}.{funcName}(): {message}',
style='{',
))
LOGGER.addHandler(handler)
LOGGER.info('Srctools postcompiler hook started at {}!',
datetime.datetime.now().isoformat())
LOGGER.info("Map path is {}", path)
conf, game_info, fsys, pack_blacklist, plugin = config.parse(path)
fsys.open_ref()
packlist = PackList(fsys)
LOGGER.info('Gameinfo: {}', game_info.path)
LOGGER.info(
'Search paths: \n{}',
'\n'.join([sys.path for sys, prefix in fsys.systems]),
)
fgd = FGD.engine_dbase()
LOGGER.info('Loading soundscripts...')
packlist.load_soundscript_manifest(
conf.path.with_name('srctools_sndscript_data.vdf'))
LOGGER.info('Done! ({} sounds)', len(packlist.soundscripts))
LOGGER.info('Reading BSP...')
bsp_file = BSP(path)
LOGGER.info('Reading entities...')
vmf = bsp_file.read_ent_data()
LOGGER.info('Done!')
# Mount the existing packfile, so the cubemap files are recognised.
LOGGER.info('Mounting BSP packfile...')
zipfile = ZipFile(BytesIO(bsp_file.get_lump(BSP_LUMPS.PAKFILE)))
fsys.add_sys(ZipFileSystem('<BSP pakfile>', zipfile))
studiomdl_path = conf.get(str, 'studiomdl')
if studiomdl_path:
studiomdl_loc = (game_info.root / studiomdl_path).resolve()
if not studiomdl_loc.exists():
LOGGER.warning('No studiomdl found at "{}"!', studiomdl_loc)
studiomdl_loc = None
else:
LOGGER.warning('No studiomdl path provided.')
studiomdl_loc = None
LOGGER.info('Loading plugins...')
plugin.load_all()
use_comma_sep = conf.get(bool, 'use_comma_sep')
if use_comma_sep is None:
# Guess the format, by picking whatever the first output uses.
for ent in vmf.entities:
for out in ent.outputs:
use_comma_sep = out.comma_sep
break
if use_comma_sep is None:
LOGGER.warning(
'No outputs in map, could not determine BSP I/O format!')
LOGGER.warning('Set "use_comma_sep" in srctools.vdf.')
use_comma_sep = False
LOGGER.info('Running transforms...')
run_transformations(vmf, fsys, packlist, bsp_file, game_info,
studiomdl_loc)
if studiomdl_loc is not None and args.propcombine:
decomp_cache_loc = conf.get(str, 'propcombine_cache')
if decomp_cache_loc is not None:
decomp_cache_loc = (game_info.root / decomp_cache_loc).resolve()
decomp_cache_loc.mkdir(parents=True, exist_ok=True)
if conf.get(bool, 'propcombine_crowbar'):
# argv[0] is the location of our script/exe, which lets us locate
# Crowbar from there.
crowbar_loc = Path(sys.argv[0], '../Crowbar.exe').resolve()
else:
crowbar_loc = None
LOGGER.info('Combining props...')
propcombine.combine(
bsp_file,
vmf,
packlist,
game_info,
studiomdl_loc=studiomdl_loc,
qc_folders=[
game_info.root / folder for folder in conf.get(
Property, 'propcombine_qc_folder').as_array(conv=Path)
],
decomp_cache_loc=decomp_cache_loc,
crowbar_loc=crowbar_loc,
auto_range=conf.get(int, 'propcombine_auto_range'),
min_cluster=conf.get(int, 'propcombine_min_cluster'),
debug_tint=args.showgroups,
debug_dump=args.dumpgroups,
)
LOGGER.info('Done!')
else: # Strip these if they're present.
for ent in vmf.by_class['comp_propcombine_set']:
ent.remove()
bsp_file.lumps[BSP_LUMPS.ENTITIES].data = bsp_file.write_ent_data(
vmf, use_comma_sep)
if conf.get(bool, 'auto_pack') and args.allow_pack:
LOGGER.info('Analysing packable resources...')
packlist.pack_fgd(vmf, fgd)
packlist.pack_from_bsp(bsp_file)
packlist.eval_dependencies()
if conf.get(bool, 'soundscript_manifest'):
packlist.write_manifest()
packlist.pack_into_zip(bsp_file,
blacklist=pack_blacklist,
ignore_vpk=False)
with bsp_file.packfile() as pak_zip:
# List out all the files, but group together files with the same extension.
ext_for_name: Dict[str, List[str]] = defaultdict(list)
for file in pak_zip.infolist():
filename = Path(file.filename)
if '.' in filename.name:
stem, ext = filename.name.split('.', 1)
file_path = str(filename.parent / stem)
else:
file_path = file.filename
ext = ''
ext_for_name[file_path].append(ext)
LOGGER.info('Packed files: \n{}'.format('\n'.join([
(f'{name}.{exts[0]}'
if len(exts) == 1 else f'{name}.({"/".join(exts)})')
for name, exts in sorted(ext_for_name.items())
])))
LOGGER.info('Writing BSP...')
bsp_file.save()
LOGGER.info("srctools VRAD hook finished!")
def main(argv: List[str]) -> None:
LOGGER.info('BEE2 VRAD hook started!')
args = " ".join(argv)
fast_args = argv[1:]
full_args = argv[1:]
if not fast_args:
# No arguments!
LOGGER.info(
'No arguments!\n'
"The BEE2 VRAD takes all the regular VRAD's "
'arguments, with some extra arguments:\n'
'-force_peti: Force enabling map conversion. \n'
"-force_hammer: Don't convert the map at all.\n"
"If not specified, the map name must be \"preview.bsp\" to be "
"treated as PeTI.")
sys.exit()
# The path is the last argument to vrad
# P2 adds wrong slashes sometimes, so fix that.
fast_args[-1] = path = os.path.normpath(argv[-1]) # type: str
LOGGER.info("Map path is " + path)
load_config()
for a in fast_args[:]:
if a.casefold() in (
"-both",
"-final",
"-staticproplighting",
"-staticproppolys",
"-textureshadows",
):
# remove final parameters from the modified arguments
fast_args.remove(a)
elif a in ('-force_peti', '-force_hammer', '-no_pack'):
# we need to strip these out, otherwise VRAD will get confused
fast_args.remove(a)
full_args.remove(a)
fast_args = ['-bounce', '2', '-noextra'] + fast_args
# Fast args: -bounce 2 -noextra -game $gamedir $path\$file
# Final args: -both -final -staticproplighting -StaticPropPolys
# -textureshadows -game $gamedir $path\$file
if not path.endswith(".bsp"):
path += ".bsp"
if not os.path.exists(path):
raise ValueError('"{}" does not exist!'.format(path))
if not os.path.isfile(path):
raise ValueError('"{}" is not a file!'.format(path))
# If VBSP thinks it's hammer, trust it.
if CONF.bool('is_hammer', False):
is_peti = edit_args = False
else:
is_peti = True
# Detect preview via knowing the bsp name. If we are in preview,
# check the config file to see what was specified there.
if os.path.basename(path) == "preview.bsp":
edit_args = not CONF.bool('force_full', False)
else:
# publishing - always force full lighting.
edit_args = False
if '-force_peti' in args or '-force_hammer' in args:
# we have override commands!
if '-force_peti' in args:
LOGGER.warning('OVERRIDE: Applying cheap lighting!')
is_peti = edit_args = True
else:
LOGGER.warning('OVERRIDE: Preserving args!')
is_peti = edit_args = False
LOGGER.info('Final status: is_peti={}, edit_args={}', is_peti, edit_args)
# Grab the currently mounted filesystems in P2.
game = find_gameinfo(argv)
root_folder = game.path.parent
fsys = game.get_filesystem()
fsys_tag = fsys_mel = None
if is_peti and 'mel_vpk' in CONF:
fsys_mel = VPKFileSystem(CONF['mel_vpk'])
fsys.add_sys(fsys_mel)
if is_peti and 'tag_dir' in CONF:
fsys_tag = RawFileSystem(CONF['tag_dir'])
fsys.add_sys(fsys_tag)
LOGGER.info('Reading BSP')
bsp_file = BSP(path)
bsp_ents = bsp_file.read_ent_data()
zip_data = BytesIO()
zip_data.write(bsp_file.get_lump(BSP_LUMPS.PAKFILE))
zipfile = ZipFile(zip_data, mode='a')
# Mount the existing packfile, so the cubemap files are recognised.
fsys.systems.append((ZipFileSystem('', zipfile), ''))
fsys.open_ref()
LOGGER.info('Done!')
LOGGER.info('Reading our FGD files...')
fgd = load_fgd()
packlist = PackList(fsys)
packlist.load_soundscript_manifest(
str(root_folder / 'bin/bee2/sndscript_cache.vdf'))
# We nee to add all soundscripts in scripts/bee2_snd/
# This way we can pack those, if required.
for soundscript in fsys.walk_folder('scripts/bee2_snd/'):
if soundscript.path.endswith('.txt'):
packlist.load_soundscript(soundscript, always_include=False)
if is_peti:
LOGGER.info('Adding special packed files:')
music_data = CONF.find_key('MusicScript', [])
if music_data:
packlist.pack_file('scripts/BEE2_generated_music.txt',
PackType.SOUNDSCRIPT,
data=generate_music_script(
music_data, packlist))
for filename, arcname in inject_files():
LOGGER.info('Injecting "{}" into packfile.', arcname)
with open(filename, 'rb') as f:
packlist.pack_file(arcname, data=f.read())
LOGGER.info('Run transformations...')
run_transformations(bsp_ents, fsys, packlist)
LOGGER.info('Scanning map for files to pack:')
packlist.pack_from_bsp(bsp_file)
packlist.pack_fgd(bsp_ents, fgd)
packlist.eval_dependencies()
LOGGER.info('Done!')
if is_peti:
packlist.write_manifest()
else:
# Write with the map name, so it loads directly.
packlist.write_manifest(os.path.basename(path)[:-4])
# We need to disallow Valve folders.
pack_whitelist = set() # type: Set[FileSystem]
pack_blacklist = set() # type: Set[FileSystem]
if is_peti:
pack_blacklist |= {
RawFileSystem(root_folder / 'portal2_dlc2'),
RawFileSystem(root_folder / 'portal2_dlc1'),
RawFileSystem(root_folder / 'portal2'),
RawFileSystem(root_folder / 'platform'),
RawFileSystem(root_folder / 'update'),
}
if fsys_mel is not None:
pack_whitelist.add(fsys_mel)
if fsys_tag is not None:
pack_whitelist.add(fsys_tag)
if '-no_pack' not in args:
# Cubemap files packed into the map already.
existing = set(zipfile.infolist())
LOGGER.info('Writing to BSP...')
packlist.pack_into_zip(
zipfile,
ignore_vpk=True,
whitelist=pack_whitelist,
blacklist=pack_blacklist,
)
LOGGER.info(
'Packed files:\n{}', '\n'.join([
zipinfo.filename for zipinfo in zipfile.infolist()
if zipinfo.filename not in existing
]))
dump_files(zipfile)
zipfile.close() # Finalise the zip modification
# Copy the zipfile into the BSP file, and adjust the headers.
bsp_file.lumps[BSP_LUMPS.PAKFILE].data = zip_data.getvalue()
# Copy new entity data.
bsp_file.lumps[BSP_LUMPS.ENTITIES].data = BSP.write_ent_data(bsp_ents)
bsp_file.save()
LOGGER.info(' - BSP written!')
if is_peti:
mod_screenshots()
if edit_args:
LOGGER.info("Forcing Cheap Lighting!")
run_vrad(fast_args)
else:
if is_peti:
LOGGER.info(
"Publishing - Full lighting enabled! (or forced to do so)")
else:
LOGGER.info("Hammer map detected! Not forcing cheap lighting..")
run_vrad(full_args)
LOGGER.info("BEE2 VRAD hook finished!")
def main(argv: List[str]) -> None:
"""Main VRAD script."""
LOGGER.info(
"BEE{} VRAD hook initiallised, srctools v{}, Hammer Addons v{}",
utils.BEE_VERSION, srctools.__version__, version_haddons,
)
# Warn if srctools Cython code isn't installed.
utils.check_cython(LOGGER.warning)
args = " ".join(argv)
fast_args = argv[1:]
full_args = argv[1:]
if not fast_args:
# No arguments!
LOGGER.info(
'No arguments!\n'
"The BEE2 VRAD takes all the regular VRAD's "
'arguments, with some extra arguments:\n'
'-force_peti: Force enabling map conversion. \n'
"-force_hammer: Don't convert the map at all.\n"
"If not specified, the map name must be \"preview.bsp\" to be "
"treated as PeTI."
)
sys.exit()
# The path is the last argument to vrad
# P2 adds wrong slashes sometimes, so fix that.
fast_args[-1] = path = os.path.normpath(argv[-1])
LOGGER.info("Map path is " + path)
LOGGER.info('Loading Settings...')
config = ConfigFile('compile.cfg')
for a in fast_args[:]:
folded_a = a.casefold()
if folded_a.casefold() in (
"-final",
"-staticproplighting",
"-staticproppolys",
"-textureshadows",
):
# remove final parameters from the modified arguments
fast_args.remove(a)
elif folded_a == '-both':
# LDR Portal 2 isn't actually usable, so there's not much
# point compiling for it.
pos = fast_args.index(a)
fast_args[pos] = full_args[pos] = '-hdr'
elif a in ('-force_peti', '-force_hammer', '-no_pack'):
# we need to strip these out, otherwise VRAD will get confused
fast_args.remove(a)
full_args.remove(a)
fast_args = ['-bounce', '2', '-noextra'] + fast_args
# Fast args: -bounce 2 -noextra -game $gamedir $path\$file
# Final args: -both -final -staticproplighting -StaticPropPolys
# -textureshadows -game $gamedir $path\$file
if not path.endswith(".bsp"):
path += ".bsp"
if not os.path.exists(path):
raise ValueError('"{}" does not exist!'.format(path))
if not os.path.isfile(path):
raise ValueError('"{}" is not a file!'.format(path))
LOGGER.info('Reading BSP')
bsp_file = BSP(path)
# If VBSP marked it as Hammer, trust that.
if srctools.conv_bool(bsp_file.ents.spawn['BEE2_is_peti']):
is_peti = True
# Detect preview via knowing the bsp name. If we are in preview,
# check the config file to see what was specified there.
if os.path.basename(path) == "preview.bsp":
edit_args = not config.get_bool('General', 'vrad_force_full')
# If shift is held, reverse.
if utils.check_shift():
LOGGER.info('Shift held, inverting configured lighting option!')
edit_args = not edit_args
else:
# publishing - always force full lighting.
edit_args = False
else:
is_peti = edit_args = False
if '-force_peti' in args or '-force_hammer' in args:
# we have override commands!
if '-force_peti' in args:
LOGGER.warning('OVERRIDE: Applying cheap lighting!')
is_peti = edit_args = True
else:
LOGGER.warning('OVERRIDE: Preserving args!')
is_peti = edit_args = False
LOGGER.info('Final status: is_peti={}, edit_args={}', is_peti, edit_args)
if not is_peti:
# Skip everything, if the user wants these features install the Hammer Addons postcompiler.
LOGGER.info("Hammer map detected! Skipping all transforms.")
run_vrad(full_args)
return
# Grab the currently mounted filesystems in P2.
game = find_gameinfo(argv)
root_folder = game.path.parent
fsys = game.get_filesystem()
# Special case - move the BEE2 filesystem FIRST, so we always pack files found there.
for child_sys in fsys.systems[:]:
if 'bee2' in child_sys[0].path.casefold():
fsys.systems.remove(child_sys)
fsys.systems.insert(0, child_sys)
zip_data = BytesIO()
zip_data.write(bsp_file.get_lump(BSP_LUMPS.PAKFILE))
zipfile = ZipFile(zip_data)
# Mount the existing packfile, so the cubemap files are recognised.
fsys.add_sys(ZipFileSystem('<BSP pakfile>', zipfile))
LOGGER.info('Done!')
LOGGER.debug('Filesystems:')
for child_sys in fsys.systems[:]:
LOGGER.debug('- {}: {!r}', child_sys[1], child_sys[0])
LOGGER.info('Reading our FGD files...')
fgd = FGD.engine_dbase()
packlist = PackList(fsys)
LOGGER.info('Reading soundscripts...')
packlist.load_soundscript_manifest(
str(root_folder / 'bin/bee2/sndscript_cache.vdf')
)
# We need to add all soundscripts in scripts/bee2_snd/
# This way we can pack those, if required.
for soundscript in fsys.walk_folder('scripts/bee2_snd/'):
if soundscript.path.endswith('.txt'):
packlist.load_soundscript(soundscript, always_include=False)
LOGGER.info('Reading particles....')
packlist.load_particle_manifest()
LOGGER.info('Loading transforms...')
load_transforms()
LOGGER.info('Checking for music:')
music.generate(bsp_file.ents, packlist)
LOGGER.info('Run transformations...')
run_transformations(bsp_file.ents, fsys, packlist, bsp_file, game)
LOGGER.info('Scanning map for files to pack:')
packlist.pack_from_bsp(bsp_file)
packlist.pack_fgd(bsp_file.ents, fgd)
packlist.eval_dependencies()
LOGGER.info('Done!')
packlist.write_soundscript_manifest()
packlist.write_particles_manifest(f'maps/{Path(path).stem}_particles.txt')
# We need to disallow Valve folders.
pack_whitelist: set[FileSystem] = set()
pack_blacklist: set[FileSystem] = set()
# Exclude absolutely everything except our folder.
for child_sys, _ in fsys.systems:
# Add 'bee2/' and 'bee2_dev/' only.
if (
isinstance(child_sys, RawFileSystem) and
'bee2' in os.path.basename(child_sys.path).casefold()
):
pack_whitelist.add(child_sys)
else:
pack_blacklist.add(child_sys)
if config.get_bool('General', 'packfile_dump_enable'):
dump_loc = Path(config.get_val(
'General',
'packfile_dump_dir',
'../dump/'
)).absolute()
else:
dump_loc = None
if '-no_pack' not in args:
# Cubemap files packed into the map already.
existing = set(bsp_file.pakfile.namelist())
LOGGER.info('Writing to BSP...')
packlist.pack_into_zip(
bsp_file,
ignore_vpk=True,
whitelist=pack_whitelist,
blacklist=pack_blacklist,
dump_loc=dump_loc,
)
LOGGER.info('Packed files:\n{}', '\n'.join(
set(bsp_file.pakfile.namelist()) - existing
))
LOGGER.info('Writing BSP...')
bsp_file.save()
LOGGER.info(' - BSP written!')
screenshot.modify(config, game.path)
if edit_args:
LOGGER.info("Forcing Cheap Lighting!")
run_vrad(fast_args)
else:
LOGGER.info("Publishing - Full lighting enabled! (or forced to do so)")
run_vrad(full_args)
LOGGER.info("BEE2 VRAD hook finished!")
def main(argv):
LOGGER.info('Srctools VRAD hook started!')
game_info = find_gameinfo(argv)
fsys = game_info.get_filesystem()
fsys.open_ref()
packlist = PackList(fsys)
LOGGER.info('Gameinfo: {}\nSearch path: \n{}', game_info.path,
'\n'.join([sys[0].path for sys in fsys.systems]))
fgd = load_fgd()
LOGGER.info('Loading soundscripts...')
packlist.load_soundscript_manifest('srctools_sndscript_data.vdf')
LOGGER.info('Done! ({} sounds)', len(packlist.soundscripts))
# The path is the last argument to VRAD
# Hammer adds wrong slashes sometimes, so fix that.
path = os.path.normpath(argv[-1])
LOGGER.info("Map path is " + path)
if path == "":
raise Exception("No map passed!")
if not path.endswith(".bsp"):
path += ".bsp"
LOGGER.info('Reading BSP...')
bsp_file = BSP(path)
bsp_file.read_header()
bsp_file.read_game_lumps()
LOGGER.info('Reading entities...')
vmf = bsp_file.read_ent_data()
LOGGER.info('Done!')
run_transformations(vmf, fsys, packlist)
bsp_file.replace_lump(
bsp_file.filename,
BSP_LUMPS.ENTITIES,
bsp_file.write_ent_data(vmf),
)
LOGGER.info('Finished writing entities.')
packlist.pack_fgd(vmf, fgd)
packlist.pack_from_bsp(bsp_file)
packlist.eval_dependencies()
with bsp_file.packfile() as pak_zip:
packlist.pack_into_zip(pak_zip)
LOGGER.info("srctools VRAD hook finished!")
def main(args: List[str]) -> None:
"""Main script."""
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument(
"-f",
"--filter",
help="filter output to only display resources in this subfolder. "
"This can be used multiple times.",
type=str.casefold,
action='append',
metavar='folder',
dest='filters',
)
parser.add_argument(
"-u",
"--unused",
help="Instead of showing depenencies, show files in the filtered "
"folders that are unused.",
action='store_true',
)
parser.add_argument(
"game",
help="either location of a gameinfo.txt file, or any root folder.",
)
parser.add_argument(
"path",
help="the files to load. The path can have a single * in the "
"filename to match files with specific extensions and a prefix.",
)
result = parser.parse_args(args)
if result.unused and not result.filters:
raise ValueError(
'At least one filter must be provided in "unused" mode.')
if result.game:
try:
fsys = Game(result.game).get_filesystem()
except FileNotFoundError:
fsys = FileSystemChain(RawFileSystem(result.game))
else:
fsys = FileSystemChain()
packlist = PackList(fsys)
file_path: str = result.path
print('Finding files...')
with fsys:
if '*' in file_path: # Multiple files
if file_path.count('*') > 1:
raise ValueError('Multiple * in path!')
prefix, suffix = file_path.split('*')
folder, prefix = os.path.split(prefix)
prefix = prefix.casefold()
suffix = suffix.casefold()
print(f'Prefix: {prefix!r}, suffix: {suffix!r}')
print(f'Searching folder {folder}...')
files = []
for file in fsys.walk_folder(folder):
file_path = file.path.casefold()
if not os.path.basename(file_path).startswith(prefix):
continue
if file_path.endswith(suffix):
print(' ' + file.path)
files.append(file)
else: # Single file
files = [fsys[file_path]]
for file in files:
ext = file.path[-4:].casefold()
if ext == '.vmf':
with file.open_str() as f:
vmf_props = Property.parse(f)
vmf = VMF.parse(vmf_props)
packlist.pack_fgd(vmf, fgd)
del vmf, vmf_props # Hefty, don't want to keep.
elif ext == '.bsp':
child_sys = fsys.get_system(file)
if not isinstance(child_sys, RawFileSystem):
raise ValueError('Cannot inspect BSPs in VPKs!')
bsp = BSP(os.path.join(child_sys.path, file.path))
packlist.pack_from_bsp(bsp)
packlist.pack_fgd(bsp.read_ent_data(), fgd)
del bsp
else:
packlist.pack_file(file.path)
print('Evaluating dependencies...')
packlist.eval_dependencies()
print('Done.')
if result.unused:
print('Unused files:')
used = set(packlist.filenames())
for folder in result.filters:
for file in fsys.walk_folder(folder):
if file.path.casefold() not in used:
print(' ' + file.path)
else:
print('Dependencies:')
for filename in packlist.filenames():
if not result.filters or any(
map(filename.casefold().startswith, result.filters)):
print(' ' + filename)
def main(argv):
LOGGER.info('BEE2 VRAD hook started!')
args = " ".join(argv)
fast_args = argv[1:]
full_args = argv[1:]
# The path is the last argument to vrad
# P2 adds wrong slashes sometimes, so fix that.
fast_args[-1] = path = os.path.normpath(argv[-1])
LOGGER.info("Map path is " + path)
if path == "":
raise Exception("No map passed!")
load_config()
for a in fast_args[:]:
if a.casefold() in (
"-both",
"-final",
"-staticproplighting",
"-staticproppolys",
"-textureshadows",
):
# remove final parameters from the modified arguments
fast_args.remove(a)
elif a in ('-force_peti', '-force_hammer', '-no_pack'):
# we need to strip these out, otherwise VBSP will get confused
fast_args.remove(a)
full_args.remove(a)
fast_args = ['-bounce', '2', '-noextra'] + fast_args
# Fast args: -bounce 2 -noextra -game $gamedir $path\$file
# Final args: -both -final -staticproplighting -StaticPropPolys
# -textureshadows -game $gamedir $path\$file
if not path.endswith(".bsp"):
path += ".bsp"
# If VBSP thinks it's hammer, trust it.
if CONF.bool('is_hammer', False):
is_peti = edit_args = False
else:
is_peti = True
# Detect preview via knowing the bsp name. If we are in preview,
# check the config file to see what was specified there.
if os.path.basename(path) == "preview.bsp":
edit_args = not CONF.bool('force_full', False)
else:
# publishing - always force full lighting.
edit_args = False
if '-force_peti' in args or '-force_hammer' in args:
# we have override commands!
if '-force_peti' in args:
LOGGER.warning('OVERRIDE: Applying cheap lighting!')
is_peti = edit_args = True
else:
LOGGER.warning('OVERRIDE: Preserving args!')
is_peti = edit_args = False
LOGGER.info('Final status: is_peti={}, edit_args={}', is_peti, edit_args)
LOGGER.info('Reading BSP')
bsp_file = BSP(path)
bsp_file.read_header()
LOGGER.info('Done!')
if '-no_pack' not in args:
pack_content(bsp_file, path, is_peti)
else:
LOGGER.warning("Packing files is disabled!")
if is_peti:
mod_screenshots()
if edit_args:
LOGGER.info("Forcing Cheap Lighting!")
run_vrad(fast_args)
else:
if is_peti:
LOGGER.info(
"Publishing - Full lighting enabled! (or forced to do so)")
else:
LOGGER.info("Hammer map detected! Not forcing cheap lighting..")
run_vrad(full_args)
LOGGER.info("BEE2 VRAD hook finished!")
def pack_content(bsp_file: BSP, path: str, is_peti: bool):
"""Pack any custom content into the map.
Filelist format: "[control char]filename[\t packname]"
Filename is the name of the actual file. If given packname is the
name to save it into the packfile as. If the first character of the
filename is '#', the file will be added to the soundscript manifest too.
"""
files = set() # Files to pack.
soundscripts = set() # Soundscripts need to be added to the manifest too..
rem_soundscripts = set(
) # Soundscripts to exclude, so we can override the sounds.
particles = set()
additional_files = set() # .vvd files etc which also are needed.
preload_files = set() # Files we want to force preloading
try:
pack_list = open(path[:-4] + '.filelist.txt')
except (IOError, FileNotFoundError):
pass # Assume no files if missing..
# There might still be things to inject.
else:
with pack_list:
for line in pack_list:
line = line.strip().lower()
if not line or line.startswith('//'):
continue # Skip blanks or comments
if line[:8] == 'precache':
preload_files.add(line)
continue
if line[:2] == '-#':
rem_soundscripts.add(line[2:])
continue
if line[:1] == '#':
line = line[1:]
soundscripts.add(line)
# We need to add particle systems to a manifest.
if line.startswith('particles/'):
particles.add(line)
if line[-4:] == '.mdl':
additional_files.update(
{line[:-4] + ext
for ext in MDL_ADDITIONAL_EXT})
files.add(line)
# Remove guessed files not in the original list.
additional_files -= files
# Only generate a soundscript for PeTI maps..
if is_peti:
music_data = CONF.find_key('MusicScript', [])
if music_data.value:
generate_music_script(music_data, files)
# Add the new script to the manifest file..
soundscripts.add('scripts/BEE2_generated_music.txt')
# We still generate these in hammer-mode - it's still useful there.
# If no files are packed, no manifest will be added either.
gen_sound_manifest(soundscripts, rem_soundscripts)
gen_part_manifest(particles)
gen_auto_script(preload_files, is_peti)
inject_names = list(inject_files())
# Abort packing if no packfiles exist, and no injected files exist either.
if not files and not inject_names:
LOGGER.info('No files to pack!')
return
LOGGER.info('Files to pack:')
for file in sorted(files):
# \t seperates the original and in-pack name if used.
LOGGER.info(' # "' + file.replace('\t', '" as "') + '"')
if additional_files and LOGGER.isEnabledFor(logging.DEBUG):
LOGGER.info('Potential additional files:')
for file in sorted(additional_files):
LOGGER.debug(' # "' + file + '"')
LOGGER.info('Injected files:')
for _, file in inject_names:
LOGGER.info(' # "' + file + '"')
LOGGER.info("Packing Files!")
# Manipulate the zip entirely in memory
zip_data = BytesIO()
zip_data.write(bsp_file.get_lump(BSP_LUMPS.PAKFILE))
zipfile = ZipFile(zip_data, mode='a')
LOGGER.debug(' - Existing zip read')
zip_write = get_zip_writer(zipfile)
for file in files:
pack_file(zip_write, file)
for file in additional_files:
pack_file(zip_write, file, suppress_error=True)
for filename, arcname in inject_names:
LOGGER.info('Injecting "{}" into packfile.', arcname)
zip_write(filename, arcname)
LOGGER.debug(' - Added files')
zipfile.close() # Finalise the zip modification
# Copy the zipfile into the BSP file, and adjust the headers
bsp_file.replace_lump(
path,
BSP_LUMPS.PAKFILE,
zip_data.getvalue(), # Get the binary data we need
)
LOGGER.debug(' - BSP written!')
LOGGER.info("Packing complete!")
def combine(
bsp: BSP,
bsp_ents: VMF,
pack: PackList,
game: Game,
studiomdl_loc: Path = None,
qc_folders: List[Path] = None,
auto_range: float = 0,
min_cluster: int = 2,
debug_tint: bool = False,
) -> None:
"""Combine props in this map."""
# First parse out the bbox ents, so they are always removed.
bbox_ents = list(bsp_ents.by_class['comp_propcombine_set'])
for ent in bbox_ents:
ent.remove()
if not studiomdl_loc.exists():
LOGGER.warning('No studioMDL! Cannot propcombine!')
return
if not qc_folders:
# If gameinfo is blah/game/hl2/gameinfo.txt,
# QCs should be in blah/content/ according to Valve's scheme.
# But allow users to override this.
qc_folders = [game.path.parent.parent / 'content']
# Parse through all the QC files.
LOGGER.info('Parsing QC files. Paths: \n{}',
'\n'.join(map(str, qc_folders)))
qc_map = {} # type: Dict[str, QC]
for qc_folder in qc_folders:
load_qcs(qc_map, qc_folder)
LOGGER.info('Done! {} props.', len(qc_map))
map_name = Path(bsp.filename).stem
# Don't re-parse models continually.
mdl_map = {} # type: Dict[str, Model]
# Wipe these, if they're being used again.
_mesh_cache.clear()
_coll_cache.clear()
def get_model(filename: str) -> Tuple[Optional[QC], Optional[Model]]:
"""Given a filename, load/parse the QC and MDL data."""
key = unify_mdl(filename)
try:
qc = qc_map[key]
except KeyError:
return None, None
try:
model = mdl_map[key]
except KeyError:
try:
mdl_file = pack.fsys[filename]
except FileNotFoundError:
# We don't have this model, we can't combine...
return None, None
model = mdl_map[key] = Model(pack.fsys, mdl_file)
return qc, model
def get_grouping_key(prop: StaticProp) -> Optional[tuple]:
"""Compute a grouping key for this prop.
Only props with matching key can be possibly combined.
If None it cannot be combined.
"""
qc, model = get_model(prop.model)
if model is None or qc is None:
return None
return (
# Must be first, we pull this out later.
frozenset({
tex.casefold().replace('\\', '/')
for tex in model.iter_textures([prop.skin])
}),
model.flags.value,
prop.flags.value,
model.contents,
model.surfaceprop,
prop.renderfx,
*prop.tint,
)
prop_count = 0
# First, construct groups of props that can possibly be combined.
prop_groups = defaultdict(
list) # type: Dict[Optional[tuple], List[StaticProp]]
# This holds the list of all props we want in the map -
# combined ones, and any we reject for whatever reason.
final_props: List[StaticProp] = []
if bbox_ents:
LOGGER.info('Propcombine sets present ({}), combining...',
len(bbox_ents))
grouper = group_props_ent(
prop_groups,
final_props,
get_model,
bbox_ents,
min_cluster,
)
elif auto_range > 0:
LOGGER.info('Automatically finding propcombine sets...')
grouper = group_props_auto(
prop_groups,
final_props,
auto_range,
min_cluster,
)
else:
# No way provided to choose props.
LOGGER.info('No propcombine groups provided.')
return
for prop in bsp.static_props():
prop_groups[get_grouping_key(prop)].append(prop)
prop_count += 1
# These are models we cannot merge no matter what -
# no source files etc.
final_props.extend(prop_groups.pop(None, []))
with ModelCompiler(
game,
studiomdl_loc,
pack,
map_name,
'propcombine',
) as compiler:
for group in grouper:
grouped_prop = combine_group(compiler, group, get_model)
if debug_tint:
# Compute a random hue, and convert back to RGB 0-255.
grouped_prop.tint = round(
Vec(*colorsys.hsv_to_rgb(random.random(), 1, 1)) * 255)
final_props.append(grouped_prop)
LOGGER.info(
'Combined {} props to {} props using {} groups.',
prop_count,
len(final_props),
compiler.model_folder,
)
# If present, delete old cache file. We'll have cleaned up the models.
try:
os.remove(compiler.model_folder_abs / 'cache.vdf')
except FileNotFoundError:
pass
bsp.write_static_props(final_props)
def main(argv: List[str]) -> None:
parser = argparse.ArgumentParser(
description="Modifies the BSP file, allowing additional entities "
"and bugfixes.", )
parser.add_argument("--nopack",
dest="allow_pack",
action="store_false",
help="Prevent packing of files found in the map.")
parser.add_argument(
"--propcombine",
action="store_true",
help="Allow merging static props together.",
)
parser.add_argument(
"--showgroups",
action="store_true",
help="Show propcombined props, by setting their tint to 0 255 0",
)
parser.add_argument(
"map",
help="The path to the BSP file.",
)
args = parser.parse_args(argv)
# The path is the last argument to the compiler.
# Hammer adds wrong slashes sometimes, so fix that.
# Also if it's the VMF file, make it the BSP.
path = Path(args.map).with_suffix('.bsp')
# Open and start writing to the map's log file.
handler = FileHandler(path.with_suffix('.log'))
handler.setFormatter(
Formatter(
# One letter for level name
'[{levelname}] {module}.{funcName}(): {message}',
style='{',
))
LOGGER.addHandler(handler)
LOGGER.info('Srctools postcompiler hook started at {}!',
datetime.datetime.now().isoformat())
LOGGER.info("Map path is {}", path)
conf, game_info, fsys, pack_blacklist, plugins = config.parse(path)
fsys.open_ref()
packlist = PackList(fsys)
LOGGER.info('Gameinfo: {}', game_info.path)
LOGGER.info(
'Search paths: \n{}',
'\n'.join([sys.path for sys, prefix in fsys.systems]),
)
fgd = FGD.engine_dbase()
LOGGER.info('Loading soundscripts...')
packlist.load_soundscript_manifest(
conf.path.with_name('srctools_sndscript_data.vdf'))
LOGGER.info('Done! ({} sounds)', len(packlist.soundscripts))
LOGGER.info('Reading BSP...')
bsp_file = BSP(path)
LOGGER.info('Reading entities...')
vmf = bsp_file.read_ent_data()
LOGGER.info('Done!')
studiomdl_path = conf.get(str, 'studiomdl')
if studiomdl_path:
studiomdl_loc = (game_info.root / studiomdl_path).resolve()
if not studiomdl_loc.exists():
LOGGER.warning('No studiomdl found at "{}"!', studiomdl_loc)
studiomdl_loc = None
else:
LOGGER.warning('No studiomdl path provided.')
studiomdl_loc = None
for plugin in plugins:
plugin.load()
use_comma_sep = conf.get(bool, 'use_comma_sep')
if use_comma_sep is None:
# Guess the format, by picking whatever the first output uses.
for ent in vmf.entities:
for out in ent.outputs:
use_comma_sep = out.comma_sep
break
if use_comma_sep is None:
LOGGER.warning(
'No outputs in map, could not determine BSP I/O format!')
LOGGER.warning('Set "use_comma_sep" in srctools.vdf.')
use_comma_sep = False
run_transformations(vmf, fsys, packlist, bsp_file, game_info,
studiomdl_loc)
if studiomdl_loc is not None and args.propcombine:
LOGGER.info('Combining props...')
propcombine.combine(
bsp_file,
vmf,
packlist,
game_info,
studiomdl_loc,
[
game_info.root / folder for folder in conf.get(
Property, 'propcombine_qc_folder').as_array(conv=Path)
],
conf.get(int, 'propcombine_auto_range'),
conf.get(int, 'propcombine_min_cluster'),
debug_tint=args.showgroups,
)
LOGGER.info('Done!')
else: # Strip these if they're present.
for ent in vmf.by_class['comp_propcombine_set']:
ent.remove()
bsp_file.lumps[BSP_LUMPS.ENTITIES].data = bsp_file.write_ent_data(
vmf, use_comma_sep)
if conf.get(bool, 'auto_pack') and args.allow_pack:
LOGGER.info('Analysing packable resources...')
packlist.pack_fgd(vmf, fgd)
packlist.pack_from_bsp(bsp_file)
packlist.eval_dependencies()
packlist.pack_into_zip(bsp_file,
blacklist=pack_blacklist,
ignore_vpk=False)
with bsp_file.packfile() as pak_zip:
LOGGER.info('Packed files: \n{}'.format('\n'.join(pak_zip.namelist())))
LOGGER.info('Writing BSP...')
bsp_file.save()
LOGGER.info("srctools VRAD hook finished!")
def combine(
bsp: BSP,
bsp_ents: VMF,
pack: PackList,
game: Game,
*,
studiomdl_loc: Path = None,
qc_folders: List[Path] = None,
crowbar_loc: Optional[Path] = None,
decomp_cache_loc: Path = None,
auto_range: float = 0,
min_cluster: int = 2,
debug_tint: bool = False,
debug_dump: bool = False,
) -> None:
"""Combine props in this map."""
# First parse out the bbox ents, so they are always removed.
bbox_ents = list(bsp_ents.by_class['comp_propcombine_set'])
for ent in bbox_ents:
ent.remove()
if not studiomdl_loc.exists():
LOGGER.warning('No studioMDL! Cannot propcombine!')
return
if not qc_folders and decomp_cache_loc is None:
# If gameinfo is blah/game/hl2/gameinfo.txt,
# QCs should be in blah/content/ according to Valve's scheme.
# But allow users to override this.
# If Crowbar's path is provided, that means they may want to just supply nothing.
qc_folders = [game.path.parent.parent / 'content']
# Parse through all the QC files.
LOGGER.info('Parsing QC files. Paths: \n{}',
'\n'.join(map(str, qc_folders)))
qc_map: Dict[str, Optional[QC]] = {}
for qc_folder in qc_folders:
load_qcs(qc_map, qc_folder)
LOGGER.info('Done! {} props.', len(qc_map))
map_name = Path(bsp.filename).stem
# Don't re-parse models continually.
mdl_map: Dict[str, Optional[Model]] = {}
# Wipe these, if they're being used again.
_mesh_cache.clear()
_coll_cache.clear()
missing_qcs: Set[str] = set()
def get_model(filename: str) -> Union[Tuple[QC, Model], Tuple[None, None]]:
"""Given a filename, load/parse the QC and MDL data.
Either both are returned, or neither are.
"""
key = unify_mdl(filename)
try:
model = mdl_map[key]
except KeyError:
try:
mdl_file = pack.fsys[filename]
except FileNotFoundError:
# We don't have this model, we can't combine...
return None, None
model = mdl_map[key] = Model(pack.fsys, mdl_file)
if 'no_propcombine' in model.keyvalues.casefold():
mdl_map[key] = qc_map[key] = None
return None, None
if model is None or key in missing_qcs:
return None, None
try:
qc = qc_map[key]
except KeyError:
if crowbar_loc is None:
missing_qcs.add(key)
return None, None
qc = decompile_model(pack.fsys, decomp_cache_loc, crowbar_loc,
filename, model.checksum)
qc_map[key] = qc
if qc is None:
return None, None
else:
return qc, model
# Ignore these two, they don't affect our new prop.
relevant_flags = ~(StaticPropFlags.HAS_LIGHTING_ORIGIN
| StaticPropFlags.DOES_FADE)
def get_grouping_key(prop: StaticProp) -> Optional[tuple]:
"""Compute a grouping key for this prop.
Only props with matching key can be possibly combined.
If None it cannot be combined.
"""
qc, model = get_model(prop.model)
if model is None or qc is None:
return None
return (
# Must be first, we pull this out later.
frozenset({
tex.casefold().replace('\\', '/')
for tex in model.iter_textures([prop.skin])
}),
model.flags.value,
(prop.flags & relevant_flags).value,
model.contents,
model.surfaceprop,
prop.renderfx,
*prop.tint,
)
prop_count = 0
# First, construct groups of props that can possibly be combined.
prop_groups = defaultdict(
list) # type: Dict[Optional[tuple], List[StaticProp]]
# This holds the list of all props we want in the map -
# combined ones, and any we reject for whatever reason.
final_props: List[StaticProp] = []
rejected: List[StaticProp] = []
if bbox_ents:
LOGGER.info('Propcombine sets present ({}), combining...',
len(bbox_ents))
grouper = group_props_ent(
prop_groups,
rejected,
get_model,
bbox_ents,
min_cluster,
)
elif auto_range > 0:
LOGGER.info('Automatically finding propcombine sets...')
grouper = group_props_auto(
prop_groups,
rejected,
auto_range,
min_cluster,
)
else:
# No way provided to choose props.
LOGGER.info('No propcombine groups provided.')
return
for prop in bsp.static_props():
prop_groups[get_grouping_key(prop)].append(prop)
prop_count += 1
# These are models we cannot merge no matter what -
# no source files etc.
cannot_merge = prop_groups.pop(None, [])
final_props.extend(cannot_merge)
LOGGER.debug(
'Prop groups: \n{}', '\n'.join([
f'{group}: {len(props)}'
for group, props in sorted(prop_groups.items(),
key=operator.itemgetter(0))
]))
group_count = 0
with ModelCompiler(
game,
studiomdl_loc,
pack,
map_name,
'propcombine',
) as compiler:
for group in grouper:
grouped_prop = combine_group(compiler, group, get_model)
if debug_tint:
# Compute a random hue, and convert back to RGB 0-255.
r, g, b = colorsys.hsv_to_rgb(random.random(), 1, 1)
grouped_prop.tint = Vec(round(r * 255), round(g * 255),
round(b * 255))
final_props.append(grouped_prop)
group_count += 1
final_props.extend(rejected)
if debug_dump:
dump_vmf = VMF()
for prop in rejected:
dump_vmf.create_ent(
'prop_static',
model=prop.model,
origin=prop.origin,
angles=prop.angles,
solid=prop.solidity,
rendercolor=prop.tint,
)
dump_fname = Path(bsp.filename).with_name(map_name +
'_propcombine_reject.vmf')
LOGGER.info('Dumping uncombined props to {}...', dump_fname)
with dump_fname.open('w') as f:
dump_vmf.export(f)
LOGGER.info(
'Combined {} props into {}:\n - {} grouped models\n - {} ineligable\n - {} had no group',
prop_count,
len(final_props),
group_count,
len(cannot_merge),
len(rejected),
)
LOGGER.debug('Models with unknown QCs: \n{}',
'\n'.join(sorted(missing_qcs)))
# If present, delete old cache file. We'll have cleaned up the models.
try:
os.remove(compiler.model_folder_abs / 'cache.vdf')
except FileNotFoundError:
pass
bsp.write_static_props(final_props)
def main(argv: List[str]) -> None:
LOGGER.info('Srctools postcompiler hook started!')
parser = argparse.ArgumentParser(
description="Modifies the BSP file, allowing additional entities "
"and bugfixes.", )
parser.add_argument("--nopack",
dest="allow_pack",
action="store_false",
help="Prevent packing of files found in the map.")
parser.add_argument(
"--propcombine",
action="store_true",
help="Allow merging static props together.",
)
parser.add_argument(
"map",
help="The path to the BSP file.",
)
args = parser.parse_args(argv)
# The path is the last argument to the compiler.
# Hammer adds wrong slashes sometimes, so fix that.
# Also if it's the VMF file, make it the BSP.
path = Path(args.map).with_suffix('.bsp')
LOGGER.info("Map path is {}", path)
conf, game_info, fsys, pack_blacklist = config.parse(path)
fsys.open_ref()
packlist = PackList(fsys)
LOGGER.info('Gameinfo: {}', game_info.path)
LOGGER.info(
'Search paths: \n{}',
'\n'.join([sys.path for sys, prefix in fsys.systems]),
)
fgd = load_fgd()
LOGGER.info('Loading soundscripts...')
packlist.load_soundscript_manifest(
conf.path.with_name('srctools_sndscript_data.vdf'))
LOGGER.info('Done! ({} sounds)', len(packlist.soundscripts))
LOGGER.info('Reading BSP...')
bsp_file = BSP(path)
LOGGER.info('Reading entities...')
vmf = bsp_file.read_ent_data()
LOGGER.info('Done!')
run_transformations(vmf, fsys, packlist)
studiomdl_loc = conf.get(str, 'propcombine_studiomdl')
if studiomdl_loc and args.propcombine:
LOGGER.info('Combining props...')
propcombine.combine(
bsp_file,
vmf,
packlist,
game_info,
game_info.root / studiomdl_loc,
[
game_info.root / folder for folder in conf.get(
Property, 'propcombine_qc_folder').as_array(conv=Path)
],
conf.get(int, 'propcombine_auto_range'),
conf.get(int, 'propcombine_min_cluster'),
)
LOGGER.info('Done!')
bsp_file.lumps[BSP_LUMPS.ENTITIES].data = bsp_file.write_ent_data(vmf)
if conf.get(bool, 'auto_pack') and args.allow_pack:
LOGGER.info('Analysing packable resources...')
packlist.pack_fgd(vmf, fgd)
packlist.pack_from_bsp(bsp_file)
packlist.eval_dependencies()
with bsp_file.packfile() as pak_zip:
packlist.pack_into_zip(pak_zip, blacklist=pack_blacklist)
LOGGER.info('Packed files: \n{}'.format('\n'.join(pak_zip.namelist())))
LOGGER.info('Writing BSP...')
bsp_file.save()
LOGGER.info("srctools VRAD hook finished!")
def main(argv: List[str]) -> None:
LOGGER.info('BEE2 VRAD hook started!')
args = " ".join(argv)
fast_args = argv[1:]
full_args = argv[1:]
if not fast_args:
# No arguments!
LOGGER.info(
'No arguments!\n'
"The BEE2 VRAD takes all the regular VRAD's "
'arguments, with some extra arguments:\n'
'-force_peti: Force enabling map conversion. \n'
"-force_hammer: Don't convert the map at all.\n"
"If not specified, the map name must be \"preview.bsp\" to be "
"treated as PeTI."
)
sys.exit()
# The path is the last argument to vrad
# P2 adds wrong slashes sometimes, so fix that.
fast_args[-1] = path = os.path.normpath(argv[-1]) # type: str
LOGGER.info("Map path is " + path)
load_config()
for a in fast_args[:]:
if a.casefold() in (
"-both",
"-final",
"-staticproplighting",
"-staticproppolys",
"-textureshadows",
):
# remove final parameters from the modified arguments
fast_args.remove(a)
elif a in ('-force_peti', '-force_hammer', '-no_pack'):
# we need to strip these out, otherwise VRAD will get confused
fast_args.remove(a)
full_args.remove(a)
fast_args = ['-bounce', '2', '-noextra'] + fast_args
# Fast args: -bounce 2 -noextra -game $gamedir $path\$file
# Final args: -both -final -staticproplighting -StaticPropPolys
# -textureshadows -game $gamedir $path\$file
if not path.endswith(".bsp"):
path += ".bsp"
if not os.path.exists(path):
raise ValueError('"{}" does not exist!'.format(path))
if not os.path.isfile(path):
raise ValueError('"{}" is not a file!'.format(path))
# If VBSP thinks it's hammer, trust it.
if CONF.bool('is_hammer', False):
is_peti = edit_args = False
else:
is_peti = True
# Detect preview via knowing the bsp name. If we are in preview,
# check the config file to see what was specified there.
if os.path.basename(path) == "preview.bsp":
edit_args = not CONF.bool('force_full', False)
else:
# publishing - always force full lighting.
edit_args = False
if '-force_peti' in args or '-force_hammer' in args:
# we have override commands!
if '-force_peti' in args:
LOGGER.warning('OVERRIDE: Applying cheap lighting!')
is_peti = edit_args = True
else:
LOGGER.warning('OVERRIDE: Preserving args!')
is_peti = edit_args = False
LOGGER.info('Final status: is_peti={}, edit_args={}', is_peti, edit_args)
# Grab the currently mounted filesystems in P2.
game = find_gameinfo(argv)
root_folder = game.path.parent
fsys = game.get_filesystem()
fsys_tag = fsys_mel = None
if is_peti and 'mel_vpk' in CONF:
fsys_mel = VPKFileSystem(CONF['mel_vpk'])
fsys.add_sys(fsys_mel)
if is_peti and 'tag_dir' in CONF:
fsys_tag = RawFileSystem(CONF['tag_dir'])
fsys.add_sys(fsys_tag)
LOGGER.info('Reading BSP')
bsp_file = BSP(path)
bsp_ents = bsp_file.read_ent_data()
zip_data = BytesIO()
zip_data.write(bsp_file.get_lump(BSP_LUMPS.PAKFILE))
zipfile = ZipFile(zip_data, mode='a')
# Mount the existing packfile, so the cubemap files are recognised.
fsys.systems.append((ZipFileSystem('', zipfile), ''))
fsys.open_ref()
LOGGER.info('Done!')
LOGGER.info('Reading our FGD files...')
fgd = load_fgd()
packlist = PackList(fsys)
packlist.load_soundscript_manifest(
str(root_folder / 'bin/bee2/sndscript_cache.vdf')
)
# We nee to add all soundscripts in scripts/bee2_snd/
# This way we can pack those, if required.
for soundscript in fsys.walk_folder('scripts/bee2_snd/'):
if soundscript.path.endswith('.txt'):
packlist.load_soundscript(soundscript, always_include=False)
if is_peti:
LOGGER.info('Adding special packed files:')
music_data = CONF.find_key('MusicScript', [])
if music_data:
packlist.pack_file(
'scripts/BEE2_generated_music.txt',
PackType.SOUNDSCRIPT,
data=generate_music_script(music_data, packlist)
)
for filename, arcname in inject_files():
LOGGER.info('Injecting "{}" into packfile.', arcname)
with open(filename, 'rb') as f:
packlist.pack_file(arcname, data=f.read())
LOGGER.info('Run transformations...')
run_transformations(bsp_ents, fsys, packlist)
LOGGER.info('Scanning map for files to pack:')
packlist.pack_from_bsp(bsp_file)
packlist.pack_fgd(bsp_ents, fgd)
packlist.eval_dependencies()
LOGGER.info('Done!')
if is_peti:
packlist.write_manifest()
else:
# Write with the map name, so it loads directly.
packlist.write_manifest(os.path.basename(path)[:-4])
# We need to disallow Valve folders.
pack_whitelist = set() # type: Set[FileSystem]
pack_blacklist = set() # type: Set[FileSystem]
if is_peti:
pack_blacklist |= {
RawFileSystem(root_folder / 'portal2_dlc2'),
RawFileSystem(root_folder / 'portal2_dlc1'),
RawFileSystem(root_folder / 'portal2'),
RawFileSystem(root_folder / 'platform'),
RawFileSystem(root_folder / 'update'),
}
if fsys_mel is not None:
pack_whitelist.add(fsys_mel)
if fsys_tag is not None:
pack_whitelist.add(fsys_tag)
if '-no_pack' not in args:
# Cubemap files packed into the map already.
existing = set(zipfile.infolist())
LOGGER.info('Writing to BSP...')
packlist.pack_into_zip(
zipfile,
ignore_vpk=True,
whitelist=pack_whitelist,
blacklist=pack_blacklist,
)
LOGGER.info('Packed files:\n{}', '\n'.join([
zipinfo.filename
for zipinfo in zipfile.infolist()
if zipinfo.filename not in existing
]))
dump_files(zipfile)
zipfile.close() # Finalise the zip modification
# Copy the zipfile into the BSP file, and adjust the headers.
bsp_file.lumps[BSP_LUMPS.PAKFILE].data = zip_data.getvalue()
# Copy new entity data.
bsp_file.lumps[BSP_LUMPS.ENTITIES].data = BSP.write_ent_data(bsp_ents)
bsp_file.save()
LOGGER.info(' - BSP written!')
if is_peti:
mod_screenshots()
if edit_args:
LOGGER.info("Forcing Cheap Lighting!")
run_vrad(fast_args)
else:
if is_peti:
LOGGER.info("Publishing - Full lighting enabled! (or forced to do so)")
else:
LOGGER.info("Hammer map detected! Not forcing cheap lighting..")
run_vrad(full_args)
LOGGER.info("BEE2 VRAD hook finished!")
def pack_into_zip(
self,
bsp: BSP,
*,
whitelist: Iterable[FileSystem]=(),
blacklist: Iterable[FileSystem]=(),
ignore_vpk: bool=True,
) -> None:
"""Pack all our files into the packfile in the BSP.
The filesys is used to find files to pack.
Filesystems must be in the whitelist and not in the blacklist, if provided.
If ignore_vpk is True, files in VPK won't be packed unless that system
is in allow_filesys.
"""
# We need to rebuild the zipfile from scratch, so we can overwrite
# old data if required.
# First retrieve the data.
with bsp.packfile() as start_zip:
packed_files = {
info.filename.casefold(): (info.filename, start_zip.read(info))
for info in start_zip.infolist()
} # type: Dict[str, Tuple[str, bytes]]
# The packed_files dict is a casefolded name -> (orig name, bytes) tuple.
all_systems = {
sys for sys, prefix in
self.fsys.systems
} # type: Set[FileSystem]
allowed = set(all_systems)
if ignore_vpk:
for fsys in all_systems:
if isinstance(fsys, VPKFileSystem):
allowed.discard(fsys)
# Add these on top, so this overrides ignore_vpk.
allowed.update(whitelist)
# Then remove blacklisted systems.
allowed.difference_update(blacklist)
LOGGER.debug('Allowed filesystems:\n{}', '\n'.join([
('+ ' if sys in allowed else '- ') + repr(sys) for sys, prefix in
self.fsys.systems
]))
with self.fsys:
for file in self._files.values():
# Need to ensure / separators.
fname = file.filename.replace('\\', '/')
already_packed = fname.casefold() in packed_files
if file.data is not None:
# Always pack, we've got custom data.
packed_files[fname.casefold()] = (fname, file.data)
continue
try:
sys_file = self.fsys[file.filename]
except FileNotFoundError:
if not file.optional and not already_packed:
LOGGER.warning('WARNING: "{}" not packed!', file.filename)
continue
if self.fsys.get_system(sys_file) in allowed:
LOGGER.debug('ADD: {}', fname)
with sys_file.open_bin() as f:
packed_files[fname.casefold()] = (fname, f.read())
else:
LOGGER.debug('SKIP: {}', fname)
LOGGER.info('Compressing packfile...')
with io.BytesIO() as new_data:
with ZipFile(new_data, 'w') as new_zip:
for fname, data in packed_files.values():
new_zip.writestr(fname, data)
bsp.lumps[BSP_LUMPS.PAKFILE].data = new_data.getvalue()
