Checkpoint web parity through Chromium input tasks

tools/web/generate-glb-web-reimport-report.py

@@ -0,0 +1,149 @@
+"""Re-import Web-produced GLBs in Blender 5.2 and emit canonical graph reports."""
+
+import hashlib
+import json
+import sys
+from pathlib import Path
+
+import bpy
+
+
+FIXTURE_IDS = ("pbr", "uv", "skin", "animation")
+
+
+def sha256_file(path):
+    digest = hashlib.sha256()
+    with open(path, "rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def rounded(value):
+    return round(float(value), 6)
+
+
+def graph_report():
+    objects = []
+    for obj in sorted(bpy.data.objects, key=lambda item: item.name):
+        objects.append({
+            "name": obj.name,
+            "type": obj.type,
+            "data": obj.data.name if obj.data is not None else None,
+            "parent": obj.parent.name if obj.parent is not None else None,
+            "children": sorted(child.name for child in obj.children),
+            "location": [rounded(value) for value in obj.location],
+        })
+    meshes = []
+    for mesh in sorted(bpy.data.meshes, key=lambda item: item.name):
+        mesh.calc_loop_triangles()
+        meshes.append({
+            "name": mesh.name,
+            "vertexCount": len(mesh.vertices),
+            "polygonCount": len(mesh.polygons),
+            "triangleCount": len(mesh.loop_triangles),
+            "uvLayers": sorted(layer.name for layer in mesh.uv_layers),
+            "materials": [material.name if material else None for material in mesh.materials],
+        })
+    materials = []
+    for material in sorted(bpy.data.materials, key=lambda item: item.name):
+        materials.append({
+            "name": material.name,
+            "nodeNames": sorted(node.name for node in material.node_tree.nodes) if material.node_tree else [],
+        })
+    images = []
+    for image in sorted(bpy.data.images, key=lambda item: item.name):
+        images.append({
+            "name": image.name,
+            "size": list(image.size),
+            "packed": image.packed_file is not None,
+            "mimeType": image.file_format,
+        })
+    armatures = []
+    for armature in sorted(bpy.data.armatures, key=lambda item: item.name):
+        armatures.append({
+            "name": armature.name,
+            "bones": [{"name": bone.name, "parent": bone.parent.name if bone.parent else None} for bone in sorted(armature.bones, key=lambda item: item.name)],
+        })
+    actions = []
+    action_stable_ids = []
+    for action in sorted(bpy.data.actions, key=lambda item: item.name):
+        fcurves = []
+        for layer in action.layers:
+            for strip in layer.strips:
+                for channelbag in strip.channelbags:
+                    fcurves.extend((curve.data_path, curve.array_index) for curve in channelbag.fcurves)
+        actions.append({
+            "name": action.name,
+            "frameRange": [rounded(action.frame_range[0]), rounded(action.frame_range[1])],
+            "fcurves": sorted(fcurves),
+        })
+        owners = sorted(object_.name for object_ in bpy.data.objects if object_.animation_data is not None and object_.animation_data.action == action)
+        action_stable_ids.extend("action:" + action.name + ":object:" + owner for owner in owners)
+        if not owners:
+            action_stable_ids.append("action:" + action.name)
+    return {
+        "objects": objects,
+        "meshes": meshes,
+        "materials": materials,
+        "images": images,
+        "armatures": armatures,
+        "actions": actions,
+        "stableIds": {
+            "objects": ["object:" + item["name"] for item in objects],
+            "meshes": ["mesh:" + item["name"] for item in meshes],
+            "materials": ["material:" + item["name"] for item in materials],
+            "images": ["image:" + item["name"] for item in images],
+            "armatures": ["armature:" + item["name"] for item in armatures],
+            "actions": sorted(action_stable_ids),
+        },
+    }
+
+
+def import_reopen(glb_path, blend_path):
+    bpy.ops.wm.read_factory_settings(use_empty=True)
+    result = bpy.ops.import_scene.gltf(filepath=str(glb_path))
+    if "FINISHED" not in result:
+        raise RuntimeError("Blender Web GLB import failed: %s" % (result,))
+    before = graph_report()
+    bpy.ops.wm.save_as_mainfile(filepath=str(blend_path), check_existing=False)
+    bpy.ops.wm.open_mainfile(filepath=str(blend_path), load_ui=False)
+    after = graph_report()
+    if before != after:
+        raise RuntimeError("desktop Web GLB save/reopen semantic drift: %s" % glb_path)
+    return after
+
+
+def main(glb_root, output_root, report_path):
+    glb_root = Path(glb_root).resolve()
+    output_root = Path(output_root).resolve()
+    report_path = Path(report_path).resolve()
+    output_root.mkdir(parents=True, exist_ok=True)
+    fixtures = []
+    for fixture_id in FIXTURE_IDS:
+        glb_path = glb_root / (fixture_id + ".glb")
+        blend_path = output_root / (fixture_id + ".blend")
+        fixtures.append({
+            "id": fixture_id,
+            "glb": {"file": glb_path.name, "byteLength": glb_path.stat().st_size, "sha256": sha256_file(glb_path)},
+            "graph": import_reopen(glb_path, blend_path),
+        })
+    report = {
+        "schemaVersion": 1,
+        "task": "M12-06E",
+        "operation": "DESKTOP_REIMPORT_WEB_GLB_CANONICAL_REPORT",
+        "blenderVersion": bpy.app.version_string,
+        "fixtureCount": len(fixtures),
+        "fixtures": fixtures,
+        "nextTask": "M12-06F",
+    }
+    report_path.parent.mkdir(parents=True, exist_ok=True)
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    print("glb-web-reimport-report-generated fixtures=%s next=%s" % (len(fixtures), report["nextTask"]))
+
+
+if __name__ == "__main__":
+    args = sys.argv[sys.argv.index("--") + 1 :] if "--" in sys.argv else []
+    if len(args) != 3:
+        raise SystemExit("usage: blender --background --python generate-glb-web-reimport-report.py -- GLB_ROOT OUTPUT_ROOT REPORT")
+    main(args[0], args[1], args[2])