cue4parse 0.0.2__tar.gz

cue4parse-0.0.2/.gitignore

@@ -0,0 +1,4 @@
+/dist
+__pycache__
+*.pyc
+build.cmd

cue4parse-0.0.2/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

cue4parse-0.0.2/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: cue4parse
+Version: 0.0.2
+Summary: CUE4Parse Python wrapper and CLI tool to extract packages from Unreal Engine games
+Author-email: joric <joric@users.noreply.github.com>
+License: Unlicense
+License-File: LICENSE
+Keywords: cli,cue4parse,unreal
+Classifier: License :: OSI Approved :: The Unlicense (Unlicense)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: pythonnet>=3.0
+Description-Content-Type: text/markdown
+
+# CUE4Parse-Python
+
+cue4parse package for python
+
+## Installation
+
+### Development
+
+`pip install -e . --force`
+
+### User
+
+`pip install cue4parse`
+
+## Usage
+
+Make sure executable is added to paths, e.g. `C:\Users\user\AppData\Local\Python\pythoncore-3.14-64\Scripts`.
+
+Needs CUE4Parse libraries in `%LOCALAPPDATA%/cue4parse/libs` (automatically downloads and unpacks FModel on Windows).
+
+To run CLI: `cue4parse`
+

cue4parse-0.0.2/README.md

@@ -0,0 +1,22 @@
+# CUE4Parse-Python
+
+cue4parse package for python
+
+## Installation
+
+### Development
+
+`pip install -e . --force`
+
+### User
+
+`pip install cue4parse`
+
+## Usage
+
+Make sure executable is added to paths, e.g. `C:\Users\user\AppData\Local\Python\pythoncore-3.14-64\Scripts`.
+
+Needs CUE4Parse libraries in `%LOCALAPPDATA%/cue4parse/libs` (automatically downloads and unpacks FModel on Windows).
+
+To run CLI: `cue4parse`
+

cue4parse-0.0.2/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "cue4parse"
+version = "0.0.2"
+description = "CUE4Parse Python wrapper and CLI tool to extract packages from Unreal Engine games"
+requires-python = ">=3.9"
+dependencies = ["pythonnet>=3.0"]
+readme = "README.md"
+license = { text = "Unlicense" }
+authors = [{ name = "joric", email = "joric@users.noreply.github.com" }]
+keywords = ["unreal", "cue4parse", "cli"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: The Unlicense (Unlicense)",
+  "Operating System :: OS Independent",
+]
+
+[project.scripts]
+cue4parse = "cue4parse.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/cue4parse"]

cue4parse-0.0.2/src/cue4parse/__init__.py

@@ -0,0 +1,13 @@
+import sys
+import os
+from pathlib import Path
+
+_DLL_DIR = Path(os.environ.get('LOCALAPPDATA', os.path.expanduser('~/.local/share'))) / "cue4parse" / "libs"
+
+if not _DLL_DIR.exists():
+    print("DLLs not found. Downloading native libraries.")
+    from cue4parse import setup_deps
+    setup_deps.main()
+
+from cue4parse.core import *
+from cue4parse.includes import *

cue4parse-0.0.2/src/cue4parse/__main__.py

@@ -0,0 +1,3 @@
+from cue4parse.cli import main
+
+main()

cue4parse-0.0.2/src/cue4parse/cli.py

