176 lines
7.3 KiB
GDScript
176 lines
7.3 KiB
GDScript
extends RefCounted
|
|
## Headless checks for the Blender-authored assets staged under
|
|
## `assets/models/blender/` (tools/blender_assets.py). Nothing in the game loads
|
|
## them yet; these tests keep them import-clean and drop-in compatible with the
|
|
## npc_base contract until they are integrated.
|
|
|
|
const MANIFEST := "res://assets/models/blender/manifest.json"
|
|
const NPC_BASE := "res://assets/models/generated/npc_base.glb"
|
|
const SLOTS := ["skin", "cloth", "pants", "accessory", "hair"]
|
|
const BONES := ["Head", "HipL", "HipR", "KneeL", "KneeR", "ShoulderL", "ShoulderR",
|
|
"ElbowL", "ElbowR", "HandL", "HandR"]
|
|
## The Quaternius rig (ADR-0018) is a 62-joint armature. `NpcAvatar` maps these
|
|
## joints onto the animation proxies, so they are the drop-in requirement for a
|
|
## Quaternius-derived character instead of the 13-core names.
|
|
const QUATERNIUS_BONES := ["Head", "UpperLeg.L", "UpperLeg.R", "LowerLeg.L",
|
|
"LowerLeg.R", "UpperArm.L", "UpperArm.R", "LowerArm.L", "LowerArm.R",
|
|
"Wrist.L", "Wrist.R"]
|
|
|
|
## Quaternius-derived characters are detected by a dot-suffixed UpperArm joint;
|
|
## the procedural library uses ShoulderL/ShoulderR instead.
|
|
func _is_quaternius(skeleton: Skeleton3D) -> bool:
|
|
return skeleton != null and skeleton.find_bone("UpperArm.L") >= 0
|
|
|
|
func _manifest() -> Dictionary:
|
|
if not FileAccess.file_exists(MANIFEST):
|
|
return {}
|
|
var parsed: Variant = JSON.parse_string(FileAccess.get_file_as_string(MANIFEST))
|
|
return parsed if parsed is Dictionary else {}
|
|
|
|
func _assets(category: String = "") -> Dictionary:
|
|
var out := {}
|
|
var assets: Dictionary = _manifest().get("assets", {})
|
|
for name in assets:
|
|
var entry: Dictionary = assets[name]
|
|
if category == "" or str(entry.get("category", "")) == category:
|
|
out[name] = entry
|
|
return out
|
|
|
|
func _instance(entry: Dictionary) -> Node3D:
|
|
var packed := ResourceLoader.load("res://" + str(entry["path"])) as PackedScene
|
|
if packed == null:
|
|
return null
|
|
return packed.instantiate() as Node3D
|
|
|
|
func _global_rest(skeleton: Skeleton3D, bone: int) -> Transform3D:
|
|
var xf := skeleton.get_bone_rest(bone)
|
|
var parent := skeleton.get_bone_parent(bone)
|
|
while parent >= 0:
|
|
xf = skeleton.get_bone_rest(parent) * xf
|
|
parent = skeleton.get_bone_parent(parent)
|
|
return xf
|
|
|
|
func test_manifest_lists_every_category() -> bool:
|
|
var counts := {}
|
|
for entry in _assets().values():
|
|
var category := str(entry.get("category", ""))
|
|
counts[category] = int(counts.get(category, 0)) + 1
|
|
return TestUtils.check(int(counts.get("npc", 0)) >= 8
|
|
and int(counts.get("npc_gear", 0)) >= 10 and int(counts.get("props", 0)) >= 10,
|
|
"manifest lists characters, gear and props (%s)" % str(counts))
|
|
|
|
func test_every_asset_imports_as_a_scene_with_geometry() -> bool:
|
|
var problems: Array[String] = []
|
|
var assets := _assets()
|
|
for name in assets:
|
|
var node := _instance(assets[name])
|
|
if node == null:
|
|
problems.append("%s not imported" % name)
|
|
continue
|
|
if node.find_children("*", "MeshInstance3D", true, false).is_empty():
|
|
problems.append("%s has no mesh" % name)
|
|
node.free()
|
|
return TestUtils.check(not assets.is_empty() and problems.is_empty(),
|
|
"Blender assets import (%s)" % str(problems))
|
|
|
|
func test_characters_match_the_npc_base_contract() -> bool:
|
|
var problems: Array[String] = []
|
|
var assets := _assets("npc")
|
|
for name in assets:
|
|
var node := _instance(assets[name])
|
|
if node == null:
|
|
problems.append("%s missing" % name)
|
|
continue
|
|
var skeleton := node.find_child("Skeleton3D", true, false) as Skeleton3D
|
|
var mesh := node.find_child("npc_base", true, false) as MeshInstance3D
|
|
if skeleton == null or mesh == null:
|
|
problems.append("%s lacks Skeleton3D/npc_base" % name)
|
|
node.free()
|
|
continue
|
|
var required: Array = QUATERNIUS_BONES if _is_quaternius(skeleton) else BONES
|
|
for bone in required:
|
|
if skeleton.find_bone(bone) < 0:
|
|
problems.append("%s missing bone %s" % [name, bone])
|
|
var slots := {}
|
|
for i in mesh.mesh.get_surface_count():
|
|
var mat := mesh.mesh.surface_get_material(i)
|
|
if mat != null:
|
|
slots[str(mat.resource_name)] = true
|
|
for slot in SLOTS:
|
|
if not slots.has(slot):
|
|
problems.append("%s missing slot %s" % [name, slot])
|
|
node.free()
|
|
return TestUtils.check(assets.size() >= 8 and problems.is_empty(),
|
|
"characters keep bones + slots (%s)" % str(problems))
|
|
|
|
func test_character_joints_line_up_with_npc_base() -> bool:
|
|
## NpcAvatar positions its animation proxies for npc_base; a drop-in
|
|
## replacement must put the same joints in the same places.
|
|
if not ResourceLoader.exists(NPC_BASE):
|
|
return TestUtils.check(true, "npc_base not imported; skipped")
|
|
var base := (ResourceLoader.load(NPC_BASE) as PackedScene).instantiate()
|
|
var base_skel := base.find_child("Skeleton3D", true, false) as Skeleton3D
|
|
var problems: Array[String] = []
|
|
var assets := _assets("npc")
|
|
for name in assets:
|
|
var node := _instance(assets[name])
|
|
var skeleton := node.find_child("Skeleton3D", true, false) as Skeleton3D if node else null
|
|
if skeleton == null:
|
|
problems.append("%s has no skeleton" % name)
|
|
elif _is_quaternius(skeleton):
|
|
# ADR-0018: a Quaternius character keeps its own 62-joint skeleton and
|
|
# NpcAvatar re-derives the proxy pivots from it, so the joints are not
|
|
# expected to sit on npc_base's 13-core positions.
|
|
pass
|
|
else:
|
|
for bone in BONES:
|
|
var a := _global_rest(base_skel, base_skel.find_bone(bone)).origin
|
|
var b := _global_rest(skeleton, skeleton.find_bone(bone)).origin
|
|
if a.distance_to(b) > 0.01:
|
|
problems.append("%s.%s off by %.3f" % [name, bone, a.distance_to(b)])
|
|
if node:
|
|
node.free()
|
|
base.free()
|
|
return TestUtils.check(problems.is_empty(), "joints match npc_base (%s)" % str(problems))
|
|
|
|
func test_character_bones_accept_the_avatar_pose_math() -> bool:
|
|
## Same composition as NpcAvatar._pose_bone(): rest * offset must stay a
|
|
## valid rotation on every limb bone.
|
|
var problems: Array[String] = []
|
|
var assets := _assets("npc")
|
|
for name in assets:
|
|
var node := _instance(assets[name])
|
|
var skeleton := node.find_child("Skeleton3D", true, false) as Skeleton3D if node else null
|
|
if skeleton == null:
|
|
problems.append(name)
|
|
else:
|
|
var bones: Array = QUATERNIUS_BONES if _is_quaternius(skeleton) else BONES
|
|
for bone in bones:
|
|
var index := skeleton.find_bone(bone)
|
|
if index < 0:
|
|
problems.append("%s missing %s" % [name, bone])
|
|
continue
|
|
# NpcAvatar._swing_bone(): pose = rest^-1 * swing * rest, applied
|
|
# through the global pose. The composition must stay a valid
|
|
# rotation on every limb bone of either rig.
|
|
var rest := skeleton.get_bone_global_rest(index).basis.get_rotation_quaternion()
|
|
var swing := Quaternion(Vector3.RIGHT, 0.4)
|
|
skeleton.set_bone_pose_rotation(index, rest.inverse() * swing * rest)
|
|
if not skeleton.get_bone_pose_rotation(index).is_normalized():
|
|
problems.append("%s.%s" % [name, bone])
|
|
if node:
|
|
node.free()
|
|
return TestUtils.check(problems.is_empty(), "bones pose cleanly (%s)" % str(problems))
|
|
|
|
func test_grounded_props_sit_on_the_floor() -> bool:
|
|
var problems: Array[String] = []
|
|
var assets := _assets("props")
|
|
for name in assets:
|
|
var bounds: Dictionary = assets[name].get("bounds_godot", {})
|
|
if name in ["wall_lantern", "marquee"] or bounds.is_empty():
|
|
continue
|
|
var min_y := float(bounds["min"][1])
|
|
if absf(min_y) > 0.03:
|
|
problems.append("%s min y %.3f" % [name, min_y])
|
|
return TestUtils.check(problems.is_empty(), "props grounded (%s)" % str(problems))
|