178 lines
6.7 KiB
Python
178 lines
6.7 KiB
Python
"""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()
|