@@ -0,0 +1,521 @@
+from cue4parse import *
+
+import tempfile
+import fnmatch
+import time
+from importlib.metadata import version
+
+export_directory = ""
+overwrite_files = False
+
+DEBUG = False
+
+class ExportType(Flag):
+    NONE = 0
+    TEXTURE = auto()
+    SOUND = auto()
+    MESH = auto()
+    ANIMATION = auto()
+    OTHER = auto()
+
+@dataclass
+class CliOptions:
+    sources: list[str]
+    pak: str | None
+    output: str | None
+    package: list[str]
+    config: list[str]
+    game: str
+    key: list[str]
+    mappings: str | None
+    format: str
+    list_only: bool
+    yes: bool
+    verbose: bool
+    mesh_format: str
+    anim_format: str
+    texture_format: str
+    material_format: str
+    lod_format: str
+    socket_format: str
+    nanite_format: str  # kept for parity (not assigned if enum unavailable)
+    export_morph_targets: bool
+    export_materials: bool
+    export_hdr_as_hdr: bool
+    compression: str
+
+def norm_path(path: str) -> str:
+    if not path:
+        return "."
+    return path.replace("/", os.sep).replace("\\\\", "\\")
+
+
+def parse_enum(enum_type: Any, value: str, default_name: str | None = None) -> Any:
+    # pythonnet enum access: getattr(EnumType, "ValueName")
+    if hasattr(enum_type, value):
+        return getattr(enum_type, value)
+    for name in dir(enum_type):
+        if name.lower() == value.lower():
+            return getattr(enum_type, name)
+    if default_name and hasattr(enum_type, default_name):
+        print(f"Warning: Unknown value '{value}' for {enum_type.__name__}, using default '{default_name}'", file=sys.stderr)
+        return getattr(enum_type, default_name)
+    print(f"Warning: Unknown value '{value}' for {enum_type.__name__}, using default", file=sys.stderr)
+    # best-effort default
+    names = [n for n in dir(enum_type) if not n.startswith("_")]
+    return getattr(enum_type, names[0]) if names else None
+
+
+def check_file(out_path: Path, silent: bool = False) -> bool:
+    skip = (not overwrite_files) and out_path.exists()
+    if not silent:
+        if skip:
+            Log.Warning("Already exists, skipping {Path}", norm_path(str(out_path)))
+        else:
+            Log.Information("Writing {Path}", norm_path(str(out_path)))
+    return not skip
+
+
+def write_to_log(_folder: str, _log_message: str, counter: list[int]) -> None:
+    counter[0] += 1
+
+
+def write_to_file(folder: str, file_name: str, data: bytes, log_message: str, counter: list[int]) -> None:
+    out_path = Path(export_directory) / folder / file_name
+    if not check_file(out_path):
+        return
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_bytes(data)
+    write_to_log(folder, log_message, counter)
+
+def save_json(folder: str, name: str, exports: Any, counter: list[int]) -> None:
+    #text = JsonConvert.SerializeObject(exports, Formatting.Indented) # alternative way
+
+    serializer = JsonSerializer();
+    serializer.Formatting = Formatting.Indented;
+
+    output_to_stdout = export_directory==""
+    if output_to_stdout:
+        writer = JsonTextWriter(Console.Out)
+        serializer.Serialize(writer, exports)
+        writer.Flush()
+        return
+
+    file_name = f"{Path(name).stem}.json"
+    out_path = Path(export_directory) / folder / file_name
+
+    if not check_file(out_path):
+        return
+
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+
+    stream = StreamWriter(str(out_path), False, Encoding.UTF8);
+    try:
+        writer = JsonTextWriter(stream);
+        try:
+            serializer.Serialize(writer, exports);
+            writer.Flush()
+        finally:
+            writer.Close()
+    finally:
+        stream.Close()
+
+    write_to_log(folder, name, counter)
+
+
+def save_raw(folder: str, package, provider, counter: list[int]) -> None:
+    name = str(package.Name)
+    out_path = Path(export_directory) / folder / name
+    if not check_file(out_path):
+        return
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    data = bytes(provider.Files[package.Path].Read())
+    write_to_file(folder, name, data, name, counter)
+
+
+def try_load_locmeta(package) -> tuple[bool, Any]:
+    ok, reader = package.TryCreateReader()
+    if not ok or reader is None:
+        return False, None
+    try:
+        return True, FTextLocalizationMetaDataResource(reader)
+    except Exception:
+        return False, None
+
+
+def try_load_locres(package) -> tuple[bool, Any]:
+    ok, reader = package.TryCreateReader()
+    if not ok or reader is None:
+        return False, None
+    try:
+        return True, FTextLocalizationResource(reader)
+    except Exception:
+        return False, None
+
+
+def save_texture(folder: str, texture: UTexture, platform: ETexturePlatform, options: ExporterOptions, counter: list[int], name_prefix='') -> None:
+    out_base = Path(export_directory) / folder / str(texture.Name)
+    for ext in (".png", ".hdr"):
+        p = out_base.with_suffix(ext)
+        if not check_file(p, silent=True):
+            check_file(p, silent=False)
+            return
+
+    if isinstance(texture, UTexture2DArray):
+        bitmaps = list(TextureDecoder.DecodeTextureArray(texture, platform))
+    else:
+        bitmap = TextureDecoder.Decode(texture, platform)
+        if isinstance(texture, UTextureCube):
+            bitmap = CubemapConverter.ToPanorama(bitmap) if bitmap is not None else None
+        bitmaps = [bitmap]
+
+    for bitmap in bitmaps or []:
+        if bitmap is None:
+            continue
+        result = TextureEncoder.Encode(bitmap, options.TextureFormat, options.ExportHdrTexturesAsHdr)
+        if isinstance(result, tuple):
+            encoded, extension = result
+        else:
+            encoded, extension = result, "png"
+        file_name = f"{name_prefix}{texture.Name}.{extension}"
+        write_to_file(folder, file_name, bytes(encoded), f"{file_name} ({bitmap.Width}x{bitmap.Height})", counter)
+
+
+def filter_paths(paths: Iterable[str], pattern: str) -> list[str]:
+    return [p for p in paths if fnmatch.fnmatch(p, pattern)]
+
+
+def execute(options: CliOptions) -> int:
+    global export_directory, overwrite_files
+
+    overwrite_files = options.yes
+
+    if options.verbose:
+        Log.Logger = with_console(LoggerConfiguration().MinimumLevel.Verbose()).CreateLogger()
+    else:
+        Log.Logger = with_console(LoggerConfiguration().MinimumLevel.Fatal()).CreateLogger()
+
+    try:
+        game_version = parse_enum(EGame, options.game, "GAME_UE5_LATEST")
+    except Exception:
+        raise ValueError(f"Invalid game version: {options.game}")
+
+    if options.mappings and (not Path(options.mappings).exists()):
+        print(f"Mappings not found: {options.mappings}", file=sys.stderr)
+        return 1
+
+    version = VersionContainer(game_version, ETexturePlatform.DesktopMobile)
+
+    single_pak_mode = bool(options.pak)
+    if single_pak_mode:
+        if not Path(options.pak).exists():
+            print(f"Pak file not found: {options.pak}", file=sys.stderr)
+            return 1
+        print(f"Loading single pak: {norm_path(options.pak)}...", file=sys.stderr)
+        pak_dir = str(Path(options.pak).resolve().parent)
+        provider = DefaultFileProvider(pak_dir, SearchOption.TopDirectoryOnly, VersionContainer(game_version))
+    else:
+        directory = options.sources[0] if options.sources else None
+        if not directory:
+            return 0
+        print(f"Loading {norm_path(directory)}...", file=sys.stderr)
+        if directory.endswith(".apk"):
+            provider = ApkFileProvider(directory, VersionContainer(game_version))
+        else:
+            provider = DefaultFileProvider(directory, SearchOption.AllDirectories, VersionContainer(game_version), StringComparer.OrdinalIgnoreCase)
+
+    if options.mappings and Path(options.mappings).exists():
+        provider.MappingsContainer = FileUsmapTypeMappingsProvider(options.mappings)
+
+    oodle_path = os.path.join(tempfile.gettempdir(), str(OodleHelper.OodleFileName))
+    OodleHelper.DownloadOodleDll(oodle_path)
+    OodleHelper.Initialize(oodle_path)
+
+    zlib_path = os.path.join(tempfile.gettempdir(), str(ZlibHelper.DLL_NAME))
+    ZlibHelper.DownloadDll(zlib_path)
+    ZlibHelper.Initialize(zlib_path)
+
+    if single_pak_mode:
+        provider.RegisterVfs(options.pak)
+    else:
+        provider.Initialize()
+
+    for key_entry in options.key:
+        provider.SubmitKey(FGuid(), FAesKey(key_entry))
+
+    provider.SubmitKey(FGuid(0,0,0,0), FAesKey(bytearray(32)))
+    provider.PostMount()
+
+    try:
+        provider.ChangeCulture(provider.GetLanguageCode(ELanguage.English))
+    except Exception as exc:
+        msg = "expected for single-pak mode" if single_pak_mode else "culture loading failed"
+        Log.Warning(f"Warning: Culture loading failed ({msg}): {exc}")
+
+    print(f"Total assets: {provider.Files.Count}", file=sys.stderr)
+    print(f"Output format: {options.format}", file=sys.stderr)
+
+    detex_path = os.path.join(tempfile.gettempdir(), str(DetexHelper.DLL_NAME))
+    if not Path(detex_path).exists():
+        DetexHelper.LoadDllAsync(detex_path).GetAwaiter().GetResult()
+    DetexHelper.Initialize(detex_path)
+
+    package_paths: list[str] = []
+    for list_file in options.config:
+        if list_file and Path(list_file).exists():
+            print(f"Loading file list: {norm_path(list_file)}", file=sys.stderr)
+            for line in Path(list_file).read_text(encoding="utf-8", errors="ignore").splitlines():
+                t = line.strip()
+                if not t or t.startswith("#") or t.startswith("["):
+                    continue
+                package_paths.append(t)
+
+    for item in options.package:
+        if item:
+            package_paths.append(item)
+
+    if not package_paths:
+        package_paths = ["*"]
+
+    packages = []
+    keys = list(provider.Files.Keys)
+    for path in package_paths:
+        if any(ch in path for ch in ("*", "?")):
+            matched_keys = filter_paths(keys, path)
+            matched = [provider.Files[k] for k in matched_keys]
+            print(f"Added wildcard: {path} ({len(matched)} matches)", file=sys.stderr)
+        else:
+            ok, obj = provider.Files.TryGetValue(path)
+            matched = [obj] if ok else []
+        packages.extend(matched)
+
+    if not packages:
+        print("No matches, exiting.", file=sys.stderr)
+        return 0
+
+    export_type = ExportType.TEXTURE | ExportType.SOUND | ExportType.MESH | ExportType.ANIMATION | ExportType.OTHER
+
+    exp_options = ExporterOptions()
+    exp_options.LodFormat = parse_enum(ELodFormat, options.lod_format, "AllLods")
+    exp_options.MeshFormat = parse_enum(EMeshFormat, options.mesh_format, "ActorX")
+    exp_options.AnimFormat = parse_enum(EAnimFormat, options.anim_format, "ActorX")
+    exp_options.MaterialFormat = parse_enum(EMaterialFormat, options.material_format, "AllLayersNoRef")
+    exp_options.TextureFormat = parse_enum(ETextureFormat, options.texture_format, "Png")
+    exp_options.CompressionFormat = parse_enum(EFileCompressionFormat, options.compression, "None")
+    exp_options.Platform = version.Platform
+    exp_options.SocketFormat = parse_enum(ESocketFormat, options.socket_format, "Bone")
+    exp_options.ExportMorphTargets = options.export_morph_targets
+    exp_options.ExportMaterials = options.export_materials
+    exp_options.ExportHdrTexturesAsHdr = options.export_hdr_as_hdr
+
+    needs_output_dir = (not options.list_only) and options.format not in ("csv", "json")
+    if not options.output:
+        if needs_output_dir:
+            print("Output directory is not specified. Use -o <dir> or use -f json/csv/-l for stdout output.", file=sys.stderr)
+            return 1
+        export_directory = ""
+    else:
+        export_directory = norm_path(options.output)
+
+    import threading
+    from concurrent.futures import ThreadPoolExecutor, as_completed
+
+    counter_lock = threading.Lock()
+    export_count = [0]
+    counter = 0
+    start = time.monotonic()
+
+    def process_package(package):
+        folder = str(package.Path).rsplit("/", 1)[0] if "/" in str(package.Path) else ""
+        ext = Path(str(package.Name)).suffix.lower()
+        target_format = options.format
+
+        if target_format != "raw":
+            if ext == ".umap" and target_format != "png":
+                target_format = "json"
+            elif ext == ".locmeta":
+                ok, locmeta = try_load_locmeta(package)
+                if ok:
+                    save_json(folder, str(package.Name), locmeta, export_count)
+                    return True
+            elif ext == ".locres":
+                ok, locres = try_load_locres(package)
+                if ok:
+                    save_json(folder, str(package.Name), locres, export_count)
+                    return True
+
+        ok, pkg = provider.TryLoadPackage(package)
+        if not ok or pkg is None:
+            if ext in (".uasset", ".umap"):
+                raise RuntimeError("Could not load standard asset, check game version, mappings or keys.")
+            if target_format in ("auto", "raw"):
+                target_format = "raw"
+            else:
+                return True
+
+        if target_format == "raw":
+            save_raw(folder, package, provider, export_count)
+            return True
+
+        if target_format == "json":
+            save_json(folder, str(package.Name), pkg.GetExports(), export_count)
+            return True
+
+        if target_format not in ("auto", "png"):
+            return True
+
+        if target_format == "png":
+            local_export_type = ExportType.TEXTURE
+        else:
+            local_export_type = ExportType.TEXTURE | ExportType.SOUND | ExportType.MESH | ExportType.ANIMATION | ExportType.OTHER
+
+        parsed = False
+
+        for i in range(pkg.ExportMapLength):
+            pointer = FPackageIndex(pkg, i + 1).ResolvedObject
+            if pointer is None or pointer.Object is None:
+                continue
+            dummy = AbstractUePackage.ConstructObject(pkg, pointer.Class, pkg)
+            if dummy is None:
+                continue
+
+            value = pointer.Object.Value
+            if isinstance(dummy, UTexture) and (ExportType.TEXTURE in local_export_type) and isinstance(value, UTexture):
+
+                name_prefix = folder if ext != ".umap" else str(package.Path).rsplit(".", 1)[0]+'.'+str(i)+'.'
+                try:
+                    save_texture(folder, value, exp_options.Platform, exp_options, export_count, name_prefix)
+                except Exception as exc:
+                    Log.Warning("failed to decode {ValueName}: {Error}", value.Name, exc)
+                parsed = True
+
+            elif isinstance(dummy, (USoundWave, UAkMediaAssetData)) and (ExportType.SOUND in local_export_type):
+                fmt_ref = clr.Reference[str]("")
+                data_ref = clr.Reference[object](None)
+                value.Decode(True, fmt_ref, data_ref)
+                if data_ref.Value is not None:
+                    file_name = f"{value.Name}.{str(fmt_ref.Value).lower()}"
+                    write_to_file(folder, file_name, bytes(data_ref.Value), file_name, export_count)
+                parsed = True
+
+            elif isinstance(dummy, (UAnimSequenceBase, USkeletalMesh, UStaticMesh, USkeleton)) and (
+                ExportType.ANIMATION in local_export_type or ExportType.MESH in local_export_type
+            ):
+                exporter = CUE4Exporter(value, exp_options)
+                ok_write, _, file_path = exporter.TryWriteToDir(DirectoryInfo(export_directory), None, None)
+                if ok_write:
+                    write_to_log(folder, os.path.basename(str(file_path)), export_count)
+                parsed = True
+
+        if not parsed and (target_format == 'json' or target_format == 'auto'):
+            save_json(folder, str(package.Name), pkg.GetExports(), export_count)
+
+        return True
+
+    if options.list_only:
+        for package in packages:
+            if options.format == "csv":
+                print(f"{package.Path},{provider.Files[package.Path].Size}")
+            else:
+                print(package.Path)
+    else:
+
+        max_workers = os.cpu_count() or 4 if not DEBUG else 1
+        fatal_error = [None]  # shared error slot
+
+        print(f"Using parallel processing, {max_workers} threads", file=sys.stderr)
+
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = {executor.submit(process_package, pkg): pkg for pkg in packages}
+            for future in as_completed(futures):
+                if fatal_error[0]:
+                    executor.shutdown(wait=False, cancel_futures=True)
+                    break
+                with counter_lock:
+                    counter += 1
+                    if not options.verbose:
+                        print(f"Exporting package {counter} of {len(packages)}...      \r", end="", file=sys.stderr)
+                try:
+                    future.result()
+                except RuntimeError as e:
+                    fatal_error[0] = e
+                    print(str(e), file=sys.stderr)
+
+        if fatal_error[0]:
+            return 1
+
+    elapsed = time.monotonic() - start
+
+    if not options.verbose:
+        print(f"Processed {len(packages)} packages in {elapsed:.2f}s", file=sys.stderr)
+
+    Log.Information(f"Processed {len(packages)} packages in {elapsed:.2f}s")
+    return 0
+
+import argparse
+
+class CustomHelpFormatter(argparse.RawTextHelpFormatter):
+    def __init__(self, prog):
+        super().__init__(prog, max_help_position=60, width=120)
+        self.show_extended = False
+    def _get_help_string(self, action):
+        help_string = action.help or ''
+        if action.default is not None and action.default != argparse.SUPPRESS:
+            if action.default == [] or action.default is False:
+                return help_string
+            if '%(default)' not in help_string:
+                help_string += ' (default: %(default)s)'
+        return help_string
+
+examples = [
+    ["Export all package names to a text file:", "cue4parse -i MyGame -l > packages.txt"],
+    ["Export a single package to stdout in json format:", "cue4parse -i MyGame -p Assets/MyAsset.uasset -f json"],
+    ["Export multiple packages matching wildcard patterns to a directory:", "cue4parse -i MyGame -p */Textures* -p */Icons* -o Exports"],
+    ["Export packages from list, overwrite existing files:", "cue4parse -i MyGame -c packages.txt -o Exports -y"],
+    ["Export with PSK meshes and PSA animations:", "cue4parse -i MyGame -p */SkeletalMeshes/* -o Exports --mesh-format ActorX --anim-format ActorX"],
+    ["Process a single .pak file:", "cue4parse --pak MyMod.pak -o Exports -m Mappings.usmap -g GAME_UE5_1"],
+]
+
+parser = argparse.ArgumentParser(
+    prog="cue4parse",
+    description=f"CUE4Parse-Python {version('cue4parse')}: a command line tool to extract resources from Unreal Engine games",
+    epilog='\n\n'.join(f'{a}\n    {b}'for a,b in examples),
+    formatter_class=CustomHelpFormatter,
+    add_help = True,
+)
+
+parser.add_argument("-i", "--input", metavar="INPUT", action="append", default=[], dest="sources", help="Input game directory or pak/asset file (repeatable)")
+parser.add_argument("-o", "--output", help="Output directory (optional for list/json/csv modes)")
+parser.add_argument("-p", "--package", action="append", default=[], help="Package path or wildcard pattern (repeatable)")
+parser.add_argument("-c", "--config", action="append", default=[], help="Package list file (repeatable)")
+parser.add_argument("-g", "--game", default="GAME_UE5_LATEST", help="Game version")
+parser.add_argument("-k", "--key", action="append", default=[], help="AES key in hex format (repeatable)")
+parser.add_argument("-m", "--mappings", help="Mappings file")
+parser.add_argument("-f", "--format", default="auto", help="Output format: auto, raw, json, csv, png")
+parser.add_argument("-l", "--list", action="store_true", dest="list_only", help="List matching packages (supports auto and csv)")
+parser.add_argument("-y", "--yes", action="store_true", help="Overwrite existing files")
+parser.add_argument("-v", "--verbose", action="store_true", help="Enable verbose output")
+
+# more options
+parser.add_argument("--pak", help="Single .pak file to process (no directory scanning)")
+parser.add_argument("--mesh-format", default="ActorX", help="Mesh format: ActorX (psk), Gltf2 (glb), UEFormat (uemodel), OBJ")
+parser.add_argument("--anim-format", default="ActorX", help="Animation format: ActorX (psa), UEFormat (ueanim)")
+parser.add_argument("--texture-format", default="Png", help="Texture format: Png, Jpeg, Tga, Dds")
+parser.add_argument("--material-format", default="AllLayersNoRef", help="Material format: FirstLayer, AllLayersNoRef, AllLayers")
+parser.add_argument("--lod-format", default="AllLods", help="LOD format: FirstLod, AllLods")
+parser.add_argument("--socket-format", default="Bone", help="Socket format: Bone, Socket, None")
+parser.add_argument("--nanite-format", default="AllLayersNaniteFirst", help="Nanite format: OnlyNaniteLOD, OnlyNormalLODs, AllLayersNaniteFirst, AllLayersNaniteLast")
+parser.add_argument("--export-morph-targets", action=argparse.BooleanOptionalAction, default=True, help="Export morph targets")
+parser.add_argument("--export-materials", action=argparse.BooleanOptionalAction, default=True, help="Export materials with meshes")
+parser.add_argument("--export-hdr-as-hdr", action=argparse.BooleanOptionalAction, default=True, help="Export HDR textures as .hdr")
+parser.add_argument("--compression", default="None", help="Compression: None, GZIP, ZSTD")
+
+def main(argv: list[str] | None = None) -> int:
+    argv = argv if argv is not None else sys.argv[1:]
+    if not argv:
+        parser.print_help()
+        return 0
+    return execute(parser.parse_args(argv))
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cue4parse-0.0.2/src/cue4parse/core.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import fnmatch
+import json
+import logging
+import os
+import sys
+import time
+from dataclasses import dataclass
+from enum import Flag, auto
+from pathlib import Path
+from typing import Any, Iterable
+
+from cue4parse import _DLL_DIR
+
+def _find_dotnet_root() -> Path | None:
+    candidates = [
+        Path.home() / ".dotnet",
+        Path("/usr/share/dotnet"),
+        Path("/usr/lib/dotnet"),
+    ]
+    for candidate in candidates:
+        if (candidate / "host" / "fxr").exists():
+            return candidate
+    return None
+
+def _find_runtime_config() -> str | None:
+    libs_dir = Path(__file__).parent / "libs"
+    configs = list(libs_dir.glob("*.runtimeconfig.json"))
+    return str(configs[0]) if configs else None
+
+dotnet_root = _find_dotnet_root()
+if dotnet_root:
+    os.environ["DOTNET_ROOT"] = str(dotnet_root)
+
+import pythonnet
+
+runtime_config = _find_runtime_config()
+if runtime_config:
+    pythonnet.load("coreclr", runtime_config=runtime_config)
+else:
+    pythonnet.load("coreclr")
+
+import clr
+
+libs_dir = _DLL_DIR
+cue4parse_dll_dir = str(libs_dir)
+sys.path.append(cue4parse_dll_dir)
+
+clr.AddReference("CUE4Parse")
+clr.AddReference("CUE4Parse-Conversion")
+
+clr.AddReference("System")
+clr.AddReference("System.Core")
+clr.AddReference("Newtonsoft.Json")
+
+clr.AddReference("Serilog")
+clr.AddReference("Serilog.Sinks.Console")
+
+import System
+from Serilog import Log, LoggerConfiguration
+from Serilog.Events import LogEventLevel
+from Serilog.Configuration import LoggerSinkConfiguration
+
+def with_console(cfg: LoggerConfiguration) -> LoggerConfiguration:
+    asm = System.Reflection.Assembly.Load("Serilog.Sinks.Console")
+    bf = System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static
+    lsc_t = clr.GetClrType(LoggerSinkConfiguration)
+    for t in asm.GetTypes():
+        if not (t.IsSealed and t.IsAbstract):
+            continue
+        for m in t.GetMethods(bf):
+            if m.Name != "Console":
+                continue
+            ps = m.GetParameters()
+            if len(ps) >= 1 and ps[0].ParameterType == lsc_t:
+                args = [System.Type.Missing] * len(ps)
+                args[0] = cfg.WriteTo
+                # Find and set the standardErrorFromLevel parameter so it's stderr, not stdout
+                for i, p in enumerate(ps):
+                    if p.Name == "standardErrorFromLevel":
+                        lel_t = System.Type.GetType("Serilog.Events.LogEventLevel, Serilog")
+                        args[i] = System.Enum.Parse(lel_t, "Verbose")
+                        break
+                m.Invoke(None, System.Array[System.Object](args))
+                return cfg
+    raise RuntimeError("Serilog console sink extension method not found")
+
+# you can re-define it in user code later with Verbose() or any other level
+Log.Logger = with_console(LoggerConfiguration().MinimumLevel.Fatal()).CreateLogger()

