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);