diff --git a/JotunnModStub/Dvergur/DvergurConfig.cs b/JotunnModStub/Dvergur/DvergurConfig.cs
index af26423..775b605 100644
--- a/JotunnModStub/Dvergur/DvergurConfig.cs
+++ b/JotunnModStub/Dvergur/DvergurConfig.cs
@@ -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;
diff --git a/JotunnModStub/Dvergur/DvergurVisuals.cs b/JotunnModStub/Dvergur/DvergurVisuals.cs
index d5c05ec..3110267 100644
--- a/JotunnModStub/Dvergur/DvergurVisuals.cs
+++ b/JotunnModStub/Dvergur/DvergurVisuals.cs
@@ -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;
///
@@ -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);
+ }
+
+ ///
+ /// 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.
+ ///
+ 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();
+ 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(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(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];
+ }
+
+ ///
+ /// Without the creature shader the hood ignores the camera's dither fade and fills the
+ /// screen in first person; its own textures are kept.
+ ///
+ private static void ApplyDitherShader(GameObject obj)
+ {
+ Shader dither = Shader.Find("Custom/Creature");
+ if (dither == null) return;
+
+ foreach (Renderer renderer in obj.GetComponentsInChildren(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.
///
- private static GameObject ResolveHoodSource()
+ private static HoodSource ResolveHoodSource()
{
if (hoodSourceResolved) return cachedHoodSource;
hoodSourceResolved = true;
- GameObject dverger = PrefabManager.Cache.GetPrefab(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(true))
- {
- string name = renderer.gameObject.name.ToLower();
- foreach (string keyword in DvergurConfig.HoodRendererNames)
+ GameObject forced = PrefabManager.Cache.GetPrefab(DvergurConfig.HoodForcedPrefab);
+ SkinnedMeshRenderer forcedRenderer = forced != null ? forced.GetComponentInChildren(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(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(prefabName);
+ if (prefab == null) continue;
+
+ // First choice: the hood is its own object.
+ foreach (Renderer renderer in prefab.GetComponentsInChildren(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(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;
+ }
+
+ /// Where the hood mesh comes from: a whole object, or one submesh of a shared mesh.
+ 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)
diff --git a/JotunnModStub/RacesOfValheim.cs b/JotunnModStub/RacesOfValheim.cs
index 95be5b1..600f3ea 100644
--- a/JotunnModStub/RacesOfValheim.cs
+++ b/JotunnModStub/RacesOfValheim.cs
@@ -795,10 +795,29 @@ namespace RacesOfValheim
Jotunn.Logger.LogInfo($"=== {prefabName} HIERARCHY ===");
DumpTransform(prefab.transform, "");
+ // Submeshes and their materials are the part that matters: the Dvergr carries its hood,
+ // body and clothes in one mesh, so the hood can only be picked out by submesh index.
Jotunn.Logger.LogInfo($"=== {prefabName} RENDERERS ===");
foreach (Renderer renderer in prefab.GetComponentsInChildren(true))
{
- Jotunn.Logger.LogInfo($" {renderer.gameObject.name} ({renderer.GetType().Name}) path={GetPath(renderer.transform)}");
+ Mesh mesh = null;
+ if (renderer is SkinnedMeshRenderer skinned) mesh = skinned.sharedMesh;
+ else
+ {
+ MeshFilter filter = renderer.GetComponent();
+ if (filter != null) mesh = filter.sharedMesh;
+ }
+
+ Jotunn.Logger.LogInfo(
+ $" {renderer.gameObject.name} ({renderer.GetType().Name}) " +
+ $"submeshes={(mesh != null ? mesh.subMeshCount : 0)} path={GetPath(renderer.transform)}");
+
+ Material[] materials = renderer.sharedMaterials;
+ for (int i = 0; i < materials.Length; i++)
+ {
+ int tris = (mesh != null && i < mesh.subMeshCount) ? mesh.GetTriangles(i).Length / 3 : 0;
+ Jotunn.Logger.LogInfo($" submesh {i}: material='{(materials[i] != null ? materials[i].name : "null")}' triangles={tris}");
+ }
}
LevelEffects levelEffects = prefab.GetComponentInChildren(true);