BlenderをPythonから動かして一括処理する〜GUIを開かずに100個書き出す〜

# -*- coding: utf-8 -*-
"""
p998 材料づくり: 変換の元になる glb を100個つくる。Blenderの中で動く。

  blender -b --factory-startup --python make_sources.py -- --n 100 --tex 512 --out out/src

★現場でよくある形に寄せている:
  - どのファイルも中身の名前が同じ（オブジェクト "Model"・メッシュ "Model"・マテリアル "Material"）
  - 1個ごとにテクスチャ画像（--tex で一辺のピクセル数）を1枚埋め込む
"""
import bpy
import math
import os
import random
import sys


def args():
    import argparse
    a = sys.argv[sys.argv.index("--") + 1:] if "--" in sys.argv else []
    p = argparse.ArgumentParser()
    p.add_argument("--n", type=int, default=100)
    p.add_argument("--tex", type=int, default=512)
    p.add_argument("--out", required=True)
    return p.parse_args(a)


def one(i, tex, out):
    bpy.ops.wm.read_factory_settings(use_empty=True)
    rnd = random.Random(i)
    bpy.ops.mesh.primitive_uv_sphere_add(segments=32 + rnd.randint(0, 32), ring_count=16 + rnd.randint(0, 16),
                                         radius=1.0)
    obj = bpy.context.object
    obj.name = "Model"
    obj.data.name = "Model"
    obj.scale = (1, 1, rnd.uniform(0.5, 2.0))

    img = bpy.data.images.new("Texture", tex, tex)
    # 1個ずつ違う色の縞模様＋ノイズ（中身が同じだと圧縮されてメモリ差が見えにくい）
    import numpy as np
    g = np.random.default_rng(i)
    c = g.random(3)
    band = ((np.arange(tex) // (4 + i % 13)) % 2)[:, None]
    px = np.empty((tex, tex, 4), dtype=np.float32)
    noise = g.random((tex, tex)) * 0.15
    px[..., 0] = c[0] * band + noise
    px[..., 1] = c[1] * (1 - band) + noise
    px[..., 2] = c[2] + noise
    px[..., 3] = 1.0
    px = px.ravel()
    img.pixels.foreach_set(px)
    img.pack()

    mat = bpy.data.materials.new("Material")
    mat.use_nodes = True
    nt = mat.node_tree
    tn = nt.nodes.new("ShaderNodeTexImage")
    tn.image = img
    nt.links.new(tn.outputs["Color"], nt.nodes["Principled BSDF"].inputs["Base Color"])
    obj.data.materials.append(mat)

    path = os.path.join(out, f"src_{i:03d}.glb")
    bpy.ops.export_scene.gltf(filepath=path, export_format="GLB")
    return path


def main():
    a = args()
    out = os.path.abspath(a.out)
    os.makedirs(out, exist_ok=True)
    for i in range(a.n):
        p = one(i, a.tex, out)
        print(f"[src] {i:03d} {os.path.getsize(p)} bytes")
    sys.exit(0)


if __name__ == "__main__":
    main()

# -*- coding: utf-8 -*-
"""
p998 変換の本体（実験2・3・4・6で使用）。Blenderの中で動く。
100個の glb を「読み込む → 面を半分に減らす → glb で書き出す（→ サムネイルを焼く）」を1つのBlenderで回す。

  blender -b --factory-startup --python-exit-code 1 --python convert.py -- --src 元フォルダ --out 出力フォルダ

--cleanup   none（消さない）/ objects（オブジェクトだけ消す）/ purge（孤立データも掃除）/ reset（毎回空のシーンに戻す）
--name-from object（オブジェクト名から出力名を作る）/ source（元ファイル名から作る）
--render    none / workbench / eevee / cycles（サムネイルを焼く）  --res 256 --samples 16
--n / --start  一部だけ処理する（例: --start 37 --n 1）
--naive     try/except も sys.exit も使わない素朴な書き方（失敗したらそこで止まる）

出力: <out>/items/*.glb（*.png）と <out>/log.csv（1個ごとの ok・時間・メモリ・データ数・名前）
"""
import bpy
import csv
import math
import os
import sys
import time
import traceback


# ------------------------------------------------------------------ 小道具

def rss_mb():
    """いまのプロセスの常駐メモリ(MB)。Windowsでは resource が無いので ctypes で取る"""
    if sys.platform == "win32":
        import ctypes
        from ctypes import wintypes

        class PMC(ctypes.Structure):
            _fields_ = [("cb", wintypes.DWORD), ("PageFaultCount", wintypes.DWORD),
                        ("PeakWorkingSetSize", ctypes.c_size_t), ("WorkingSetSize", ctypes.c_size_t),
                        ("QuotaPeakPagedPoolUsage", ctypes.c_size_t), ("QuotaPagedPoolUsage", ctypes.c_size_t),
                        ("QuotaPeakNonPagedPoolUsage", ctypes.c_size_t), ("QuotaNonPagedPoolUsage", ctypes.c_size_t),
                        ("PagefileUsage", ctypes.c_size_t), ("PeakPagefileUsage", ctypes.c_size_t)]
        pmc = PMC()
        pmc.cb = ctypes.sizeof(PMC)
        # ★型を指定しないと 64bit で疑似ハンドル(-1)が int として渡され、ERROR_INVALID_HANDLE で黙って失敗→0.0 になる
        k32 = ctypes.WinDLL("kernel32", use_last_error=True)
        psapi = ctypes.WinDLL("psapi", use_last_error=True)
        k32.GetCurrentProcess.restype = wintypes.HANDLE
        psapi.GetProcessMemoryInfo.argtypes = [wintypes.HANDLE, ctypes.POINTER(PMC), wintypes.DWORD]
        psapi.GetProcessMemoryInfo.restype = wintypes.BOOL
        if not psapi.GetProcessMemoryInfo(k32.GetCurrentProcess(), ctypes.byref(pmc), pmc.cb):
            raise ctypes.WinError(ctypes.get_last_error())
        return pmc.WorkingSetSize / 1048576
    # macOS: task_info で「いまの」常駐量を取る（ru_maxrss は最大値なので減らない）
    try:
        import ctypes
        import ctypes.util
        libc = ctypes.CDLL(ctypes.util.find_library("c"))

        class TaskBasicInfo(ctypes.Structure):
            _fields_ = [("virtual_size", ctypes.c_uint64), ("resident_size", ctypes.c_uint64),
                        ("resident_size_max", ctypes.c_uint64), ("user_time", ctypes.c_uint64),
                        ("system_time", ctypes.c_uint64), ("policy", ctypes.c_int),
                        ("suspend_count", ctypes.c_int)]
        MACH_TASK_BASIC_INFO = 20
        info = TaskBasicInfo()
        count = ctypes.c_uint(ctypes.sizeof(info) // 4)
        libc.mach_task_self.restype = ctypes.c_uint
        r = libc.task_info(libc.mach_task_self(), MACH_TASK_BASIC_INFO, ctypes.byref(info), ctypes.byref(count))
        if r == 0:
            return info.resident_size / 1048576
    except Exception:
        pass
    import resource
    return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1048576


def setup_render(args):
    sc = bpy.context.scene
    sc.render.resolution_x = args.res
    sc.render.resolution_y = args.res
    sc.render.resolution_percentage = 100
    sc.render.image_settings.file_format = "PNG"
    if args.render == "workbench":
        sc.render.engine = "BLENDER_WORKBENCH"
        sc.display.shading.color_type = "MATERIAL"
    elif args.render == "eevee":
        sc.render.engine = "BLENDER_EEVEE"
        sc.eevee.taa_render_samples = args.samples
    elif args.render == "cycles":
        sc.render.engine = "CYCLES"
        sc.cycles.samples = args.samples
        sc.cycles.use_denoising = True
        try:
            prefs = bpy.context.preferences.addons["cycles"].preferences
            for t in ("OPTIX", "CUDA", "METAL", "HIP"):
                try:
                    prefs.compute_device_type = t
                    break
                except TypeError:
                    continue
            prefs.get_devices()
            for d in prefs.devices:
                d.use = d.type != "CPU"
            sc.cycles.device = "GPU"
        except Exception:
            traceback.print_exc()


def ensure_camera_light():
    sc = bpy.context.scene
    if sc.camera is None or sc.camera.name not in bpy.data.objects:
        cam = bpy.data.objects.new("cam", bpy.data.cameras.new("cam"))
        sc.collection.objects.link(cam)
        cam.location = (9, -9, 7)
        cam.rotation_euler = (math.radians(65), 0, math.radians(45))
        cam.data.clip_end = 1000
        sc.camera = cam
    if "sun" not in bpy.data.objects:
        sun = bpy.data.objects.new("sun", bpy.data.lights.new("sun", "SUN"))
        sun.data.energy = 3
        sun.rotation_euler = (math.radians(40), 0, math.radians(30))
        sc.collection.objects.link(sun)


def frame_object(obj):
    """カメラを、いま作った1個がちょうど収まる位置へ動かす（サムネイル用）"""
    from mathutils import Vector
    sc = bpy.context.scene
    bpy.context.view_layer.update()
    pts = [obj.matrix_world @ Vector(c) for c in obj.bound_box]
    center = sum(pts, Vector()) / 8
    size = max((max(p[k] for p in pts) - min(p[k] for p in pts)) for k in range(3))
    d = Vector((1.0, -1.0, 0.75)).normalized()
    cam = sc.camera
    cam.location = center + d * size * 2.4
    cam.rotation_euler = (-d).to_track_quat("-Z", "Y").to_euler()
    if sc.world is None:
        sc.world = bpy.data.worlds.new("world")
    sc.world.color = (0.18, 0.2, 0.24)
    if sc.world.use_nodes and "Background" in sc.world.node_tree.nodes:
        sc.world.node_tree.nodes["Background"].inputs["Color"].default_value = (0.18, 0.2, 0.24, 1)


# ------------------------------------------------------------------ 本体

def args():
    import argparse
    a = sys.argv[sys.argv.index("--") + 1:] if "--" in sys.argv else []
    p = argparse.ArgumentParser()
    p.add_argument("--src", required=True)
    p.add_argument("--n", type=int, default=100)
    p.add_argument("--start", type=int, default=0)
    p.add_argument("--cleanup", default="purge", choices=["none", "objects", "purge", "reset"])
    p.add_argument("--name-from", default="object", choices=["object", "source"])
    p.add_argument("--render", default="none", choices=["none", "workbench", "eevee", "cycles"])
    p.add_argument("--res", type=int, default=256)
    p.add_argument("--samples", type=int, default=16)
    p.add_argument("--out", required=True)
    p.add_argument("--tag", default="")
    p.add_argument("--naive", action="store_true",
                   help="try/except も sys.exit も書かない、素朴な書き方（失敗したらそこでループが止まる）")
    return p.parse_args(a)


def main():
    a = args()
    src = os.path.abspath(a.src)
    out = os.path.abspath(a.out)
    items = os.path.join(out, "items")
    os.makedirs(items, exist_ok=True)
    files = sorted(f for f in os.listdir(src) if f.endswith(".glb"))[a.start: a.start + a.n]

    bpy.ops.wm.read_factory_settings(use_empty=True)
    print(f"[p998] convert blender {bpy.app.version_string} platform={sys.platform} "
          f"cleanup={a.cleanup} name_from={a.name_from} render={a.render} files={len(files)}")

    log_path = os.path.join(out, f"log_{a.start:03d}.csv" if a.start or a.n < 100 else "log.csv")
    f = open(log_path, "w", newline="", encoding="utf-8")
    w = csv.writer(f)
    w.writerow(["tag", "i", "src", "ok", "sec_import", "sec_edit", "sec_export", "sec_render", "sec_total",
                "rss_mb", "n_objects", "n_meshes", "n_materials", "n_images", "obj_name", "mesh_name",
                "out_file", "overwrote", "error"])
    written = set()
    fails = 0
    t_all = time.perf_counter()
    for i, name in enumerate(files, start=a.start):
        t0 = time.perf_counter()
        r = dict(ok=0, sec_import="", sec_edit="", sec_export="", sec_render="", obj_name="", mesh_name="",
                 out_file="", overwrote="", error="")
        try:
            if a.render != "none":
                if i == a.start or a.cleanup == "reset":
                    setup_render(a)
                ensure_camera_light()
            before = set(bpy.data.objects)
            bpy.ops.import_scene.gltf(filepath=os.path.join(src, name))
            new = [o for o in bpy.data.objects if o not in before and o.type == "MESH"]
            obj = new[0]
            r["obj_name"], r["mesh_name"] = obj.name, obj.data.name
            t1 = time.perf_counter()

            # 手を加える: 面を半分に減らす（Decimate を適用）
            m = obj.modifiers.new("dec", "DECIMATE")
            m.ratio = 0.5
            bpy.context.view_layer.objects.active = obj
            bpy.ops.object.select_all(action="DESELECT")
            obj.select_set(True)
            bpy.ops.object.modifier_apply(modifier="dec")
            t2 = time.perf_counter()

            stem = obj.name if a.name_from == "object" else os.path.splitext(name)[0].replace("src_", "out_")
            outp = os.path.join(items, stem + ".glb")
            r["overwrote"] = int(outp in written)
            written.add(outp)
            bpy.ops.export_scene.gltf(filepath=outp, export_format="GLB", use_selection=True)
            r["out_file"] = os.path.basename(outp)
            t3 = time.perf_counter()

            if a.render != "none":
                for o in bpy.context.scene.objects:
                    if o.type == "MESH":
                        o.hide_render = (o is not obj)
                frame_object(obj)
                bpy.context.scene.render.filepath = os.path.join(items, stem + ".png")
                bpy.ops.render.render(write_still=True)
            t4 = time.perf_counter()
            r.update(ok=1, sec_import=round(t1 - t0, 4), sec_edit=round(t2 - t1, 4),
                     sec_export=round(t3 - t2, 4), sec_render=round(t4 - t3, 4))

            if a.cleanup in ("objects", "purge"):
                for o in new:
                    bpy.data.objects.remove(o, do_unlink=True)
            if a.cleanup == "purge":
                bpy.data.orphans_purge(do_recursive=True)
            if a.cleanup == "reset":
                bpy.ops.wm.read_factory_settings(use_empty=True)
        except Exception as e:
            if a.naive:
                f.close()
                raise
            fails += 1
            r["error"] = f"{type(e).__name__}: {e}".replace("\n", " ")[:300]
            traceback.print_exc()
        w.writerow([a.tag, i, name, r["ok"], r["sec_import"], r["sec_edit"], r["sec_export"], r["sec_render"],
                    round(time.perf_counter() - t0, 4), round(rss_mb(), 1), len(bpy.data.objects),
                    len(bpy.data.meshes), len(bpy.data.materials), len(bpy.data.images),
                    r["obj_name"], r["mesh_name"], r["out_file"], r["overwrote"], r["error"]])
        f.flush()
    f.close()
    n_out = len([x for x in os.listdir(items) if x.endswith(".glb")])
    print(f"[p998] done files={len(files)} fails={fails} out_glb={n_out} sec={time.perf_counter() - t_all:.2f}")
    if not a.naive:
        # ★これを書かないと、1個失敗しても終了コードは0（成功）のまま
        sys.exit(1 if fails else 0)


if __name__ == "__main__":
    main()

# -*- coding: utf-8 -*-
"""
p998 実験5: 16個の操作を1つずつ試し、動いたかどうかを CSV に残す。Blenderの中で動く。

  画面なし          : blender -b --factory-startup --python probe_ops.py -- --out out/probe_bg.csv
  画面あり・すぐ実行 : blender --factory-startup --python probe_ops.py -- --out out/probe_gui.csv --quit
  画面あり・待って実行: blender --factory-startup --python probe_ops.py -- --out out/probe_defer.csv --defer --quit
  （画面ありの2つは、Blenderのウィンドウが一瞬開いて自動で閉じる）
"""
import bpy
import csv
import os
import sys
import tempfile
import traceback


def args():
    a = sys.argv[sys.argv.index("--") + 1:] if "--" in sys.argv else []
    out = a[a.index("--out") + 1] if "--out" in a else "probe.csv"
    return os.path.abspath(out), ("--quit" in a), ("--defer" in a)


TMP = tempfile.mkdtemp(prefix="p998_")


def fresh():
    bpy.ops.wm.read_factory_settings(use_empty=False)   # 既定の立方体・カメラ・ライトがある状態


def c_active():
    o = bpy.context.active_object
    return f"active={o.name if o else None} / selected={len(bpy.context.selected_objects)}"


def c_add_cube():
    bpy.ops.mesh.primitive_cube_add(location=(3, 0, 0))
    return f"added {bpy.context.object.name}"


def c_modifier_apply():
    o = bpy.data.objects["Cube"]
    m = o.modifiers.new("sub", "SUBSURF")
    m.levels = 2
    bpy.context.view_layer.objects.active = o
    bpy.ops.object.modifier_apply(modifier="sub")
    return f"verts={len(o.data.vertices)}"


def c_editmode_subdivide():
    o = bpy.data.objects["Cube"]
    bpy.context.view_layer.objects.active = o
    bpy.ops.object.mode_set(mode="EDIT")
    bpy.ops.mesh.select_all(action="SELECT")
    bpy.ops.mesh.subdivide(number_cuts=2)
    bpy.ops.object.mode_set(mode="OBJECT")
    return f"verts={len(o.data.vertices)}"


def c_render_still():
    sc = bpy.context.scene
    sc.render.engine = "BLENDER_WORKBENCH"
    sc.render.resolution_x = sc.render.resolution_y = 64
    sc.render.filepath = os.path.join(TMP, "still.png")
    bpy.ops.render.render(write_still=True)
    return f"exists={os.path.exists(sc.render.filepath)}"


def c_render_opengl():
    sc = bpy.context.scene
    sc.render.resolution_x = sc.render.resolution_y = 64
    sc.render.filepath = os.path.join(TMP, "gl.png")
    bpy.ops.render.opengl(write_still=True)
    return f"exists={os.path.exists(sc.render.filepath)}"


def c_view3d_frame():
    bpy.ops.view3d.view_all()
    return "ok"


def c_view3d_override():
    win = bpy.context.window_manager.windows[0] if bpy.context.window_manager.windows else None
    if win is None:
        raise RuntimeError("window が1つも無い")
    area = next(a for a in win.screen.areas if a.type == "VIEW_3D")
    with bpy.context.temp_override(window=win, area=area):
        bpy.ops.view3d.view_all()
    return "ok(temp_override)"


def c_screenshot():
    p = os.path.join(TMP, "shot.png")
    bpy.ops.screen.screenshot(filepath=p)
    return f"exists={os.path.exists(p)}"


def c_save_as():
    p = os.path.join(TMP, "saved.blend")
    bpy.ops.wm.save_as_mainfile(filepath=p)
    return f"exists={os.path.exists(p)} / bpy.data.filepath={bpy.data.filepath}"


def c_relpath_unsaved():
    return f"abspath('//x.png')={bpy.path.abspath('//x.png')!r}"


def c_gltf_export():
    p = os.path.join(TMP, "a.glb")
    bpy.ops.export_scene.gltf(filepath=p, export_format="GLB")
    return f"bytes={os.path.getsize(p)}"


def c_fbx_export():
    p = os.path.join(TMP, "a.fbx")
    bpy.ops.export_scene.fbx(filepath=p)
    return f"bytes={os.path.getsize(p)}"


def c_undo():
    bpy.ops.ed.undo()
    return "ok"


def c_windows():
    wm = bpy.context.window_manager
    return f"windows={len(wm.windows)} / screen={bpy.context.screen}"


CASES = [
    ("状態: ウィンドウの数", c_windows),
    ("状態: アクティブ／選択", c_active),
    ("追加: primitive_cube_add", c_add_cube),
    ("モディファイア適用", c_modifier_apply),
    ("編集モードで細分化", c_editmode_subdivide),
    ("レンダリング: render.render", c_render_still),
    ("ビューポート撮影: render.opengl", c_render_opengl),
    ("3Dビュー操作: view3d.view_all", c_view3d_frame),
    ("3Dビュー操作（areaだけ渡す）", c_view3d_override),
    ("画面のスクショ: screen.screenshot", c_screenshot),
    ("未保存での // パス", c_relpath_unsaved),
    ("保存: save_as_mainfile", c_save_as),
    ("保存後の // パス", c_relpath_unsaved),
    ("書き出し: glTF", c_gltf_export),
    ("書き出し: FBX", c_fbx_export),
    ("元に戻す: ed.undo", c_undo),
]


def run(out, quit_after, mode):
    os.makedirs(os.path.dirname(out), exist_ok=True)
    rows = []
    if mode == "immediate":
        fresh()
    ctx = {}
    if mode == "defer":
        # ★タイマーの中では context に window が入っていない。3Dビューの区画を探して明示的に渡す
        win = bpy.context.window_manager.windows[0]
        area = next(a for a in win.screen.areas if a.type == "VIEW_3D")
        region = next(r for r in area.regions if r.type == "WINDOW")
        ctx = dict(window=win, screen=win.screen, area=area, region=region)
    for name, fn in CASES:
        try:
            if ctx:
                with bpy.context.temp_override(**ctx):
                    msg = fn()
            else:
                msg = fn()
            rows.append([name, 1, msg.replace("\n", " ")])
        except Exception as e:
            rows.append([name, 0, f"{type(e).__name__}: {str(e).strip()}".replace("\n", " ")[:300]])
        print(f"[probe] {rows[-1][1]} {name} :: {rows[-1][2]}")
    with open(out, "w", newline="", encoding="utf-8") as f:
        w = csv.writer(f)
        w.writerow(["case", "ok", "detail"])
        w.writerows(rows)
    print(f"[probe] background={bpy.app.background} mode={mode} version={bpy.app.version_string} -> {out}")
    if quit_after:
        # ★起動直後(--python の中)では quit_blender の poll も通らないので、os._exit で確実に終える
        sys.stdout.flush()
        os._exit(0)


def main():
    out, quit_after, defer = args()
    if defer and not bpy.app.background:
        # ★画面が出来上がってから実行する（--python の時点ではウィンドウもスクリーンもまだ無い）
        def later():
            run(out, quit_after, "defer")
            return None
        bpy.app.timers.register(later, first_interval=2.0)
    else:
        run(out, quit_after, "immediate")


if __name__ == "__main__":
    main()

# p998 実験2: わざと例外で落ちるだけのスクリプト
#   blender -b --factory-startup --python err.py
import bpy
print("before error")
raise RuntimeError("わざと落とす")

# -*- coding: utf-8 -*-
r"""
p998: 実験0〜6をまとめて回す。★Blenderの外で、ふつうの Python 3 で動かす（標準ライブラリだけ）。
make_sources.py / convert.py / probe_ops.py / err.py と同じフォルダに置いて実行する。

  Mac    : python3 runner.py --blender /Applications/Blender.app/Contents/MacOS/Blender
  Windows: python runner.py --blender "C:\Program Files\Blender Foundation\Blender 5.2\blender.exe"

  --only e1,e2    一部の実験だけ回す（既定は all）
  --quick         回数と個数を減らした短縮版（実験4はWorkbenchで6個だけ）
  --no-gui        画面ありの実験（実験5の2つ）を飛ばす

実験:
  e0 環境の申告               → out/env.txt
  e1 起動にかかる時間          → out/e1_startup.csv
  e2 失敗したときの終了コード   → out/e2_exitcode.csv
  e3 後片付けと名前（100個）   → out/e3_summary.csv（1個ごとは out/e3/*/log.csv）
  e4 1プロセス/1個ずつ/並列    → out/e4_strategy.csv（レンダリングあり）
  e5 画面なしで動かない操作     → out/e5_probe_*.csv
  e6 パス（// と日本語フォルダ） → out/e6_paths.csv

★Blenderの設定置き場は、このフォルダの blender_home/ に隔離する（普段の設定を汚さない）。
★どの実験も、失敗しても止めずに次へ進む。結果には必ず終了コードか ok 列を残す。
"""
import argparse
import csv
import os
import platform
import shutil
import subprocess
import sys
import time

HERE = os.path.dirname(os.path.abspath(__file__))
OUT = os.path.join(HERE, "out")

# Windowsの cp932 で print が落ちないように
try:
    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
except Exception:
    pass


def log(msg):
    print(f"[runner] {time.strftime('%H:%M:%S')} {msg}", flush=True)


def run(cmd, logfile=None, cwd=None, env=None, timeout=3600):
    """コマンドを実行し、(終了コード, 秒, 出力) を返す。出力は utf-8 で読む（cp932で読まない）"""
    t0 = time.perf_counter()
    try:
        p = subprocess.run(cmd, cwd=cwd or HERE, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
                           timeout=timeout)
        rc = p.returncode
        text = p.stdout.decode("utf-8", errors="replace")
    except subprocess.TimeoutExpired as e:
        rc = "timeout"
        text = (e.stdout or b"").decode("utf-8", errors="replace")
    sec = time.perf_counter() - t0
    if logfile:
        os.makedirs(os.path.dirname(logfile), exist_ok=True)
        with open(logfile, "w", encoding="utf-8") as f:
            f.write(" ".join(f'"{c}"' if " " in c else c for c in cmd) + "\n\n" + text)
    return rc, sec, text


def user_env(isolated_home):
    """★eightの普段のBlender設定を汚さないよう、設定置き場を隔離する（消せば元通り）"""
    env = dict(os.environ)
    if isolated_home:
        env["BLENDER_USER_RESOURCES"] = isolated_home
    env["PYTHONUTF8"] = "1"
    return env


def write_csv(path, header, rows):
    os.makedirs(os.path.dirname(path), exist_ok=True)
    with open(path, "w", newline="", encoding="utf-8") as f:
        w = csv.writer(f)
        w.writerow(header)
        w.writerows(rows)


# ------------------------------------------------------------------ e0

def e0(B, env):
    lines = [f"platform: {platform.platform()}", f"machine: {platform.machine()}",
             f"python: {sys.version.split()[0]}", f"cpu_count: {os.cpu_count()}", f"blender_path: {B}"]
    rc, sec, txt = run([B, "-b", "--factory-startup", "--python-expr",
                        "import bpy,sys;print('BLVER',bpy.app.version_string);print('BLHASH',bpy.app.build_hash.decode())"],
                       env=env, timeout=300)
    for ln in txt.splitlines():
        if ln.startswith(("BLVER", "BLHASH")):
            lines.append(ln)
    if shutil.which("nvidia-smi"):
        _, _, g = run(["nvidia-smi", "--query-gpu=name,driver_version,memory.total", "--format=csv,noheader"],
                      timeout=60)
        lines.append("gpu(nvidia-smi): " + g.strip())
    if sys.platform == "darwin":
        _, _, g = run(["sysctl", "-n", "machdep.cpu.brand_string", "hw.memsize"], timeout=30)
        lines.append("cpu/mem: " + " / ".join(g.split()))
    # 空き容量
    du = shutil.disk_usage(HERE)
    lines.append(f"disk_free_GB: {du.free / 1e9:.1f}")
    os.makedirs(OUT, exist_ok=True)
    with open(os.path.join(OUT, "env.txt"), "w", encoding="utf-8") as f:
        f.write("\n".join(lines) + "\n")
    log("e0 " + " | ".join(lines))


# ------------------------------------------------------------------ e1 起動時間

def e1(B, env_iso, env_user, reps):
    rows = []
    cases = [
        ("factory", [B, "-b", "--factory-startup", "--python-expr", "pass"], env_iso),
        ("user_prefs", [B, "-b", "--python-expr", "pass"], env_user),
        ("factory_import_bpy_ops", [B, "-b", "--factory-startup", "--python-expr",
                                    "import bpy; bpy.ops.mesh.primitive_cube_add()"], env_iso),
    ]
    for name, cmd, env in cases:
        for k in range(reps + 1):
            rc, sec, _ = run(cmd, env=env, timeout=600,
                             logfile=os.path.join(OUT, "logs", f"e1_{name}_{k}.txt"))
            rows.append([name, k, "warmup" if k == 0 else "", rc, round(sec, 3)])
            log(f"e1 {name} #{k} rc={rc} {sec:.2f}s")
    write_csv(os.path.join(OUT, "e1_startup.csv"), ["case", "rep", "note", "exit", "sec"], rows)


# ------------------------------------------------------------------ e2 終了コード

def e2(B, env):
    rows = []
    cases = [
        ("script_raises_default", [B, "-b", "--factory-startup", "--python", "err.py"]),
        ("script_raises_exitcode1", [B, "-b", "--factory-startup", "--python-exit-code", "1", "--python", "err.py"]),
        ("expr_raises_default", [B, "-b", "--factory-startup", "--python-expr", "1/0"]),
        ("expr_raises_exitcode1", [B, "-b", "--factory-startup", "--python-exit-code", "1", "--python-expr", "1/0"]),
        ("missing_script_default", [B, "-b", "--factory-startup", "--python", "no_such_file.py"]),
        ("missing_script_exitcode1", [B, "-b", "--factory-startup", "--python-exit-code", "1",
                                      "--python", "no_such_file.py"]),
        ("missing_blend_default", [B, "-b", "no_such_file.blend", "--python-expr", "pass"]),
        ("script_sys_exit_3", [B, "-b", "--factory-startup", "--python-expr", "import sys; sys.exit(3)"]),
    ]
    for name, cmd in cases:
        rc, sec, txt = run(cmd, env=env, timeout=300, logfile=os.path.join(OUT, "logs", f"e2_{name}.txt"))
        tb = int("Traceback" in txt or "Error" in txt)
        rows.append([name, rc, tb, round(sec, 3)])
        log(f"e2 {name} rc={rc} error_in_log={tb}")

    # 100個のうち1個だけ壊れているとき（★壊れた1個は ok=0 で残り、プロセスの終了コードは1）
    src = os.path.join(OUT, "src")
    broken = os.path.join(OUT, "src_broken")
    if os.path.isdir(src):
        shutil.rmtree(broken, ignore_errors=True)
        shutil.copytree(src, broken)
        with open(os.path.join(broken, "src_037.glb"), "wb") as f:
            f.write(b"this is not a glb file")
        for name, extra in (("naive_one_broken_default", ["--naive"]),
                            ("naive_one_broken_exitcode1", ["--naive"]),
                            ("careful_one_broken_default", []),
                            ("careful_one_broken_exitcode1", [])):
            o = os.path.join(OUT, "e2_" + name)
            shutil.rmtree(o, ignore_errors=True)
            ec = ["--python-exit-code", "1"] if name.endswith("exitcode1") else []
            cmd = [B, "-b", "--factory-startup", *ec, "--python", "convert.py", "--",
                   "--src", broken, "--cleanup", "purge", "--name-from", "source", "--out", o, "--tag", name, *extra]
            rc, sec, txt = run(cmd, env=env, timeout=1800, logfile=os.path.join(OUT, "logs", f"e2_{name}.txt"))
            n_out = len([x for x in os.listdir(os.path.join(o, "items")) if x.endswith(".glb")]) \
                if os.path.isdir(os.path.join(o, "items")) else 0
            rows.append([name, rc, int("Traceback" in txt), round(sec, 3), n_out])
            log(f"e2 {name} rc={rc} out_glb={n_out}")
    write_csv(os.path.join(OUT, "e2_exitcode.csv"), ["case", "exit", "error_in_log", "sec", "out_glb"], rows)


# ------------------------------------------------------------------ 材料

def make_src(B, env, tex, name):
    d = os.path.join(OUT, name)
    if os.path.isdir(d) and len([x for x in os.listdir(d) if x.endswith(".glb")]) >= 100:
        return d
    rc, sec, _ = run([B, "-b", "--factory-startup", "--python", "make_sources.py", "--",
                      "--n", "100", "--tex", str(tex), "--out", d], env=env, timeout=3600,
                     logfile=os.path.join(OUT, "logs", f"make_{name}.txt"))
    log(f"sources {name} tex={tex} rc={rc} {sec:.1f}s")
    return d


# ------------------------------------------------------------------ e3 後片付け

def e3(B, env, src_dirs):
    rows = []
    for src_name, src in src_dirs:
        for cl in ("none", "objects", "purge", "reset"):
            for nf in ("object", "source"):
                tag = f"{src_name}_{cl}_{nf}"
                o = os.path.join(OUT, "e3", tag)
                shutil.rmtree(o, ignore_errors=True)
                cmd = [B, "-b", "--factory-startup", "--python-exit-code", "1", "--python", "convert.py", "--",
                       "--src", src, "--cleanup", cl, "--name-from", nf, "--out", o, "--tag", tag]
                rc, sec, _ = run(cmd, env=env, timeout=3600, logfile=os.path.join(OUT, "logs", f"e3_{tag}.txt"))
                lg = list(csv.DictReader(open(os.path.join(o, "log.csv"), encoding="utf-8")))
                n_out = len([x for x in os.listdir(os.path.join(o, "items")) if x.endswith(".glb")])
                ok = sum(int(r["ok"]) for r in lg)
                rss0, rss1 = float(lg[0]["rss_mb"]), float(lg[-1]["rss_mb"])
                rss_max = max(float(r["rss_mb"]) for r in lg)
                rows.append([src_name, cl, nf, rc, round(sec, 2), ok, n_out,
                             sum(int(r["overwrote"] or 0) for r in lg), rss0, rss1, rss_max,
                             lg[-1]["n_meshes"], lg[-1]["n_images"], lg[1]["obj_name"], lg[-1]["obj_name"]])
                log(f"e3 {tag} rc={rc} ok={ok} out={n_out} rss {rss0}->{rss1} {sec:.1f}s")
    write_csv(os.path.join(OUT, "e3_summary.csv"),
              ["src", "cleanup", "name_from", "exit", "sec_wall", "ok", "out_glb", "overwrote",
               "rss_first", "rss_last", "rss_max", "meshes_left", "images_left", "name_2nd", "name_last"], rows)


# ------------------------------------------------------------------ e4 回し方

def e4(B, env, src, engines, parallels, n):
    rows = []

    def conv(tag, start, count, engine, o):
        return [B, "-b", "--factory-startup", "--python-exit-code", "1", "--python", "convert.py", "--",
                "--src", src, "--n", str(count), "--start", str(start), "--cleanup", "purge",
                "--name-from", "source", "--render", engine, "--res", "256", "--samples", "16",
                "--out", o, "--tag", tag]

    for engine in engines:
        # ★ウォームアップ（p976の教訓：そのマシンで最初にシェーダを要求した処理だけ15秒余計にかかる）
        o = os.path.join(OUT, "e4", f"warmup_{engine}")
        shutil.rmtree(o, ignore_errors=True)
        rc, sec, _ = run(conv("warmup", 0, 1, engine, o), env=env,
                         logfile=os.path.join(OUT, "logs", f"e4_warmup_{engine}.txt"))
        rows.append([engine, "warmup", 1, 1, rc, round(sec, 2), ""])
        log(f"e4 {engine} warmup rc={rc} {sec:.1f}s")

        # (a) 1プロセスで n 個
        o = os.path.join(OUT, "e4", f"{engine}_single")
        shutil.rmtree(o, ignore_errors=True)
        rc, sec, _ = run(conv("single", 0, n, engine, o), env=env,
                         logfile=os.path.join(OUT, "logs", f"e4_{engine}_single.txt"))
        rows.append([engine, "single", 1, n, rc, round(sec, 2), count_png(o)])
        log(f"e4 {engine} single rc={rc} {sec:.1f}s")

        # (b) 1個ずつ起動し直す
        o = os.path.join(OUT, "e4", f"{engine}_per_item")
        shutil.rmtree(o, ignore_errors=True)
        t0 = time.perf_counter()
        bad = 0
        for i in range(n):
            rc, _, _ = run(conv("per_item", i, 1, engine, o), env=env,
                           logfile=os.path.join(OUT, "logs", f"e4_{engine}_per_item_{i:03d}.txt"))
            bad += int(rc != 0)
        sec = time.perf_counter() - t0
        rows.append([engine, "per_item", n, n, f"fails={bad}", round(sec, 2), count_png(o)])
        log(f"e4 {engine} per_item fails={bad} {sec:.1f}s")

        # (c) 並列 k 本（n を k 等分）
        for k in parallels:
            o = os.path.join(OUT, "e4", f"{engine}_par{k}")
            shutil.rmtree(o, ignore_errors=True)
            os.makedirs(o, exist_ok=True)
            per = (n + k - 1) // k
            t0 = time.perf_counter()
            procs = []
            for j in range(k):
                start = j * per
                cnt = min(per, n - start)
                if cnt <= 0:
                    continue
                lf = open(os.path.join(OUT, "logs", f"e4_{engine}_par{k}_{j}.txt"), "wb")
                procs.append((subprocess.Popen(conv(f"par{k}", start, cnt, engine, o), cwd=HERE, env=env,
                                               stdout=lf, stderr=subprocess.STDOUT), lf))
            codes = []
            for p, lf in procs:
                codes.append(p.wait())
                lf.close()
            sec = time.perf_counter() - t0
            rows.append([engine, f"par{k}", k, n, "/".join(map(str, codes)), round(sec, 2), count_png(o)])
            log(f"e4 {engine} par{k} codes={codes} {sec:.1f}s")
    write_csv(os.path.join(OUT, "e4_strategy.csv"),
              ["engine", "strategy", "processes", "items", "exit", "sec_wall", "png_written"], rows)


def count_png(o):
    d = os.path.join(o, "items")
    return len([x for x in os.listdir(d) if x.endswith(".png")]) if os.path.isdir(d) else 0


# ------------------------------------------------------------------ e5 画面なしで動かない操作

def e5(B, env, gui):
    run([B, "-b", "--factory-startup", "--python", "probe_ops.py", "--", "--out",
         os.path.join(OUT, "e5_probe_background.csv")], env=env, timeout=600,
        logfile=os.path.join(OUT, "logs", "e5_background.txt"))
    log("e5 background done")
    if gui:
        # ★画面が一瞬開いて閉じる（2回）
        run([B, "--factory-startup", "--python", "probe_ops.py", "--", "--out",
             os.path.join(OUT, "e5_probe_gui_immediate.csv"), "--quit"], env=env, timeout=300,
            logfile=os.path.join(OUT, "logs", "e5_gui_immediate.txt"))
        run([B, "--factory-startup", "--python", "probe_ops.py", "--", "--out",
             os.path.join(OUT, "e5_probe_gui_defer.csv"), "--defer", "--quit"], env=env, timeout=300,
            logfile=os.path.join(OUT, "logs", "e5_gui_defer.txt"))
        log("e5 gui done")


# ------------------------------------------------------------------ e6 パス

def e6(B, env):
    rows = []
    base = os.path.join(OUT, "e6")
    shutil.rmtree(base, ignore_errors=True)
    os.makedirs(base, exist_ok=True)

    # (1) 保存していないシーンで // を使うと、どこに書かれるか（カレントディレクトリを変えて2回）
    expr = ("import bpy,os;sc=bpy.context.scene;sc.render.engine='BLENDER_WORKBENCH';"
            "sc.render.resolution_x=sc.render.resolution_y=32;sc.render.filepath='//unsaved_out.png';"
            "print('CWD',os.getcwd());print('ABS',bpy.path.abspath(sc.render.filepath));"
            "bpy.ops.render.render(write_still=True)")
    for label, cwd in (("cwd_here", HERE), ("cwd_base", base)):
        rc, sec, txt = run([B, "-b", "--factory-startup", "--python-expr", expr], cwd=cwd, env=env, timeout=300,
                           logfile=os.path.join(OUT, "logs", f"e6_unsaved_{label}.txt"))
        ab = next((ln[4:] for ln in txt.splitlines() if ln.startswith("ABS ")), "")
        err = next((ln.strip() for ln in txt.splitlines() if "cannot save" in ln), "")
        rows.append(["unsaved_//", label, rc, f"abspath={ab} / {err}",
                     os.path.exists(os.path.join(cwd, "unsaved_out.png"))])
        log(f"e6 unsaved // {label} -> {ab}")

    # (2) .blend を保存してから -o //frames/f_#### -f 1
    blend = os.path.join(base, "scene.blend")
    run([B, "-b", "--factory-startup", "--python-expr",
         f"import bpy;sc=bpy.context.scene;sc.render.engine='BLENDER_WORKBENCH';"
         f"sc.render.resolution_x=sc.render.resolution_y=32;bpy.ops.wm.save_as_mainfile(filepath=r'{blend}')"],
        env=env, timeout=300)
    rc, sec, txt = run([B, "-b", blend, "-o", "//frames/f_####", "-F", "PNG", "-f", "1"], cwd=HERE, env=env,
                       timeout=300, logfile=os.path.join(OUT, "logs", "e6_saved_o.txt"))
    rows.append(["saved_-o_//", "", rc, os.path.join(base, "frames", "f_0001.png"),
                 os.path.exists(os.path.join(base, "frames", "f_0001.png"))])
    # ★引数の順番: -o を -f の後ろに書くと効かない（引数は左から順に実行される）
    rc, sec, txt = run([B, "-b", blend, "-f", "1", "-o", "//late/f_####"], cwd=HERE, env=env,
                       timeout=300, logfile=os.path.join(OUT, "logs", "e6_order.txt"))
    written = [ln for ln in txt.splitlines() if "Saved:" in ln]
    rows.append(["-f_before_-o", "", rc, written[0].strip() if written else "",
                 os.path.exists(os.path.join(base, "late", "f_0001.png"))])
    log(f"e6 -f before -o -> {written[:1]}")

    # (3) 日本語を含むフォルダで変換を回す
    jp = os.path.join(base, "作業フォルダ_日本語")
    src = os.path.join(OUT, "src")
    if os.path.isdir(src):
        jsrc = os.path.join(jp, "元データ")
        shutil.copytree(src, jsrc)
        o = os.path.join(jp, "出力")
        rc, sec, txt = run([B, "-b", "--factory-startup", "--python-exit-code", "1", "--python", "convert.py", "--",
                            "--src", jsrc, "--n", "10", "--cleanup", "purge", "--name-from", "source",
                            "--out", o, "--tag", "jp"], env=env, timeout=1800,
                           logfile=os.path.join(OUT, "logs", "e6_japanese.txt"))
        n = len([x for x in os.listdir(os.path.join(o, "items"))]) if os.path.isdir(os.path.join(o, "items")) else 0
        rows.append(["japanese_dir", "", rc, o, n])
        log(f"e6 japanese dir rc={rc} files={n}")
    write_csv(os.path.join(OUT, "e6_paths.csv"), ["case", "variant", "exit", "path", "result"], rows)


# ------------------------------------------------------------------ main

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--blender", required=True)
    ap.add_argument("--only", default="all")
    ap.add_argument("--quick", action="store_true", help="Macでの動作確認用（回数・個数を減らす）")
    ap.add_argument("--no-gui", action="store_true")
    a = ap.parse_args()
    B = a.blender
    if not os.path.exists(B):
        log(f"[STOP] blender not found: {B}")
        sys.exit(2)
    only = set("e0,e1,e2,e3,e4,e5,e6".split(",")) if a.only == "all" else set(a.only.split(","))
    os.makedirs(os.path.join(OUT, "logs"), exist_ok=True)
    iso = os.path.join(HERE, "blender_home")
    env_iso = user_env(iso)
    env_user = user_env(None)

    if "e0" in only:
        e0(B, env_iso)
    if "e1" in only:
        e1(B, env_iso, env_user, reps=2 if a.quick else 5)
    src = make_src(B, env_iso, 512, "src")
    if "e2" in only:
        e2(B, env_iso)
    if "e3" in only:
        srcs = [("tex512", src)]
        if not a.quick:
            srcs.append(("tex2048", make_src(B, env_iso, 2048, "src2k")))
        e3(B, env_iso, srcs)
    if "e4" in only:
        if a.quick:
            e4(B, env_iso, src, ["workbench"], [2], 6)
        else:
            e4(B, env_iso, src, ["eevee", "cycles"], [2, 4], 100)
    if "e5" in only:
        e5(B, env_iso, gui=not a.no_gui)
    if "e6" in only:
        e6(B, env_iso)
    log("ALL DONE")


if __name__ == "__main__":
    main()