#!/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 import showcase_schema 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")) try: showcase_schema.validate_manifest(manifest) except showcase_schema.ValidationFailure as exc: raise SystemExit(str(exc)) from exc 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 site_trees_from_spec(spec_path: Path | None) -> list[list[float]]: """Tree anchor points (plan meters) for the viewer's instanced low-poly trees. site_context_from_dump.py emits street trees as short posts under the custom `trees` category; the viewer hides those posts and renders trunk+crown InstancedMeshes at these midpoints instead. """ if not spec_path or not spec_path.exists(): return [] try: spec = showcase_schema.normalize_spec(json.loads(spec_path.read_text(encoding="utf-8"))) except (OSError, json.JSONDecodeError): return [] showcase_schema.validate_spec(spec) trees = [] for floor in spec.get("floors", {}).values(): for seg in floor.get("segments", {}).get("trees", []): trees.append( [ round((seg["start"][0] + seg["end"][0]) / 2, 2), round((seg["start"][1] + seg["end"][1]) / 2, 2), ] ) return trees def write_assets(glb: Path, metadata: Path, out_dir: Path, web_variants: list[dict], site_trees: list[list[float]]): 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 if site_trees: meta["site_trees"] = site_trees (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) variant = default_variant(manifest, variants) spec_value = variant.get("spec") if variant else None spec_path = resolve_manifest_path(manifest_path, spec_value) if (manifest_path and spec_value) else None write_assets(glb, metadata, out_dir, web_variants, site_trees_from_spec(spec_path)) 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())