cue4parse-0.0.2/src/cue4parse/example.py

@@ -0,0 +1,38 @@
+import time
+from cue4parse import *
+
+GAME_DIR = r"E:\Games\Subnautica2\Subnautica2\Content\Paks"
+MAPPINGS_FILE = r"E:\Games\Subnautica2\Subnautica2.usmap"
+
+def main():
+    start = time.perf_counter()
+
+    Log.Logger = with_console(LoggerConfiguration().MinimumLevel.Verbose()).CreateLogger()
+
+    version = VersionContainer(EGame.GAME_UE5_6, ETexturePlatform.DesktopMobile)
+    provider = DefaultFileProvider(GAME_DIR, SearchOption.TopDirectoryOnly, version, StringComparer.OrdinalIgnoreCase)
+
+    provider.MappingsContainer = FileUsmapTypeMappingsProvider(MAPPINGS_FILE)
+    provider.Initialize()
+
+    provider.SubmitKey(FGuid(0,0,0,0), FAesKey(bytearray(32)))
+    provider.PostMount()
+
+    package_path = 'Subnautica2/Content/Maps/Main/L_Main.umap'
+
+    ok, package = provider.TryLoadPackage(package_path)
+
+    exports = package.GetExports()
+
+    name_filter = lambda name: 'Lifepod' in str(name)
+
+    for export in exports:
+        name = str(export)
+        if not name_filter(name):
+            continue
+        print(export.ExportType)
+
+    print(f'Finished in {time.perf_counter() - start:.4f}s')
+
+if __name__ == '__main__':
+    raise SystemExit(main())

cue4parse-0.0.2/src/cue4parse/includes.py

@@ -0,0 +1,34 @@
+from cue4parse import *
+
+from System import Console
+from System.IO import StreamWriter, StringWriter, TextWriter
+from System.Text import Encoding
+from Newtonsoft.Json import JsonSerializer, Formatting, JsonTextWriter, JsonConvert
+
+from System import Guid, StringComparer
+from System.IO import SearchOption, DirectoryInfo
+from CUE4Parse.Compression import OodleHelper, ZlibHelper
+from CUE4Parse.Encryption.Aes import FAesKey
+from CUE4Parse.FileProvider import DefaultFileProvider, ApkFileProvider
+from CUE4Parse.MappingsProvider import FileUsmapTypeMappingsProvider
+from CUE4Parse.UE4.Assets import AbstractUePackage
+from CUE4Parse.UE4.Assets.Exports.Animation import UAnimSequenceBase, USkeleton
+from CUE4Parse.UE4.Assets.Exports.SkeletalMesh import USkeletalMesh
+from CUE4Parse.UE4.Assets.Exports.Sound import USoundWave
+from CUE4Parse.UE4.Assets.Exports.StaticMesh import UStaticMesh
+from CUE4Parse.UE4.Assets.Exports.Texture import UTexture, UTexture2DArray, UTextureCube
+from CUE4Parse.UE4.Assets.Exports.Wwise import UAkMediaAssetData
+from CUE4Parse.UE4.Localization import FTextLocalizationResource, FTextLocalizationMetaDataResource
+from CUE4Parse.UE4.Objects.Core.Misc import FGuid
+from CUE4Parse.UE4.Objects.UObject import FPackageIndex
+from CUE4Parse.UE4.Versions import VersionContainer, EGame, ELanguage
+from CUE4Parse.UE4.Assets.Exports.Texture import ETexturePlatform
+
+from CUE4Parse_Conversion import Exporter as CUE4Exporter, ExporterOptions
+from CUE4Parse_Conversion.Animations import EAnimFormat
+from CUE4Parse_Conversion.Meshes import EMeshFormat, ELodFormat, ESocketFormat
+from CUE4Parse_Conversion.Textures import ETextureFormat, TextureDecoder, TextureEncoder, CubemapConverter, CTexture
+from CUE4Parse_Conversion.Textures.BC import DetexHelper
+from CUE4Parse_Conversion.UEFormat.Enums import EFileCompressionFormat
+from CUE4Parse.UE4.Assets.Exports.Material import EMaterialFormat
+

cue4parse-0.0.2/src/cue4parse/setup.bat

@@ -0,0 +1,98 @@
+@echo off
+setlocal enabledelayedexpansion
+
+set "SCRIPT_DIR=%~dp0"
+set "LIBS_DIR=%LOCALAPPDATA%\cue4parse\libs"
+set "TMP_DIR=%TEMP%\cue4parse-setup"
+
+echo === cue4parse dependency setup (Windows) ===
+
+if exist "%TMP_DIR%" rmdir /s /q "%TMP_DIR%"
+mkdir "%TMP_DIR%"
+
+rem add "goto git" here if you want to build dlls locally
+
+echo Downloading fmodel
+for /f "usebackq tokens=*" %%i in (`powershell -command "(Invoke-RestMethod -Uri 'https://api.fmodel.app/v1/infos/Qa').downloadUrl"`) do set DOWNLOAD_URL=%%i
+if errorlevel 1 goto git
+
+curl.exe -L -o "%TMP_DIR%\FModel.zip" "%DOWNLOAD_URL%" || goto git
+powershell -command "Expand-Archive -Force '%TMP_DIR%\FModel.zip' '%TMP_DIR%'" || goto git
+
+where dotnet >nul 2>&1 || (
+    echo Installig dotnet
+    winget install Microsoft.DotNet.SDK.10 --accept-package-agreements --accept-source-agreements || goto git
+)
+
+where sfextract >nul 2>&1 || (
+    echo Installig sfextract
+    dotnet tool install -g sfextract || goto git
+)
+
+echo Running sfextract
+sfextract "%TMP_DIR%\FModel.exe" --output "%LIBS_DIR%" || goto git
+
+goto success
+
+:git
+
+:: Check git
+where git >nul 2>&1
+if %errorlevel% neq 0 (
+    echo ERROR: git is required. Install from https://git-scm.com
+    exit /b 1
+)
+
+:: Check/install dotnet
+where dotnet >nul 2>&1
+if %errorlevel% neq 0 (
+    echo dotnet not found. Installing via winget...
+    winget install Microsoft.DotNet.SDK.10 --accept-package-agreements --accept-source-agreements
+    if %errorlevel% neq 0 (
+        echo ERROR: Failed to install dotnet. Install manually: https://dotnet.microsoft.com/download
+        exit /b 1
+    )
+    :: Refresh PATH so dotnet is available in this session
+    for /f "tokens=*" %%i in ('where dotnet 2^>nul') do set "DOTNET_PATH=%%i"
+    if "!DOTNET_PATH!"=="" (
+        set "PATH=%PATH%;%ProgramFiles%\dotnet"
+    )
+)
+
+
+echo Cloning CUE4Parse...
+git clone --depth=1 https://github.com/FabianFG/CUE4Parse.git "%TMP_DIR%\CUE4Parse"
+if %errorlevel% neq 0 (echo ERROR: git clone failed. && exit /b 1)
+
+:: Build
+echo Building...
+
+set "SLN=%TMP_DIR%\CUE4Parse\CUE4Parse.slnx"
+if not exist "%SLN%" (
+    echo ERROR: CUE4Parse.slnx not found.
+    exit /b 1
+)
+
+echo Building solution...
+dotnet publish "%SLN%" --configuration Release --output "%TMP_DIR%\build" --self-contained false  --runtime win-x64
+
+if %errorlevel% neq 0 (echo ERROR: Build failed. && exit /b 1)
+
+:: Copy DLLs
+echo Copying libraries to %LIBS_DIR% ...
+if not exist "%LIBS_DIR%" mkdir "%LIBS_DIR%"
+set COUNT=0
+for %%f in ("%TMP_DIR%\build\*.dll") do (
+    copy /y "%%f" "%LIBS_DIR%\" >nul
+    set /a COUNT+=1
+    echo   copied: %%~nxf
+)
+echo Copied !COUNT! libraries to %LIBS_DIR%
+
+:success
+
+:: Cleanup
+rmdir /s /q "%TMP_DIR%"
+
+echo.
+echo Done. Libraries installed to %LIBS_DIR%

