Add an option to allow the sources for compiled models to be preserved.

Author: TeamSpen210

CHANGELOG.md

@@ -7,6 +7,7 @@
 * Limit the size of propcombined groups to avoid hitting vertex limits.
 * Prevent automatically packing models specified only as Hammer previews in various entities.
 * Fix propcombine sometimes removing collisions entirely from component props.
+* Add an option to allow the sources for compiled models to be preserved.
 
 --------------------
 

src/hammeraddons/bsp_transform/__init__.py

@@ -47,8 +47,9 @@ def __init__(
         bsp: BSP,
         game: Game,
         *,
-        studiomdl_loc: Optional[Path]=None,
-        tags: FrozenSet[str]=frozenset(),
+        studiomdl_loc: Optional[Path] = None,
+        tags: FrozenSet[str] = frozenset(),
+        modelcompile_dump: Optional[Path] = None,
     ) -> None:
         self.sys = filesys
         self.vmf = vmf
@@ -57,6 +58,7 @@ def __init__(
         self.bsp_path = Path(bsp.filename)
         self._fgd: Optional[FGD] = None
         self.tags = tags
+        self.modelcompile_dump = modelcompile_dump
         self.game = game
         self.studiomdl = studiomdl_loc
         self.config = Keyvalues.root()
@@ -147,12 +149,17 @@ async def run_transformations(
     pack: PackList,
     bsp: BSP,
     game: Game,
-    studiomdl_loc: Optional[Path]=None,
-    config: Mapping[str, Keyvalues]=EmptyMapping,
+    studiomdl_loc: Optional[Path] = None,
+    config: Mapping[str, Keyvalues] = EmptyMapping,
     tags: FrozenSet[str] = frozenset(),
+    modelcompile_dump: Optional[Path] = None,
 ) -> None:
     """Run all transformations."""
-    context = Context(filesys, vmf, pack, bsp, game, studiomdl_loc=studiomdl_loc, tags=tags)
+    context = Context(
+        filesys, vmf, pack, bsp, game,
+        studiomdl_loc=studiomdl_loc, tags=tags,
+        modelcompile_dump=modelcompile_dump,
+    )
 
     for func_name, func in sorted(
         TRANSFORMS.items(),

src/hammeraddons/config.py

@@ -372,6 +372,12 @@ def packfile_filters(block: Keyvalues, kind: str) -> Iterator[re_Pattern[str]]:
     """,
 )
 
+MODEL_COMPILE_DUMP = Opt.string(
+    'modelcompile_dump', '',
+    """If set, models will be compiled as subfolders of this folder, instead of in a 
+    temporary directory.
+""")
+
 USE_COMMA_SEP = Opt.boolean_or_none(
     'use_comma_sep',
     """Before L4D, entity I/O used ',' to seperate the different parts.

src/hammeraddons/mdl_compiler.py

@@ -3,13 +3,18 @@
 Each comes with a key, used to identify a previously compiled version.
 We can then reuse already compiled versions.
 """
-from typing import Any, Awaitable, Callable, Generic, Hashable, List, Set, Tuple, TypeVar
+import shutil
+from typing import (
+    Any, Awaitable, Callable, Generic, Hashable, List, Optional, Set, Tuple, TypeVar,
+    ContextManager, Union,
+)
 from typing_extensions import Self
 from pathlib import Path
 import os
 import pickle
 import random
 import tempfile
+import contextlib
 
 from srctools import AtomicWriter, logger
 from srctools.game import Game
@@ -52,6 +57,7 @@ def __init__(
         folder_name: str,
         version: object=0,
         pack_models: bool=True,
+        compile_dir: Optional[Path] =None,
     ) -> None:
         # The models already constructed.
         self._built_models: ACache[ModelKey, GenModel[OutT]] = ACache()
@@ -65,6 +71,7 @@ def __init__(
         self.pack: PackList = pack
         self.version = version
         self.studiomdl_loc = studiomdl_loc
+        self.compile_dir = (compile_dir / folder_name) if compile_dir is not None else None
         self.limiter = trio.CapacityLimiter(8)
         self.pack_models = pack_models
         # For statistics, the number we built this compile
@@ -82,6 +89,7 @@ def from_ctx(cls, ctx: Context, folder_name: str, version: object=0) -> 'ModelCo
             ctx.bsp_path.stem,
             folder_name,
             version,
+            compile_dir=ctx.modelcompile_dump,
         )
 
     def use_count(self) -> int:
@@ -225,7 +233,20 @@ async def _compile(
                 self._mdl_names.add(mdl_name)
                 break
 
-        with tempfile.TemporaryDirectory(prefix='mdl_compile') as folder:
+        # If compile dir is specified, create the folder/clear it, but don't delete once done.
+        ctx_man: ContextManager[Union[str, bytes, Path]]
+        if self.compile_dir is not None:
+            path = Path(self.compile_dir, mdl_name)
+            ctx_man = contextlib.nullcontext(path)
+            try:
+                shutil.rmtree(path)
+            except FileNotFoundError:
+                pass
+            path.mkdir(parents=True, exist_ok=True)
+        else:  # If not specified, use a temporary directory.
+            ctx_man = tempfile.TemporaryDirectory(prefix='mdl_compile')
+
+        with ctx_man as folder:
             path = Path(folder)
             result = await compile_func(key, path, f'{self.model_folder}{mdl_name}.mdl', args)
             studio_args = [
@@ -237,6 +258,8 @@ async def _compile(
             LOGGER.debug("Execute {}", studio_args)
             async with self.limiter:
                 res = await trio.run_process(studio_args, capture_stdout=True, check=False)
+            if self.compile_dir is not None:
+                (path / 'compile.log').write_bytes(res.stdout)
             LOGGER.debug(
                 'Log for {}:\n{}',
                 str(path / 'model.qc'),

src/hammeraddons/postcompiler.py

@@ -1,4 +1,5 @@
 """Runs before VRAD, to run operations on the final BSP."""
+import shutil
 from pathlib import Path
 import sys
 import warnings
@@ -20,7 +21,6 @@
 
 from srctools import __version__ as version_lib, conv_bool
 from srctools.bsp import BSP
-from srctools.fgd import FGD
 from srctools.filesys import ZipFileSystem
 from srctools.packlist import PackList
 
@@ -139,6 +139,19 @@ async def main(argv: List[str]) -> None:
         LOGGER.warning('No studiomdl path provided.')
         studiomdl_loc = None
 
+    modelcompile_dump_str = conf.opts.get(config.MODEL_COMPILE_DUMP)
+    modelcompile_dump = conf.expand_path(modelcompile_dump_str) if modelcompile_dump_str else None
+    if modelcompile_dump is not None:
+        LOGGER.info('Clearing model compile dump folder {}', modelcompile_dump)
+        try:
+            for file in modelcompile_dump.iterdir():
+                if file.is_dir():
+                    shutil.rmtree(file)
+                else:
+                    file.unlink()
+        except FileNotFoundError:
+            pass  # Already empty.
+
     use_comma_sep = conf.opts.get(config.USE_COMMA_SEP)
     if use_comma_sep is None:
         # Guess the format, by checking existing outputs.
@@ -176,6 +189,7 @@ async def main(argv: List[str]) -> None:
         studiomdl_loc,
         transform_conf,
         pack_tags,
+        modelcompile_dump=modelcompile_dump,
     )
 
     if studiomdl_loc is not None and args.propcombine:
@@ -211,6 +225,7 @@ async def main(argv: List[str]) -> None:
             min_cluster=conf.opts.get(config.PROPCOMBINE_MIN_CLLUSTER),
             blacklist=conf.opts.get(config.PROPCOMBINE_BLACKLIST).as_array(),
             volume_tolerance=conf.opts.get(config.PROPCOMBINE_VOLUME_TOLERANCE),
+            compile_dump=modelcompile_dump,
             debug_dump=args.dumpgroups,
             pack_models=conf.opts.get(config.PROPCOMBINE_PACK) or False,
         )

src/hammeraddons/propcombine.py

@@ -1064,6 +1064,7 @@ async def combine(
     qc_folders: Optional[List[Path]]=None,
     crowbar_loc: Optional[Path]=None,
     decomp_cache_loc: Optional[Path]=None,
+    compile_dump: Optional[Path]=None,
     blacklist: Iterable[str]=(),
     auto_range: float=0,
     min_cluster: int=2,
@@ -1266,6 +1267,7 @@ def get_grouping_key(prop: StaticProp) -> Optional[tuple]:
             'ver': 2,
             'vol_tolerance': volume_tolerance,
         },
+        compile_dir=compile_dump,
         pack_models=pack_models,
     ) as compiler:
         async def do_combine(group: List[StaticProp]) -> None: