fix(dvergur): carve the hood out of the dvergr mesh as a submesh

The log settled it: the Dverger prefab holds a single renderer, dvergr, with
the hood, body and clothes baked into one mesh. There was never a separate
object to lift out, so the whole-object search could only ever fail.

Resolution now falls through three steps - a separate renderer object, a
submesh picked out by its material name, and an index pinned by hand in
DvergurConfig - and the submesh path rebuilds the chosen triangles as a
standalone skinned renderer. Vertices, bone weights and bindposes are all
carried over untouched and only the triangle list is narrowed, so the skinning
still lines up and the player rig places the hood without any offsets.

The candidate list also covers the mage variants, which wear a different hood
and may keep it as its own object.

dumpdverger now reports submesh count, per-submesh material and triangle count,
which is the part that actually identifies the hood.
This commit is contained in:
kanym 2026-08-02 23:14:07 +02:00
commit d157a730a3
3 changed files with 220 additions and 59 deletions

View file

@ -52,11 +52,31 @@ namespace RacesOfValheim
//
// The hood is lifted straight off the Dvergr NPC rather than off the Dverger Circlet item:
// the circlet is a metal band, not the hood the race is meant to wear.
//
// 'Dverger' turned out to carry a single renderer named 'dvergr' with the hood baked into
// the same mesh as the body, so a whole-object lift was never going to work. Resolution now
// tries, in order: a separate renderer object; a submesh of a combined mesh picked out by
// its material; and finally an index pinned by hand below.
public const string DvergerPrefabName = "Dverger";
// Matched against renderer object names inside that prefab, lowercased, by Contains.
// Scanned in order. The mage variants are included because they wear a different hood and
// may well keep it as its own object.
public static readonly string[] DvergerPrefabCandidates =
{
"Dverger", "DvergerMage", "DvergerMageFire", "DvergerMageIce", "DvergerMageSupport"
};
// Matched against renderer object names, lowercased, by Contains.
public static readonly string[] HoodRendererNames = { "hat", "hood", "helmet", "cap" };
// Matched against material names when the hood is a submesh of a combined mesh.
public static readonly string[] HoodMaterialNames = { "hat", "hood", "helm", "cap", "head" };
// Escape hatch for when neither name matches: pin the prefab and the submesh index by hand
// from what `dumpdverger` reports. An empty prefab or a negative index means "auto".
public const string HoodForcedPrefab = "";
public const int HoodForcedSubmeshIndex = -1;
// Applied on top of whatever the rig positions the hood at. Identity is correct when the
// bone remap succeeds; these exist so a stubborn mesh can be nudged without a code change.
public static readonly Vector3 HoodOffsetPosition = Vector3.zero;

View file

