"""Compare exporter preparation against a supplied original in real Blender. blender --background --factory-startup --python this_file.py -- \ --baseline /absolute/path/to/original_export_cesium.py The fixture combines asymmetric quads, n-gons, authored UVs, shared meshes, custom normals, shape keys and Bevel. A separate Boolean scenario exercises the dependency-bearing fallback. Expected triangle totals follow n - 2; attribute/ordering comparisons use the original exporter as an independent reference, including an unchanged-code control run. """ import argparse import importlib.util import math from pathlib import Path import sys import bpy ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT)) def load_exporter(name, path): spec = importlib.util.spec_from_file_location(name, path) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) return module def fixture(dependent): bpy.ops.wm.read_factory_settings(use_empty=True) material = bpy.data.materials.new("Fixture material") objects = [] def mesh_object(name, vertices, faces): mesh = bpy.data.meshes.new(name + " mesh") mesh.from_pydata(vertices, [], faces) mesh.materials.append(material) mesh["fixture_property"] = "preserved" obj = bpy.data.objects.new(name, mesh) bpy.context.scene.collection.objects.link(obj) objects.append(obj) return obj quad = [(0, 0, 0), (3, 0, 0), (2, 1, 0), (0, 2, 0)] mesh_object("quad", quad, [(0, 1, 2, 3)]) mesh_object("ngon", quad + [(-1, 1, 0)], [(0, 1, 2, 3, 4)]) authored = mesh_object("authored", quad, [(0, 1, 2, 3)]) uv = authored.data.uv_layers.new(name="Authored UV") for loop, value in zip(uv.data, [(0, 0), (.9, .1), (.6, .8), (.1, 1)]): loop.uv = value shared = mesh_object("shared", quad, [(0, 1, 2, 3)]) instance = bpy.data.objects.new("shared instance", shared.data) bpy.context.scene.collection.objects.link(instance) objects.append(instance) mesh_object("triangle", quad[:3], [(0, 1, 2)]) custom = mesh_object("custom normals", quad, [(0, 1, 2, 3)]) custom.data.normals_split_custom_set([(0, .2, 1)] * 4) keyed = mesh_object("shape keys", quad, [(0, 1, 2, 3)]) keyed.shape_key_add(name="Basis") keyed.shape_key_add(name="Raised").data[0].co.z = .25 bevel = mesh_object("bevel", quad, [(0, 1, 2, 3)]) modifier = bevel.modifiers.new("Fixture bevel", "BEVEL") modifier.width = .16 modifier.segments = 2 retained = mesh_object("fake user", quad, [(0, 1, 2, 3)]) retained.data.use_fake_user = True if dependent: boolean = objects[0].modifiers.new("Dependent Boolean", "BOOLEAN") boolean.object = authored return objects def digest(objects): return [{ "name": obj.name, "mesh": obj.data.name, "users": obj.data.users, "properties": dict(obj.data.items()), "vertices": [tuple(v.co) for v in obj.data.vertices], "polygons": [tuple(p.vertices) for p in obj.data.polygons], "smooth": [p.use_smooth for p in obj.data.polygons], "normals": [tuple(n.vector) for n in obj.data.corner_normals], "uv": {uv.name: [tuple(v.uv) for v in uv.data] for uv in obj.data.uv_layers}, "materials": [m.name if m else None for m in obj.data.materials], "modifiers": [(m.name, m.type) for m in obj.modifiers], "shape_keys": ([key.name for key in obj.data.shape_keys.key_blocks] if obj.data.shape_keys else []), } for obj in objects] def prepare(module, dependent, optimized): objects = fixture(dependent) if optimized: module.prepare_independent_meshes(objects) seen = set() for obj in objects: module.apply_mesh_modifiers(obj) if obj.data.name not in seen: seen.add(obj.data.name) module.triangulate_mesh(obj) module.unwrap_mesh(obj) assert objects[3].data is objects[4].data, "shared mesh was split" if not dependent: assert len(objects[0].data.polygons) == 2, "quad must give n - 2 triangles" assert len(objects[1].data.polygons) == 3, "pentagon must give n - 2 triangles" return digest(objects) def compare(expected, actual, path="root"): if isinstance(expected, dict): assert expected.keys() == actual.keys(), path for key in expected: compare(expected[key], actual[key], path + "." + str(key)) elif isinstance(expected, (list, tuple)): assert len(expected) == len(actual), (path, len(expected), len(actual)) for index, (left, right) in enumerate(zip(expected, actual)): compare(left, right, path + "[%d]" % index) elif isinstance(expected, float): assert math.isclose(expected, actual, rel_tol=0, abs_tol=1e-6), ( path, expected, actual) else: assert expected == actual, (path, expected, actual) def check_work_scene_cleanup(module): objects = fixture(False) triangle = objects[5] original_scene = bpy.context.window.scene original_layer = bpy.context.window.view_layer scene_names = set(bpy.data.scenes.keys()) collections = tuple(triangle.users_collection) unwrap = module.unwrap_mesh def fail_unwrap(obj): assert bpy.context.scene != original_scene assert obj == triangle raise RuntimeError("fixture UV failure") module.unwrap_mesh = fail_unwrap # Remove the Bevel so this specifically exercises the scratch-scene path. objects[8].modifiers.clear() try: try: module.unwrap_meshes_in_work_scene([triangle]) except RuntimeError as error: assert str(error) == "fixture UV failure" else: raise AssertionError("fixture failure was swallowed") finally: module.unwrap_mesh = unwrap assert bpy.context.window.scene == original_scene assert bpy.context.window.view_layer == original_layer assert set(bpy.data.scenes.keys()) == scene_names assert tuple(triangle.users_collection) == collections def main(): parser = argparse.ArgumentParser() parser.add_argument("--baseline", required=True) args = parser.parse_args(sys.argv[sys.argv.index("--") + 1:]) original = load_exporter("original_exporter", args.baseline) optimized = load_exporter("optimized_exporter", ROOT / "export_cesium.py") for dependent in (False, True): reference = prepare(original, dependent, False) compare(reference, prepare(original, dependent, False), "control") compare(reference, prepare(optimized, dependent, True), "optimized") check_work_scene_cleanup(optimized) print("EXPORT_PREPARATION_CHECK_OK: control, independent and dependent fixtures") if __name__ == "__main__": main()