cue4parse-0.0.2/src/cue4parse/setup.sh

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+LIBS_DIR="$HOME/.local/share/cue4parse/libs"
+
+echo "=== cue4parse Linux dependency setup ==="
+
+# Install dotnet if missing
+if ! command -v dotnet &>/dev/null; then
+    echo "dotnet not found, installing..."
+    if command -v apt-get &>/dev/null; then
+        sudo apt-get install -y dotnet-sdk-10.0
+    elif command -v dnf &>/dev/null; then
+        sudo dnf install -y dotnet-sdk-10.0
+    elif command -v pacman &>/dev/null; then
+        sudo pacman -Sy --noconfirm dotnet-sdk
+    elif command -v zypper &>/dev/null; then
+        sudo zypper install -y dotnet-sdk-10.0
+    else
+        echo "No supported package manager found. Installing via Microsoft script..."
+        curl -fsSL https://dot.net/v1/dotnet-install.sh | bash -s -- --channel 10.0
+        export DOTNET_ROOT="$HOME/.dotnet"
+        export PATH="$DOTNET_ROOT:$DOTNET_ROOT/tools:$PATH"
+    fi
+fi
+
+export PATH="$HOME/.dotnet/tools:$PATH"
+
+# Clone and build CUE4Parse
+TMP=$(mktemp -d)
+trap 'rm -rf "$TMP"' EXIT
+
+for cmd in git make gcc; do
+    command -v "$cmd" &>/dev/null || { echo "ERROR: $cmd is required. Install it with your package manager."; exit 1; }
+done
+
+echo "Cloning CUE4Parse..."
+git clone --depth=1 https://github.com/FabianFG/CUE4Parse.git "$TMP/CUE4Parse"
+
+echo "Building..."
+
+SLN="$TMP/CUE4Parse/CUE4Parse.slnx"
+if [ ! -f "$SLN" ]; then
+    echo "ERROR: CUE4Parse.slnx not found."
+    exit 1
+fi
+
+echo "Building solution..."
+dotnet publish "$SLN" --configuration Release --output "$TMP/build" --self-contained false --runtime linux-x64
+
+# Build Detex from source
+echo "Building Detex..."
+git clone --depth=1 https://github.com/hglm/detex "$TMP/detex"
+
+# Set SHARED library configuration
+sed -i 's/^LIBRARY_CONFIGURATION.*/LIBRARY_CONFIGURATION = SHARED/' "$TMP/detex/Makefile.conf"
+
+# Patch detexDecompressTextureLinear to use DETEX_HELPER_SHARED_EXPORT
+sed -i 's/DETEX_API bool detexDecompressTextureLinear/DETEX_HELPER_SHARED_EXPORT bool detexDecompressTextureLinear/' "$TMP/detex/detex.h"
+
+make -C "$TMP/detex"
+ls "$TMP/detex/"
+cp $TMP/detex/libdetex.so* "$LIBS_DIR/Detex.so"
+echo "  copied: Detex.so"
+
+echo "Copying libraries to $LIBS_DIR..."
+mkdir -p "$LIBS_DIR"
+find "$TMP/build" \( -name "*.so" -o -name "*.so.*" -o -name "*.dll"  -o -name "*.runtimeconfig.json" \) -exec cp {} "$LIBS_DIR/" \;
+
+echo "Done. Libraries installed to $LIBS_DIR"