@ -20,7 +20,7 @@ namespace RacesOfValheim
// The hood only has to be looked up once per session; the search walks a whole creature
// prefab and would otherwise run again for every player that comes into view.
private static GameObject cachedHoodSource;
private static HoodSource cachedHoodSource;
private static bool hoodSourceResolved;
/// <summary>
@ -128,65 +128,129 @@ namespace RacesOfValheim
return;
}
GameObject source = ResolveHoodSource();
if (source == null) return; // already logged once by the resolver
HoodSource source = ResolveHoodSource();
if (!source.Valid) return; // already logged once by the resolver
Transform[] playerBones = visEq.m_bodyModel.bones;
GameObject hood = source.SubmeshIndex >= 0
? BuildFromSubmesh(source.Skinned, source.SubmeshIndex, parent, playerBones)
: BuildFromObject(source.Separate, parent, playerBones);
if (hood == null) return;
hood.name = HoodName;
hood.transform.localPosition = DvergurConfig.HoodOffsetPosition;
hood.transform.localRotation = Quaternion.Euler(DvergurConfig.HoodOffsetRotation);
hood.transform.localScale = Vector3.one * DvergurConfig.HoodExtraScale;
hood.SetActive(true);
}
/// <summary>
/// Carves one submesh out of a combined skinned mesh and rebuilds it as a standalone
/// renderer bound to the player's rig.
///
/// This is what the Dvergr needs: its prefab holds a single renderer, 'dvergr', with the
/// hood, the body and the clothes all in one mesh, so there is no object to lift out. Every
/// vertex, bone weight and bindpose is kept - only the triangle list is narrowed to the one
/// submesh - which means the skinning still lines up and the rig places the hood for us.
/// </summary>
private static GameObject BuildFromSubmesh(SkinnedMeshRenderer source, int submeshIndex, Transform parent, Transform[] playerBones)
{
Mesh sourceMesh = source.sharedMesh;
if (sourceMesh == null || submeshIndex >= sourceMesh.subMeshCount) return null;
Mesh mesh = new Mesh();
// Must be set before the vertex array on meshes above 65535 verts, or the indices
// silently truncate.
mesh.indexFormat = sourceMesh.indexFormat;
mesh.vertices = sourceMesh.vertices;
mesh.normals = sourceMesh.normals;
mesh.tangents = sourceMesh.tangents;
mesh.uv = sourceMesh.uv;
mesh.boneWeights = sourceMesh.boneWeights;
mesh.bindposes = sourceMesh.bindposes;
mesh.subMeshCount = 1;
mesh.SetTriangles(sourceMesh.GetTriangles(submeshIndex), 0);
mesh.RecalculateBounds();
GameObject obj = new GameObject(HoodName);
obj.transform.SetParent(parent, false);
SkinnedMeshRenderer renderer = obj.AddComponent<SkinnedMeshRenderer>();
renderer.sharedMesh = mesh;
Material[] sourceMaterials = source.sharedMaterials;
if (submeshIndex < sourceMaterials.Length)
{
renderer.sharedMaterials = new[] { sourceMaterials[submeshIndex] };
}
RebindBones(renderer, source.bones, source.rootBone, playerBones);
ApplyDitherShader(obj);
return obj;
}
private static GameObject BuildFromObject(GameObject source, Transform parent, Transform[] playerBones)
{
if (source == null) return null;
bool wasActive = source.activeSelf;
source.SetActive(false);
GameObject hood = Object.Instantiate(source, parent, false);
source.SetActive(wasActive);
hood.name = HoodName;
StripBehaviours(hood);
hood.SetActive(true);
// The hood is skinned to the Dvergr rig. Instantiated as-is its bones still point at
// the source prefab's transforms, so it renders at the world origin or not at all -
// which is exactly why the first attempt was invisible. Rebinding it to the player's
// own bones by name is what the Skeleton does for whole bodies, and it means the rig
// positions the hood for us instead of us guessing offsets.
Transform[] playerBones = visEq.m_bodyModel.bones;
// Instantiated as-is, a skinned mesh keeps bones pointing at the source prefab's
// transforms and so renders nowhere; rebinding to the player's own bones by name is
// what the Skeleton does for whole bodies.
bool rebound = false;
foreach (SkinnedMeshRenderer smr in hood.GetComponentsInChildren<SkinnedMeshRenderer>(true))
{
Transform[] bones = smr.bones;
Transform[] remapped = new Transform[bones.Length];
for (int i = 0; i < bones.Length; i++)
{
Transform match = bones[i] != null ? FindBoneByName(playerBones, bones[i].name) : null;
remapped[i] = match != null ? match : playerBones[0];
}
smr.bones = remapped;
if (smr.rootBone != null)
{
smr.rootBone = FindBoneByName(playerBones, smr.rootBone.name) ?? playerBones[0];
}
RebindBones(smr, smr.bones, smr.rootBone, playerBones);
rebound = true;
}
if (!rebound)
{
// A rigid hood rather than a skinned one: it has no bones to rebind, so it is
// simply hung off the head the way the Furling's head is.
// A rigid hood has no bones to rebind, so it is simply hung off the head the way
// the Furling's head is.
Transform headBone = FindBoneByName(playerBones, "Head");
if (headBone != null) hood.transform.SetParent(headBone, false);
}
hood.transform.localPosition = DvergurConfig.HoodOffsetPosition;
hood.transform.localRotation = Quaternion.Euler(DvergurConfig.HoodOffsetRotation);
hood.transform.localScale = Vector3.one * DvergurConfig.HoodExtraScale;
ApplyDitherShader(hood);
return hood;
}
// Without the creature shader the hood ignores the camera's dither fade and fills the
// screen in first person; its own textures are kept.
Shader dither = Shader.Find("Custom/Creature");
if (dither != null)
private static void RebindBones(SkinnedMeshRenderer renderer, Transform[] sourceBones, Transform sourceRoot, Transform[] playerBones)
{
if (playerBones == null || playerBones.Length == 0 || sourceBones == null) return;
Transform[] remapped = new Transform[sourceBones.Length];
for (int i = 0; i < sourceBones.Length; i++)
{
foreach (Renderer renderer in hood.GetComponentsInChildren<Renderer>(true))
{
if (renderer.material != null) renderer.material.shader = dither;
}
Transform match = sourceBones[i] != null ? FindBoneByName(playerBones, sourceBones[i].name) : null;
remapped[i] = match != null ? match : playerBones[0];
}
renderer.bones = remapped;
renderer.rootBone = sourceRoot != null
? (FindBoneByName(playerBones, sourceRoot.name) ?? playerBones[0])
: playerBones[0];
}
/// <summary>
/// Without the creature shader the hood ignores the camera's dither fade and fills the
/// screen in first person; its own textures are kept.
/// </summary>
private static void ApplyDitherShader(GameObject obj)
{
Shader dither = Shader.Find("Custom/Creature");
if (dither == null) return;
foreach (Renderer renderer in obj.GetComponentsInChildren<Renderer>(true))
{
if (renderer.material != null) renderer.material.shader = dither;
}
}
@ -212,42 +276,100 @@ namespace RacesOfValheim
/// Digs the headgear out of the Dvergr NPC prefab. Resolved once and remembered, including
/// the failure, so a missing prefab cannot turn into a per-frame log.
/// </summary>
private static GameObject ResolveHoodSource()
private static HoodSource ResolveHoodSource()
{
if (hoodSourceResolved) return cachedHoodSource;
hoodSourceResolved = true;
GameObject dverger = PrefabManager.Cache.GetPrefab<GameObject>(DvergurConfig.DvergerPrefabName);
if (dverger == null)
// A hand-pinned prefab and index wins outright, for when neither name search finds it.
if (!string.IsNullOrEmpty(DvergurConfig.HoodForcedPrefab) && DvergurConfig.HoodForcedSubmeshIndex >= 0)
{
Jotunn.Logger.LogWarning($"[Dvergur] Prefab '{DvergurConfig.DvergerPrefabName}' not found; no hood.");
return null;
}
foreach (Renderer renderer in dverger.GetComponentsInChildren<Renderer>(true))
{
string name = renderer.gameObject.name.ToLower();
foreach (string keyword in DvergurConfig.HoodRendererNames)
GameObject forced = PrefabManager.Cache.GetPrefab<GameObject>(DvergurConfig.HoodForcedPrefab);
SkinnedMeshRenderer forcedRenderer = forced != null ? forced.GetComponentInChildren<SkinnedMeshRenderer>(true) : null;
if (forcedRenderer != null)
{
if (!name.Contains(keyword)) continue;
Jotunn.Logger.LogInfo($"[Dvergur] Hood resolved to '{renderer.gameObject.name}' ({renderer.GetType().Name}).");
cachedHoodSource = renderer.gameObject;
Jotunn.Logger.LogInfo($"[Dvergur] Hood pinned to '{DvergurConfig.HoodForcedPrefab}' submesh {DvergurConfig.HoodForcedSubmeshIndex}.");
cachedHoodSource = HoodSource.FromSubmesh(forcedRenderer, DvergurConfig.HoodForcedSubmeshIndex);
return cachedHoodSource;
}
}
// Nothing matched, so say exactly what was on offer - that turns a silent invisible
// hood into a one-line fix in DvergurConfig.HoodRendererNames.
System.Text.StringBuilder sb = new System.Text.StringBuilder();
foreach (Renderer renderer in dverger.GetComponentsInChildren<Renderer>(true))
System.Text.StringBuilder report = new System.Text.StringBuilder();
foreach (string prefabName in DvergurConfig.DvergerPrefabCandidates)
{
sb.Append(renderer.gameObject.name).Append(" (").Append(renderer.GetType().Name).Append("), ");
GameObject prefab = PrefabManager.Cache.GetPrefab<GameObject>(prefabName);
if (prefab == null) continue;
// First choice: the hood is its own object.
foreach (Renderer renderer in prefab.GetComponentsInChildren<Renderer>(true))
{
if (!MatchesAny(renderer.gameObject.name, DvergurConfig.HoodRendererNames)) continue;
Jotunn.Logger.LogInfo($"[Dvergur] Hood resolved to object '{renderer.gameObject.name}' in '{prefabName}'.");
cachedHoodSource = HoodSource.FromObject(renderer.gameObject);
return cachedHoodSource;
}
// Second choice: it is a submesh of a combined mesh, identified by its material.
foreach (SkinnedMeshRenderer smr in prefab.GetComponentsInChildren<SkinnedMeshRenderer>(true))
{
Material[] materials = smr.sharedMaterials;
for (int i = 0; i < materials.Length; i++)
{
if (materials[i] == null || !MatchesAny(materials[i].name, DvergurConfig.HoodMaterialNames)) continue;
Jotunn.Logger.LogInfo($"[Dvergur] Hood resolved to submesh {i} ('{materials[i].name}') of '{smr.name}' in '{prefabName}'.");
cachedHoodSource = HoodSource.FromSubmesh(smr, i);
return cachedHoodSource;
}
// Nothing matched here, so record what this renderer actually offers.
report.Append($"\n {prefabName}/{smr.name}: submeshes={smr.sharedMesh?.subMeshCount ?? 0} materials=[");
for (int i = 0; i < materials.Length; i++)
{
report.Append(i).Append(':').Append(materials[i] != null ? materials[i].name : "null").Append(' ');
}
report.Append(']');
}
}
// Say exactly what was on offer: that turns a silently invisible hood into a one-line
// fix in DvergurConfig, either a new keyword or a pinned submesh index.
Jotunn.Logger.LogWarning(
$"[Dvergur] No renderer in '{DvergurConfig.DvergerPrefabName}' matched " +
$"[{string.Join(", ", DvergurConfig.HoodRendererNames)}]. Available: {sb}");
return null;
$"[Dvergur] No hood found. Object names tried [{string.Join(", ", DvergurConfig.HoodRendererNames)}], " +
$"material names tried [{string.Join(", ", DvergurConfig.HoodMaterialNames)}]." +
$" Candidates:{report}");
return HoodSource.None;
}
/// <summary>Where the hood mesh comes from: a whole object, or one submesh of a shared mesh.</summary>
private struct HoodSource
{
public GameObject Separate;
public SkinnedMeshRenderer Skinned;
public int SubmeshIndex;
public bool Valid => Separate != null || (Skinned != null && SubmeshIndex >= 0);
public static HoodSource None => new HoodSource { SubmeshIndex = -1 };
public static HoodSource FromObject(GameObject obj) =>
new HoodSource { Separate = obj, SubmeshIndex = -1 };
public static HoodSource FromSubmesh(SkinnedMeshRenderer renderer, int index) =>
new HoodSource { Skinned = renderer, SubmeshIndex = index };
}
private static bool MatchesAny(string name, string[] keywords)
{
if (string.IsNullOrEmpty(name)) return false;
string lower = name.ToLower();
foreach (string keyword in keywords)
{
if (lower.Contains(keyword)) return true;
}
return false;
}
private static void RemoveHood(VisEquipment visEq)