308 lines
13 KiB
Python
308 lines
13 KiB
Python
import json
|
|
import struct
|
|
import tempfile
|
|
import unittest
|
|
from pathlib import Path
|
|
|
|
from PIL import Image
|
|
|
|
import model_pipeline
|
|
|
|
|
|
def parse_glb(payload: bytes):
|
|
magic, version, length = struct.unpack_from("<III", payload, 0)
|
|
json_len, json_type = struct.unpack_from("<II", payload, 12)
|
|
gltf = json.loads(payload[20:20 + json_len].decode("utf-8"))
|
|
bin_offset = 20 + json_len
|
|
bin_len, bin_type = struct.unpack_from("<II", payload, bin_offset)
|
|
binary = payload[bin_offset + 8:bin_offset + 8 + bin_len]
|
|
return {
|
|
"magic": magic,
|
|
"version": version,
|
|
"length": length,
|
|
"json_type": json_type,
|
|
"bin_type": bin_type,
|
|
"bin_len": bin_len,
|
|
"binary": binary,
|
|
"gltf": gltf,
|
|
}
|
|
|
|
|
|
def prop(name):
|
|
return model_pipeline.DIRECTORY_BY_NAME[name]
|
|
|
|
|
|
class CatalogueTests(unittest.TestCase):
|
|
def test_props_are_well_formed(self):
|
|
names = [p["name"] for p in model_pipeline.PROPS]
|
|
self.assertEqual(len(names), len(set(names)),
|
|
"prop names must be unique")
|
|
for entry in model_pipeline.PROPS:
|
|
self.assertTrue(entry["concept"].strip())
|
|
self.assertTrue(entry["parts"])
|
|
for part in entry["parts"]:
|
|
self.assertIn(part["shape"], ("box", "cylinder"))
|
|
self.assertEqual(len(part["at"]), 3)
|
|
self.assertIn(part["role"], model_pipeline.PALETTE)
|
|
if part["shape"] == "box":
|
|
self.assertEqual(len(part["size"]), 3)
|
|
self.assertTrue(all(value > 0 for value in part["size"]))
|
|
else:
|
|
self.assertGreater(part["radius"], 0)
|
|
self.assertGreater(part["height"], 0)
|
|
|
|
def test_every_prop_has_triangles(self):
|
|
for entry in model_pipeline.PROPS:
|
|
mesh = model_pipeline.build_prop_mesh(entry)
|
|
self.assertGreater(mesh.triangle_count(), 0, entry["name"])
|
|
self.assertLess(mesh.triangle_count(), 4000, entry["name"])
|
|
self.assertEqual(len(mesh.positions), len(mesh.normals))
|
|
|
|
|
|
class MeshWindingTests(unittest.TestCase):
|
|
def test_box_face_normals_point_outward(self):
|
|
mesh = model_pipeline.MeshData()
|
|
model_pipeline._add_box(mesh, (2.0, 2.0, 2.0), (0.0, 0.0, 0.0))
|
|
for tri in range(0, len(mesh.indices), 3):
|
|
a, b, c = (mesh.positions[mesh.indices[tri + i]] for i in range(3))
|
|
normal = mesh.normals[mesh.indices[tri]]
|
|
centroid = tuple((a[i] + b[i] + c[i]) / 3.0 for i in range(3))
|
|
self.assertGreater(
|
|
model_pipeline._dot(normal, centroid), 0.0,
|
|
"box face normal must point away from the centre")
|
|
|
|
def test_cylinder_caps_face_up_and_down(self):
|
|
mesh = model_pipeline.MeshData()
|
|
model_pipeline._add_cylinder(mesh, 0.5, 1.0, (0.0, 0.5, 0.0), 8)
|
|
ups = [n for n in mesh.normals if n[1] > 0.9]
|
|
downs = [n for n in mesh.normals if n[1] < -0.9]
|
|
self.assertTrue(ups, "cylinder needs an upward cap")
|
|
self.assertTrue(downs, "cylinder needs a downward cap")
|
|
|
|
|
|
class GlbTests(unittest.TestCase):
|
|
def test_glb_container_and_structure(self):
|
|
payload = model_pipeline.build_glb(prop("bench"))
|
|
parsed = parse_glb(payload)
|
|
self.assertEqual(parsed["magic"], 0x46546C67)
|
|
self.assertEqual(parsed["version"], 2)
|
|
self.assertEqual(parsed["length"], len(payload))
|
|
self.assertEqual(parsed["json_type"], 0x4E4F534A)
|
|
self.assertEqual(parsed["bin_type"], 0x004E4942)
|
|
self.assertEqual(len(payload) % 4, 0)
|
|
gltf = parsed["gltf"]
|
|
self.assertEqual(gltf["asset"]["version"], "2.0")
|
|
self.assertEqual(len(gltf["scenes"]), 1)
|
|
primitives = gltf["meshes"][0]["primitives"]
|
|
self.assertEqual(len(primitives), 1,
|
|
"parts share one primitive (one material)")
|
|
self.assertEqual(len(gltf["materials"]), 1,
|
|
"the prop draws with a single material")
|
|
for primitive in primitives:
|
|
self.assertIn("POSITION", primitive["attributes"])
|
|
self.assertIn("NORMAL", primitive["attributes"])
|
|
self.assertIn("TEXCOORD_0", primitive["attributes"],
|
|
"atlas UVs are required")
|
|
self.assertIsNotNone(primitive["indices"])
|
|
self.assertEqual(primitive["material"], 0)
|
|
for accessor in gltf["accessors"]:
|
|
self.assertIn(accessor["bufferView"],
|
|
range(len(gltf["bufferViews"])))
|
|
self.assertGreater(accessor["count"], 0)
|
|
self.assertLessEqual(gltf["buffers"][0]["byteLength"],
|
|
len(parsed["binary"]))
|
|
|
|
def test_glb_is_deterministic(self):
|
|
first = model_pipeline.build_glb(prop("bollard"))
|
|
second = model_pipeline.build_glb(prop("bollard"))
|
|
self.assertEqual(first, second)
|
|
|
|
def test_palette_override_changes_the_atlas_colour(self):
|
|
palette = {role: list(rgb)
|
|
for role, rgb in model_pipeline.PALETTE.items()}
|
|
palette["metal"] = [0.9, 0.1, 0.1]
|
|
atlas = model_pipeline.atlas_for(prop("bollard"), palette)
|
|
self.assertIn((0.9, 0.1, 0.1), atlas["colours"].values())
|
|
default = model_pipeline.build_glb(prop("bollard"))
|
|
overridden = model_pipeline.build_glb(prop("bollard"), palette)
|
|
self.assertNotEqual(default, overridden,
|
|
"the atlas texture carries the palette")
|
|
|
|
def test_material_uses_both_atlas_textures(self):
|
|
gltf = parse_glb(model_pipeline.build_glb(prop("bollard")))["gltf"]
|
|
pbr = gltf["materials"][0]["pbrMetallicRoughness"]
|
|
self.assertEqual(pbr["metallicFactor"], 1.0)
|
|
self.assertEqual(pbr["roughnessFactor"], 1.0)
|
|
self.assertIn("baseColorTexture", pbr)
|
|
self.assertIn("metallicRoughnessTexture", pbr)
|
|
self.assertEqual(len(gltf["images"]), 2)
|
|
self.assertEqual(len(gltf["textures"]), 2)
|
|
for image in gltf["images"]:
|
|
self.assertEqual(image["mimeType"], "image/png")
|
|
self.assertEqual(gltf["samplers"][0]["magFilter"], 9728,
|
|
"nearest sampling keeps palette cells flat")
|
|
|
|
def test_atlas_is_deterministic_and_power_of_two(self):
|
|
first = model_pipeline.atlas_for(prop("planter_box"))
|
|
second = model_pipeline.atlas_for(prop("planter_box"))
|
|
self.assertEqual(first["base_png"], second["base_png"])
|
|
size = first["size"]
|
|
self.assertEqual(size & (size - 1), 0, "atlas size is a power of two")
|
|
for u, v in first["role_uv"].values():
|
|
self.assertTrue(0.0 < u < 1.0 and 0.0 < v < 1.0,
|
|
"UVs stay on the texture")
|
|
self.assertEqual(len(first["roles"]), len(set(first["roles"])))
|
|
|
|
def test_indices_stay_inside_their_primitive(self):
|
|
payload = model_pipeline.build_glb(prop("planter_box"))
|
|
parsed = parse_glb(payload)
|
|
gltf = parsed["gltf"]
|
|
binary = parsed["binary"]
|
|
for primitive in gltf["meshes"][0]["primitives"]:
|
|
position_accessor = gltf["accessors"][primitive["attributes"]["POSITION"]]
|
|
index_accessor = gltf["accessors"][primitive["indices"]]
|
|
view = gltf["bufferViews"][index_accessor["bufferView"]]
|
|
raw = binary[view["byteOffset"] :view["byteOffset"] + view["byteLength"]]
|
|
indices = struct.unpack(f"<{len(raw) // 2}H", raw)
|
|
self.assertLess(max(indices), position_accessor["count"])
|
|
self.assertEqual(index_accessor["count"], len(indices))
|
|
|
|
|
|
class AuditTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.temp_dir = tempfile.TemporaryDirectory()
|
|
self.root = Path(self.temp_dir.name)
|
|
|
|
def tearDown(self):
|
|
self.temp_dir.cleanup()
|
|
|
|
def test_audit_accepts_a_written_file(self):
|
|
path = self.root / "bench.glb"
|
|
path.write_bytes(model_pipeline.build_glb(prop("bench")))
|
|
result = model_pipeline.audit_glb(path)
|
|
self.assertTrue(result["ok"], result["issues"])
|
|
self.assertGreater(result["triangles"], 0)
|
|
|
|
def test_audit_reports_missing_file(self):
|
|
result = model_pipeline.audit_glb(self.root / "nope.glb")
|
|
self.assertFalse(result["ok"])
|
|
self.assertIn("missing file", result["issues"])
|
|
|
|
def test_audit_reports_truncated_file(self):
|
|
path = self.root / "cut.glb"
|
|
path.write_bytes(model_pipeline.build_glb(prop("bench"))[:40])
|
|
result = model_pipeline.audit_glb(path)
|
|
self.assertFalse(result["ok"])
|
|
self.assertTrue(result["issues"])
|
|
|
|
def test_audit_enforces_the_triangle_budget(self):
|
|
old = model_pipeline.MAX_TRIANGLES
|
|
model_pipeline.MAX_TRIANGLES = 10
|
|
try:
|
|
path = self.root / "bench.glb"
|
|
path.write_bytes(model_pipeline.build_glb(prop("bench")))
|
|
result = model_pipeline.audit_glb(path)
|
|
finally:
|
|
model_pipeline.MAX_TRIANGLES = old
|
|
self.assertFalse(result["ok"])
|
|
self.assertTrue(any("triangle budget" in issue for issue in result["issues"]),
|
|
result["issues"])
|
|
|
|
def test_degenerate_triangle_helper(self):
|
|
self.assertEqual(
|
|
model_pipeline._triangle_area2((0, 0, 0), (1, 0, 0), (2, 0, 0)), 0.0)
|
|
self.assertGreater(
|
|
model_pipeline._triangle_area2((0, 0, 0), (1, 0, 0), (0, 1, 0)), 0.0)
|
|
|
|
def test_audit_reads_positions_and_uvs_from_the_binary(self):
|
|
parsed = parse_glb(model_pipeline.build_glb(prop("bollard")))
|
|
gltf, binary = parsed["gltf"], parsed["binary"]
|
|
primitive = gltf["meshes"][0]["primitives"][0]
|
|
positions = model_pipeline._read_float_accessor(
|
|
gltf, binary, primitive["attributes"]["POSITION"])
|
|
uvs = model_pipeline._read_float_accessor(
|
|
gltf, binary, primitive["attributes"]["TEXCOORD_0"])
|
|
indices = model_pipeline._read_index_accessor(
|
|
gltf, binary, primitive["indices"])
|
|
self.assertEqual(len(positions), gltf["accessors"][
|
|
primitive["attributes"]["POSITION"]]["count"])
|
|
self.assertEqual(len(uvs), len(positions))
|
|
self.assertEqual(len(indices) % 3, 0)
|
|
self.assertLess(min(p[1] for p in positions), 0.01)
|
|
for u, v in uvs:
|
|
self.assertTrue(0.0 <= u <= 1.0 and 0.0 <= v <= 1.0)
|
|
|
|
def test_build_writes_into_the_models_directory(self):
|
|
old = model_pipeline.MODELS_DIR
|
|
model_pipeline.MODELS_DIR = self.root
|
|
try:
|
|
written = model_pipeline.build("bollard", quiet=True)
|
|
self.assertEqual(len(written), 1)
|
|
self.assertTrue(written[0].is_file())
|
|
self.assertTrue(model_pipeline.audit_glb(written[0])["ok"])
|
|
finally:
|
|
model_pipeline.MODELS_DIR = old
|
|
|
|
|
|
class PaletteTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.temp_dir = tempfile.TemporaryDirectory()
|
|
self.root = Path(self.temp_dir.name)
|
|
|
|
def tearDown(self):
|
|
self.temp_dir.cleanup()
|
|
|
|
def test_dominant_colors_ignores_white_background(self):
|
|
image = Image.new("RGB", (96, 96), (250, 250, 250))
|
|
for x in range(20, 70):
|
|
for y in range(20, 70):
|
|
image.putpixel((x, y), (150, 40, 40))
|
|
colors = model_pipeline.dominant_colors(image)
|
|
self.assertTrue(colors)
|
|
self.assertLess(max(colors[0]), 0.9,
|
|
"background must not win the vote")
|
|
|
|
def test_palette_uses_concept_image_when_present(self):
|
|
old = model_pipeline.CONCEPTS_DIR
|
|
model_pipeline.CONCEPTS_DIR = self.root
|
|
try:
|
|
image = Image.new("RGB", (96, 96), (250, 250, 250))
|
|
for x in range(20, 70):
|
|
for y in range(20, 70):
|
|
image.putpixel((x, y), (30, 90, 40))
|
|
image.save(self.root / "bench.png")
|
|
palette = model_pipeline.palette_for_prop("bench")
|
|
self.assertLess(palette["body"][1], 0.6)
|
|
self.assertGreater(palette["body"][1], palette["body"][0])
|
|
finally:
|
|
model_pipeline.CONCEPTS_DIR = old
|
|
|
|
def test_palette_falls_back_to_defaults(self):
|
|
old = model_pipeline.CONCEPTS_DIR
|
|
model_pipeline.CONCEPTS_DIR = self.root
|
|
try:
|
|
palette = model_pipeline.palette_for_prop("bench")
|
|
self.assertEqual(palette["wood"], model_pipeline.PALETTE["wood"])
|
|
finally:
|
|
model_pipeline.CONCEPTS_DIR = old
|
|
|
|
def test_assign_roles_separates_wood_from_metal(self):
|
|
colors = [[0.62, 0.37, 0.18], [0.05, 0.05, 0.05], [0.70, 0.70, 0.70]]
|
|
palette = model_pipeline.assign_roles(colors)
|
|
self.assertAlmostEqual(palette["wood"][0], 0.62, places=3)
|
|
self.assertLess(model_pipeline._luminance(palette["metal"]), 0.1)
|
|
|
|
def test_assign_roles_finds_foliage_and_stone(self):
|
|
colors = [[0.55, 0.55, 0.53], [0.18, 0.42, 0.20]]
|
|
palette = model_pipeline.assign_roles(colors)
|
|
self.assertGreater(palette["foliage"][1], palette["foliage"][0])
|
|
self.assertGreater(palette["stone"][0], 0.5)
|
|
|
|
def test_assign_roles_without_colours_keeps_defaults(self):
|
|
palette = model_pipeline.assign_roles([])
|
|
self.assertEqual(palette["body"], model_pipeline.PALETTE["body"])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|