def write_sound(
file: StringIO,
snds: Property,
pack_list: PackList,
snd_prefix: str='*',
) -> None:
"""Write either a single sound, or multiple rndsound.
snd_prefix is the prefix for each filename - *, #, @, etc.
"""
if snds.has_children():
file.write('"rndwave"\n\t{\n')
for snd in snds:
file.write(
'\t"wave" "{sndchar}{file}"\n'.format(
file=snd.value.lstrip(SOUND_CHARS),
sndchar=snd_prefix,
)
)
pack_list.pack_file('sound/' + snd.value.casefold())
file.write('\t}\n')
else:
file.write(
'"wave" "{sndchar}{file}"\n'.format(
file=snds.value.lstrip(SOUND_CHARS),
sndchar=snd_prefix,
)
)
pack_list.pack_file('sound/' + snds.value.casefold())
def pack_ent_class(pack: PackList, clsname: str) -> None:
"""Call to pack another entity class."""
reslist = CLASS_RESOURCES[clsname]
if callable(reslist):
raise ValueError(
"Can't pack \"{}\", has a custom function!".format(clsname))
for fname, ftype in reslist:
pack.pack_file(fname, ftype)
def skybox_swapper(pack: PackList, ent: Entity) -> None:
"""This needs to pack a skybox."""
sky_name = ent['skyboxname']
for suffix in ['bk', 'dn', 'ft', 'lf', 'rt', 'up']:
pack.pack_file(
'materials/skybox/{}{}.vmt'.format(sky_name, suffix),
FileType.MATERIAL,
)
pack.pack_file(
'materials/skybox/{}{}_hdr.vmt'.format(sky_name, suffix),
FileType.MATERIAL,
optional=True,
)
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 color_correction(pack: PackList, ent: Entity) -> None:
"""Pack the color correction file."""
pack.pack_file(ent['filename'])
def pack_button_sound(pack: PackList, index: Union[int, str]) -> None:
"""Add the resource matching the hardcoded set of sounds in button ents."""
pack.pack_soundscript('Buttons.snd{:d}'.format(conv_int(index)))
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 parse(
vmf: VMF, pack: PackList
) -> Tuple[int, Dict[Tuple[str, str, int], VacObject], Dict[str, str], ]:
"""Parse out the cube objects from the map.
The return value is the number of objects, a dict of objects, and the
filenames of the script generated for each group.
The dict is (group, model, skin) -> object.
"""
cube_objects: Dict[Tuple[str, str, int], VacObject] = {}
vac_objects: Dict[str, List[VacObject]] = defaultdict(list)
for i, ent in enumerate(vmf.by_class['comp_vactube_object']):
offset = Vec.from_str(ent['origin']) - Vec.from_str(ent['offset'])
obj = VacObject(
f'obj_{i:x}',
ent['group'],
ent['model'],
ent['cube_model'],
offset,
srctools.conv_int(ent['weight']),
srctools.conv_int(ent['tv_skin']),
srctools.conv_int(ent['cube_skin']),
srctools.conv_int(ent['skin']),
)
vac_objects[obj.group].append(obj)
# Convert the ent into a precache ent, stripping the other keyvalues.
mdl_name = ent['model']
ent.keys = {'model': mdl_name}
make_precache_prop(ent)
pack.pack_file(mdl_name, FileType.MODEL, skinset={obj.skin_vac})
if obj.model_drop:
cube_objects[obj.group,
obj.model_drop.replace('\\', '/'),
obj.skin_drop, ] = obj
# Generate and pack the vactube object scripts.
# Each group is the same, so it can be shared among them all.
codes = {}
for group, objects in sorted(vac_objects.items(), key=lambda t: t[0]):
# First, see if there's a common multiple among the weights, allowing
# us to simplify.
multiple = objects[0].weight
for obj in objects[1:]:
multiple = math.gcd(multiple, obj.weight)
if multiple > 1:
LOGGER.info('Group "{}" has common factor of {}, simplifying.',
group, multiple)
code = []
for i, obj in enumerate(objects):
obj.weight /= multiple
if obj.model_drop:
model_code = f'"{obj.model_drop}"'
else:
model_code = 'null'
code.append(
f'{obj.id} <- obj("{obj.model_vac}", {obj.skin_vac}, '
f'{model_code}, {obj.weight}, "{obj.offset}", {obj.skin_tv});')
codes[group] = pack.inject_vscript('\n'.join(code))
return len(vac_objects), cube_objects, codes
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: 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!")
