| from __future__ import annotations |
|
|
| import argparse |
| import pickle |
| import sys |
| from pathlib import Path |
|
|
| import bpy |
| import numpy as np |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| argv_source = getattr(bpy.app, "argv", None) |
| if argv_source is None: |
| argv_source = sys.argv |
|
|
| argv: list[str] = [] |
| if "--" in argv_source: |
| argv = argv_source[argv_source.index("--") + 1 :] |
|
|
| parser = argparse.ArgumentParser(description="Extract triangle meshes from a .blend/.glb/.gltf scene") |
| parser.add_argument( |
| "--input", |
| default=None, |
| help="Input scene path. If omitted, uses the file already opened by Blender.", |
| ) |
| parser.add_argument("--output", required=True, help="Output pickle path") |
| parser.add_argument( |
| "--frame_mode", |
| default="first_mid_last", |
| help="Frame sampling mode: first_only, first_mid_last, last_only, or exact:<frame>", |
| ) |
| return parser.parse_args(argv) |
|
|
|
|
| def load_input_scene(input_path: str | None) -> None: |
| if not input_path: |
| return |
|
|
| path = Path(input_path).resolve() |
| if not path.exists(): |
| raise FileNotFoundError(f"Input scene does not exist: {path}") |
|
|
| ext = path.suffix.lower() |
| if ext == ".blend": |
| bpy.ops.wm.open_mainfile(filepath=str(path)) |
| return |
|
|
| if ext in {".glb", ".gltf"}: |
| bpy.ops.object.select_all(action="SELECT") |
| bpy.ops.object.delete() |
| bpy.ops.import_scene.gltf(filepath=str(path)) |
| return |
|
|
| raise ValueError(f"Unsupported input scene extension: {path.suffix}") |
|
|
|
|
| def _parse_exact_frame(mode: str) -> int | None: |
| if not mode.startswith("exact:"): |
| return None |
| raw = mode.split(":", 1)[1].strip() |
| if not raw: |
| raise ValueError("exact frame mode requires a frame number, e.g. exact:55") |
| return int(raw) |
|
|
|
|
| def frame_indices(scene: bpy.types.Scene, mode: str) -> list[int]: |
| start = int(scene.frame_start) |
| end = int(scene.frame_end) |
| if end < start: |
| end = start |
|
|
| exact = _parse_exact_frame(mode) |
| if exact is not None: |
| return [exact] |
|
|
| if mode == "last_only": |
| return [end] |
|
|
| if mode == "first_only": |
| return [start] |
|
|
| if mode != "first_mid_last": |
| raise ValueError(f"Unsupported frame_mode: {mode}") |
|
|
| if start == end: |
| return [start] |
|
|
| mid = (start + end) // 2 |
| out: list[int] = [] |
| for f in (start, mid, end): |
| if f not in out: |
| out.append(f) |
| return out |
|
|
|
|
| def world_vertices(obj_eval: bpy.types.Object, mesh: bpy.types.Mesh) -> np.ndarray: |
| local = np.empty(len(mesh.vertices) * 3, dtype=np.float32) |
| mesh.vertices.foreach_get("co", local) |
| local = local.reshape(-1, 3) |
|
|
| mat = np.array(obj_eval.matrix_world, dtype=np.float32) |
| rot = mat[:3, :3] |
| trans = mat[:3, 3] |
| return (local @ rot.T + trans).astype(np.float32, copy=False) |
|
|
|
|
| def extract_frame(scene: bpy.types.Scene, frame: int) -> dict[str, dict[str, np.ndarray]]: |
| scene.frame_set(frame) |
| depsgraph = bpy.context.evaluated_depsgraph_get() |
| out: dict[str, dict[str, np.ndarray]] = {} |
|
|
| for obj in scene.objects: |
| if obj.type != "MESH" or obj.hide_render: |
| continue |
|
|
| obj_eval = obj.evaluated_get(depsgraph) |
| mesh = obj_eval.to_mesh(preserve_all_data_layers=False, depsgraph=depsgraph) |
| if mesh is None: |
| continue |
|
|
| try: |
| mesh.calc_loop_triangles() |
| if len(mesh.vertices) == 0 or len(mesh.loop_triangles) == 0: |
| continue |
| verts = world_vertices(obj_eval, mesh) |
| faces = np.array([tri.vertices for tri in mesh.loop_triangles], dtype=np.int32) |
| out[obj.name] = { |
| "vertices": verts, |
| "faces": faces, |
| } |
| finally: |
| obj_eval.to_mesh_clear() |
|
|
| return out |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| load_input_scene(args.input) |
|
|
| output_path = Path(args.output) |
| output_path.parent.mkdir(parents=True, exist_ok=True) |
|
|
| scene = bpy.context.scene |
| frames = frame_indices(scene, args.frame_mode) |
| objects_per_frame: list[dict[str, dict[str, np.ndarray]]] = [] |
|
|
| for frame in frames: |
| objects_per_frame.append(extract_frame(scene, frame)) |
|
|
| payload = { |
| "frame_indices": frames, |
| "objects_per_frame": objects_per_frame, |
| } |
| with output_path.open("wb") as f: |
| pickle.dump(payload, f, protocol=pickle.HIGHEST_PROTOCOL) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