cue4parse-0.0.2/src/cue4parse/setup_deps.py

@@ -0,0 +1,42 @@
+import sys
+import os
+import subprocess
+from pathlib import Path
+
+from cue4parse import _DLL_DIR
+
+PLATFORM = sys.platform
+
+def natives_present() -> bool:
+    glob = "*.dll" if PLATFORM == "win32" else "*.so"
+    return _DLL_DIR.exists() and any(_DLL_DIR.glob(glob))
+
+def _run_script(script: Path, *extra_args: str) -> int:
+    """Run a script and return the returncode (0 for success, non-zero for failure)"""
+    if not script.exists():
+        raise RuntimeError(f"Setup script not found: {script}")
+    args = [*extra_args, "--force"] if "--force" in sys.argv else list(extra_args)
+    if PLATFORM == "win32":
+        result = subprocess.run([str(script), *args], shell=True)
+        return result.returncode
+    else:
+        result = subprocess.run(["bash", str(script), *args])
+        return result.returncode
+
+def main() -> None:
+    if PLATFORM not in ("win32", "linux"):
+        print(f"Unsupported platform: {PLATFORM}. Only Windows and Linux are supported.")
+        sys.exit(1)
+
+    if natives_present() and "--force" not in sys.argv:
+        print(f"Already set up. Use --force to reinstall.")
+        return
+
+    scripts = Path(__file__).parent
+    if PLATFORM == "win32":
+        _run_script(scripts / "setup.bat")
+    else:
+        _run_script(scripts / "setup.sh")
+
+if __name__ == "__main__":
+    main()

cue4parse-0.0.2/upload.cmd

@@ -0,0 +1 @@
+python -m twine upload dist/*