RacesOfValheim/JotunnModStub/ModelBorrow.cs
kanym d05cea7f08 fix(warvulture): strip dependents first, no more Can't remove Humanoid at startup
The startup error came from WarVultureVisual.BuildTemplate, not from the
Ravager costume: its passes tried Humanoid before CharacterDrop. Components
another one still requires now wait for a later pass.
2026-10-17 20:24:43 +02:00

279 lines
13 KiB
C#

using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// Borrowing a vanilla prefab's LOOK without borrowing anything it does.
///
/// This exists because of a bug that shipped: the Trol's war totem mounted trophy models by calling
/// Instantiate and then stripping the components off the copy. Instantiate runs Awake FIRST, so for
/// one frame the copy was a real, live object - and a trophy is an ItemDrop, which means a giant
/// Yagluth head fell out of the sky every time the totem's ghost was drawn.
///
/// For a world prop (the Trenta grove borrows a Yggdrasil shoot this way) the stray frame does
/// nothing visible, which is why the technique looked fine the first two times it was used. For
/// anything carrying ItemDrop, ZNetView or a Rigidbody it is a live object with physics.
///
/// The fix is one line and it is the reason this is a shared helper rather than a third copy of the
/// same loop: instantiate into a holder that is ALREADY INACTIVE. Unity does not run Awake on a
/// component that comes up disabled, so the strip happens before anything can wake.
///
/// SECOND ROUND: the borrowed model is now sized in METRES instead of by a multiplier, because a
/// multiplier against an unknown mesh is a guess and guesses shipped a Yagluth head three times
/// taller than the post it stood on. The mesh is measured and scaled to fit, and it is grounded so
/// the holder's origin is the model's BOTTOM CENTRE rather than whatever the item's author happened
/// to use as a pivot - which is what makes "put the head on top of the totem" a subtraction instead
/// of another guess. This is rule 3.2 of the house guide applied to geometry: a number that was
/// measured is already balanced.
/// </summary>
public static class ModelBorrow
{
/// <summary>
/// Hangs the renderers of a vanilla prefab under <paramref name="parent"/> and returns the holder,
/// which the caller can switch on and off. Null-safe: a missing source logs and returns an empty
/// holder rather than throwing, so a wrong name costs a warning and not a startup.
///
/// <paramref name="localPosition"/> is where the model's BOTTOM CENTRE goes.
/// <paramref name="targetSize"/> is how big its largest dimension should end up, in metres,
/// measured AFTER <paramref name="localRotation"/> has been applied.
/// </summary>
public static GameObject Attach(Transform parent, string holderName, string sourcePrefab,
Vector3 localPosition, Quaternion localRotation, float targetSize,
string label)
{
GameObject source = Jotunn.Managers.PrefabManager.Cache.GetPrefab<GameObject>(sourcePrefab);
if (source == null)
{
Jotunn.Logger.LogWarning($"[{label}] No '{sourcePrefab}' to borrow a model from; nothing was attached.");
GameObject empty = new GameObject(holderName);
empty.transform.SetParent(parent, false);
empty.transform.localPosition = localPosition;
return empty;
}
return Attach(parent, holderName, source, localPosition, localRotation, targetSize, label);
}
/// <summary>
/// The same, for a source that has already been found by hand.
///
/// Not every borrowable model is a top-level prefab. The Seeker's wing, for one, is a
/// child of the creature's death effect rather than a prefab of its own, so no name lookup
/// can reach it and the caller has to walk to it first. Everything past the lookup - the
/// inactive holder, the component strip, the measure-and-ground - is identical, which is
/// exactly why this is an overload and not a second copy.
/// </summary>
public static GameObject Attach(Transform parent, string holderName, GameObject source,
Vector3 localPosition, Quaternion localRotation, float targetSize,
string label)
{
GameObject holder = new GameObject(holderName);
holder.transform.SetParent(parent, false);
holder.transform.localPosition = localPosition;
// BEFORE the Instantiate below. This single line is the whole point of the class.
holder.SetActive(false);
if (source == null)
{
Jotunn.Logger.LogWarning($"[{label}] No source model handed to '{holderName}'; nothing was attached.");
holder.SetActive(true);
return holder;
}
string sourcePrefab = source.name;
GameObject copy = Object.Instantiate(source, holder.transform);
copy.name = "model";
copy.transform.localPosition = Vector3.zero;
copy.transform.localRotation = localRotation;
copy.transform.localScale = Vector3.one;
// An item's "attach" child is stored switched off in its prefab (VisEquipment turns it on
// when it is worn), so a copy of one comes out switched off too. The holder above is still
// inactive, so turning the copy on wakes nothing.
if (!copy.activeSelf) copy.SetActive(true);
// Everything that is not a Renderer or a Transform. Order matters for the same reason it did
// on the Aswid's lights: behaviours first, then the things they hold references to.
StripBehaviours(copy, label);
foreach (Collider collider in copy.GetComponentsInChildren<Collider>(true))
{
if (collider != null) Object.DestroyImmediate(collider);
}
foreach (Rigidbody body in copy.GetComponentsInChildren<Rigidbody>(true))
{
if (body != null) Object.DestroyImmediate(body);
}
foreach (ZNetView nview in copy.GetComponentsInChildren<ZNetView>(true))
{
if (nview != null) Object.DestroyImmediate(nview);
}
FitAndGround(copy.transform, holder.transform, targetSize, sourcePrefab, label);
holder.SetActive(true);
return holder;
}
/// <summary>
/// Destroys every MonoBehaviour under <paramref name="root"/>, dependents first.
///
/// A single pass in component order is not enough, and the log said so: "Can't remove Humanoid
/// (Script) because CharacterDrop (Script) depends on it". Unity refuses to destroy a component
/// another one still requires through [RequireComponent], so the pass that reached Humanoid
/// before CharacterDrop left a live Humanoid on the Sverm's Ravager costume - on every player
/// wearing it - which is the leftover that once broke the hammer for every piece (see
/// SvermHive.MouthCandidates). Each round here destroys only what nothing remaining requires,
/// and rounds repeat until nothing is left or nothing more can go.
/// </summary>
public static void StripBehaviours(GameObject root, string label)
{
if (root == null) return;
for (int round = 0; round < 16; round++)
{
MonoBehaviour[] left = root.GetComponentsInChildren<MonoBehaviour>(true);
if (left.Length == 0) return;
int destroyed = 0;
foreach (MonoBehaviour behaviour in left)
{
if (behaviour == null || IsRequired(behaviour)) continue;
Object.DestroyImmediate(behaviour);
destroyed++;
}
if (destroyed == 0) break;
}
foreach (MonoBehaviour survivor in root.GetComponentsInChildren<MonoBehaviour>(true))
{
if (survivor != null)
{
Jotunn.Logger.LogWarning($"[{label}] '{survivor.GetType().Name}' on '{survivor.name}' could not be stripped from a borrowed model.");
}
}
}
/// <summary>True if another component on the same GameObject names this one's type in a
/// [RequireComponent].</summary>
public static bool IsRequired(Component target)
{
System.Type type = target.GetType();
foreach (Component other in target.GetComponents<Component>())
{
if (other == null || other == target) continue;
foreach (object attribute in other.GetType().GetCustomAttributes(typeof(RequireComponent), true))
{
RequireComponent require = (RequireComponent)attribute;
if (Requires(require.m_Type0, type) || Requires(require.m_Type1, type) || Requires(require.m_Type2, type))
{
return true;
}
}
}
return false;
}
private static bool Requires(System.Type required, System.Type type) => required != null && required.IsAssignableFrom(type);
/// <summary>
/// How tall the borrowed model actually turned out, in the holder's parent's space. Used to stack
/// one borrowed model on top of another without a magic offset.
/// </summary>
public static float HeightOf(GameObject holder)
{
if (holder == null) return 0f;
return TryMeasure(holder.transform, holder.transform, out Bounds bounds) ? bounds.size.y : 0f;
}
// ---------------------------------------------------------------- measuring
/// <summary>
/// Scales the copy so its largest dimension is <paramref name="targetSize"/> metres, then slides it
/// so its bottom centre sits on the holder's origin.
/// </summary>
private static void FitAndGround(Transform copy, Transform holder, float targetSize,
string sourcePrefab, string label)
{
if (!TryMeasure(copy, holder, out Bounds raw))
{
Jotunn.Logger.LogWarning($"[{label}] '{sourcePrefab}' has no readable mesh, so it could not be " +
"sized or grounded; it is attached at scale 1 and may sit wrong.");
return;
}
float biggest = Mathf.Max(raw.size.x, Mathf.Max(raw.size.y, raw.size.z));
if (biggest <= 0.0001f)
{
Jotunn.Logger.LogWarning($"[{label}] '{sourcePrefab}' measured as a point ({raw.size}); " +
"left at scale 1.");
return;
}
float scale = targetSize / biggest;
copy.localScale = Vector3.one * scale;
if (TryMeasure(copy, holder, out Bounds fitted))
{
copy.localPosition = new Vector3(-fitted.center.x, -fitted.min.y, -fitted.center.z);
}
Jotunn.Logger.LogInfo($"[{label}] Borrowed '{sourcePrefab}': measured {raw.size}, " +
$"scaled by {scale:0.###} to fit {targetSize} m, grounded on its own base.");
}
/// <summary>
/// Bounds of every mesh under <paramref name="root"/>, expressed in <paramref name="space"/>'s local
/// coordinates. Read from sharedMesh rather than Renderer.bounds on purpose: the holder is INACTIVE
/// while this runs (that is the whole point of the class) and a renderer that has never been enabled
/// has no world bounds yet, so Renderer.bounds would quietly return zero.
/// </summary>
private static bool TryMeasure(Transform root, Transform space, out Bounds bounds)
{
bounds = new Bounds();
bool any = false;
Matrix4x4 toSpace = space.worldToLocalMatrix;
foreach (Renderer renderer in root.GetComponentsInChildren<Renderer>(true))
{
if (renderer == null) continue;
Mesh mesh;
if (renderer is SkinnedMeshRenderer skinned)
{
mesh = skinned.sharedMesh;
}
else
{
MeshFilter filter = renderer.GetComponent<MeshFilter>();
mesh = filter != null ? filter.sharedMesh : null;
}
if (mesh == null) continue;
Encapsulate(ref bounds, ref any, toSpace * renderer.transform.localToWorldMatrix, mesh.bounds);
}
return any;
}
/// <summary>All eight corners, because a rotated box's bounds are not its centre plus its extents.</summary>
private static void Encapsulate(ref Bounds bounds, ref bool any, Matrix4x4 matrix, Bounds local)
{
Vector3 centre = local.center;
Vector3 extents = local.extents;
for (int corner = 0; corner < 8; corner++)
{
Vector3 point = matrix.MultiplyPoint3x4(centre + new Vector3(
(corner & 1) == 0 ? -extents.x : extents.x,
(corner & 2) == 0 ? -extents.y : extents.y,
(corner & 4) == 0 ? -extents.z : extents.z));
if (!any) { bounds = new Bounds(point, Vector3.zero); any = true; }
else bounds.Encapsulate(point);
}
}
}
}