#!/usr/bin/env python3 """Instantiate the static Three.js web showcase template.""" from __future__ import annotations import argparse import json import shutil import time from pathlib import Path def default_template() -> Path: return Path(__file__).resolve().parents[1] / "assets" / "web-showcase-template" def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--template", default=str(default_template()), help="Template folder") parser.add_argument("--glb", help="Source default GLB model") parser.add_argument("--metadata", help="model_metadata.json from Blender script") parser.add_argument("--variants-manifest", help="Manifest from build_showcase_variants.py") parser.add_argument("--out-dir", required=True, help="Web output folder") parser.add_argument("--title", default="CAD 建筑 Web 展示模型") return parser.parse_args() def copy_template(template: Path, out_dir: Path): if not template.exists(): raise SystemExit(f"Template not found: {template}") out_dir.mkdir(parents=True, exist_ok=True) for item in template.iterdir(): dest = out_dir / item.name if item.is_dir(): shutil.copytree(item, dest, dirs_exist_ok=True) else: shutil.copy2(item, dest) def patch_index(out_dir: Path, title: str, build: str): """Fill template placeholders and stamp a cache-busting build token. Browsers cache ES modules and GLB aggressively; the ?v= query on app.js / model.glb / model_metadata.json forces a reload after a rebuild. """ for name in ("index.html", "app.js"): path = out_dir / name if not path.exists(): continue text = path.read_text(encoding="utf-8") text = text.replace("{{TITLE}}", title).replace("{{BUILD}}", build) path.write_text(text, encoding="utf-8") def resolve_manifest_path(manifest_path: Path, value: str) -> Path: path = Path(value) return path if path.is_absolute() else manifest_path.parent / path def load_variants(manifest_path: Path | None) -> tuple[dict | None, list[dict]]: if not manifest_path: return None, [] if not manifest_path.exists(): raise SystemExit(f"Variants manifest not found: {manifest_path}") manifest = json.loads(manifest_path.read_text(encoding="utf-8")) variants = list(manifest.get("variants", [])) if not variants: raise SystemExit(f"Variants manifest has no variants: {manifest_path}") return manifest, variants def default_variant(manifest: dict | None, variants: list[dict]) -> dict | None: if not variants: return None default_key = (manifest or {}).get("default_key", "standard") for variant in variants: if variant.get("key") == default_key: return variant return variants[0] def copy_variant_assets(manifest_path: Path | None, variants: list[dict], out_dir: Path) -> list[dict]: web_variants = [] for variant in variants: source_value = variant.get("source_glb") or variant.get("source") or variant.get("file") if not source_value: raise SystemExit(f"Variant is missing source_glb/source/file: {variant}") source = resolve_manifest_path(manifest_path, source_value) if manifest_path else Path(source_value) if not source.exists(): raise SystemExit(f"Variant GLB not found: {source}") dest_name = Path(variant.get("file") or f"{variant.get('key', source.stem)}.glb").name shutil.copy2(source, out_dir / dest_name) web_variant = { "key": variant.get("key", Path(dest_name).stem), "label": variant.get("label", variant.get("key", dest_name)), "file": dest_name, } if variant.get("description"): web_variant["description"] = variant["description"] web_variants.append(web_variant) return web_variants def inferred_default_glb(args_glb: str | None, manifest_path: Path | None, manifest: dict | None, variants: list[dict]) -> Path: if args_glb: return Path(args_glb) variant = default_variant(manifest, variants) if not variant: raise SystemExit("Either --glb or --variants-manifest is required") source_value = variant.get("source_glb") or variant.get("source") or variant.get("file") return resolve_manifest_path(manifest_path, source_value) if manifest_path else Path(source_value) def inferred_metadata(args_metadata: str | None, manifest_path: Path | None, manifest: dict | None, variants: list[dict]) -> Path: if args_metadata: return Path(args_metadata) variant = default_variant(manifest, variants) metadata_value = variant.get("metadata") if variant else None if not metadata_value: raise SystemExit("Either --metadata or a default variant metadata entry is required") return resolve_manifest_path(manifest_path, metadata_value) if manifest_path else Path(metadata_value) def write_assets(glb: Path, metadata: Path, out_dir: Path, web_variants: list[dict]): if not glb.exists(): raise SystemExit(f"GLB not found: {glb}") if not metadata.exists(): raise SystemExit(f"Metadata not found: {metadata}") shutil.copy2(glb, out_dir / "model.glb") meta = json.loads(metadata.read_text(encoding="utf-8")) meta.setdefault("files", {})["glb"] = "model.glb" if web_variants: meta["model_variants"] = web_variants (out_dir / "model_metadata.json").write_text( json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8", ) def main() -> int: args = parse_args() out_dir = Path(args.out_dir) manifest_path = Path(args.variants_manifest) if args.variants_manifest else None manifest, variants = load_variants(manifest_path) copy_template(Path(args.template), out_dir) build = str(int(time.time())) patch_index(out_dir, args.title, build) web_variants = copy_variant_assets(manifest_path, variants, out_dir) glb = inferred_default_glb(args.glb, manifest_path, manifest, variants) metadata = inferred_metadata(args.metadata, manifest_path, manifest, variants) write_assets(glb, metadata, out_dir, web_variants) print(json.dumps({"web_dir": str(out_dir), "entry": str(out_dir / "index.html")}, ensure_ascii=False)) return 0 if __name__ == "__main__": raise SystemExit(main())