RacesOfValheim/JotunnModStub/Dvergar/DvergarVisuals.cs
kanym bd27bd8fd4 chore(dvergar): retire the eye trace and the shader survey
Both were built to answer questions and both answered them: the trace found the camera anchor sitting half a metre above the head bone, the counter-rotating axes, and the tilt that put the eyes at the jaw; the survey established that Custom/Player carries no desaturation control and never will make a pale Dvergar.

Neither belongs in a session log now that the answers are known, so the trace goes and the survey's finding stays as the comment that stops anyone re-deriving it. The one-line reports that remain are the ones a game update could invalidate - which glow shader resolved, and the star offsets read off the creature prefab.
2026-08-05 21:44:50 +02:00

740 lines
35 KiB
C#

using HarmonyLib;
using Jotunn.Managers;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// The Dvergar's looks: a short body, dvergr skin, and a hood that is always worn.
///
/// The hood is a pure cosmetic override, not an equipment lock. The helmet slot stays free and
/// whatever the player equips keeps every one of its stats - only its mesh is swapped out, so
/// armour, resistances and set bonuses all still count.
///
/// Everything here runs for local and remote players alike, which is why it takes a Player
/// rather than reading Player.m_localPlayer.
/// </summary>
public static class DvergarVisuals
{
private const string HoodName = "DvergarHood";
// The source is looked up once per session; the search walks a whole creature prefab and
// would otherwise run again for every player that comes into view. The failure is cached
// too, so a missing prefab cannot turn into a per-frame log.
private static GameObject cachedVisual;
private static bool visualResolved;
/// <summary>
/// Reads the race off the ZDO so remote players render correctly, falling back to
/// m_customData for the main-menu preview which has no ZNetView.
/// </summary>
public static string GetPlayerRace(Player player)
{
if (player == null) return "Human";
ZNetView nview = player.GetComponent<ZNetView>();
if (nview != null && nview.IsValid())
{
return nview.GetZDO().GetString("RacesOfValheim_Race", "Human");
}
if (player.m_customData != null && player.m_customData.TryGetValue("Race", out string race))
{
return race;
}
return "Human";
}
public static bool IsDvergarPlayer(Player player) => GetPlayerRace(player) == DvergarConfig.RaceId;
// ─── Star colours ────────────────────────────────────────────────────
// Read once per session, failure included.
private static LevelEffects.LevelSetup[] cachedStarSetups;
private static bool starSetupsResolved;
/// <summary>
/// How many stars the Dvergar's colouring has earned: one at Bonemass, two at Fader.
/// </summary>
public static int GetStarTier(int state)
{
if (state >= DvergarConfig.TwoStarState) return 2;
if (state >= DvergarConfig.OneStarState) return 1;
return 0;
}
/// <summary>
/// The skin tint for a player at their current standing: the race's own slate blue-grey,
/// shifted by the hue/saturation/value offsets a real dverger of that star count wears.
///
/// Valheim does not give a starred creature a different model or a different colour - it
/// gives the same material an HSV offset through LevelEffects. Reading those offsets off
/// the creature prefab rather than picking two colours by eye means the tiers land on the
/// exact tints the game uses, and keeps following them if the prefab ever changes.
/// </summary>
public static Color GetSkinColor(Player player)
{
int tier = GetStarTier(GetProgressionState(player));
// Two stars stops deriving and states a colour outright. The creature's own two-star
// offset brightens and desaturates, which through a multiplier over the human skin
// texture means "tint it less" - and landed the tier a shade away from ordinary
// flesh, which is the opposite of what two stars should read as. Stone grey says it
// in the one language a multiplier speaks.
if (tier >= 2) return DvergarConfig.TwoStarSkinColor;
LevelEffects.LevelSetup setup = GetStarSetup(tier);
if (setup == null) return DvergarConfig.SkinColor;
return ShiftHsv(DvergarConfig.SkinColor, setup.m_hue, setup.m_saturation, setup.m_value);
}
/// <summary>
/// The tier this particular Dvergar should be coloured for. DvergarRace publishes it to
/// the ZDO every frame, so a remote player is shown at their own standing rather than the
/// observer's - which matters the moment anyone runs personal progression. Falls back to
/// this client's own reckoning when there is no ZDO, which is the main-menu preview.
/// </summary>
private static int GetProgressionState(Player player)
{
ZNetView nview = player != null ? player.GetComponent<ZNetView>() : null;
if (nview != null && nview.IsValid())
{
int published = nview.GetZDO().GetInt(DvergarConfig.StateZdoKey, 0);
if (published > 0) return published;
}
return BossProgressionManager.GetCurrentProgressionState();
}
// ─── Glowing eyes ────────────────────────────────────────────────────
private const string EyesName = "DvergarEyes";
/// <summary>
/// The skull's own idea of forward, up and right, measured once while the head is still
/// looking where the body is. Kept on the eye holder so it survives as long as the eyes
/// do, and so nothing is tempted to work it out again from a rig that has since moved.
/// </summary>
private class EyeFrame : MonoBehaviour
{
public Vector3 LocalForward = Vector3.forward;
public Vector3 LocalUp = Vector3.up;
public Vector3 LocalRight = Vector3.right;
}
private static Shader cachedGlowShader;
private static bool glowShaderResolved;
/// <summary>
/// Keeps two small emissive quads sitting over the player's painted-on eyes, coloured by
/// star tier. Safe to call for anyone: it removes them again from whoever is not a living
/// Dvergar. Call it every frame - it builds once and then only follows the head.
///
/// The holder hangs off the player root, which is unscaled, and is placed onto the head
/// bone in world space each frame. That is deliberate. Parenting straight to the head
/// bone would drag in the 100x scale the armature is authored at, and parenting to
/// Character.m_eye - the first attempt - put them outside the scaled rig entirely, which
/// is why they floated above a shrunken Dvergar and turned with the camera instead of the
/// face. Reading the bone's position and the player's facing sidesteps both.
/// </summary>
public static void ApplyEyes(Player player)
{
if (player == null) return;
Transform headBone = FindHeadBone(player);
if (headBone == null) return; // rig not up yet; try again next frame
Transform eyes = headBone.Find(EyesName);
if (!IsDvergarPlayer(player) || player.IsDead())
{
if (eyes != null)
{
// Renamed first: Destroy is deferred to the end of the frame, and every call
// until then would otherwise find it again.
eyes.name = EyesName + "_Removed";
Object.Destroy(eyes.gameObject);
}
return;
}
if (eyes == null) eyes = BuildEyes(player, headBone);
if (eyes == null) return; // already logged once by the resolver
PlaceEyes(player, headBone, eyes);
Color glow = GetEyeColor(player);
foreach (Renderer renderer in eyes.GetComponentsInChildren<Renderer>(true))
{
Material material = renderer.material;
if (material == null) continue;
material.color = glow;
if (material.HasProperty("_EmissionColor")) material.SetColor("_EmissionColor", glow);
}
}
/// <summary>
/// The head bone the body mesh is actually skinned to.
///
/// Not the Animator's. Asking the avatar for HumanBodyBones.Head returned a transform that
/// moves with the player but is not the one the head animation drives - which is why the
/// eyes tracked the body faithfully and ignored every idle bob of the head while being
/// parented to it, a thing a child transform cannot otherwise do. The rest of this mod has
/// always taken the head off VisEquipment.m_bodyModel.bones, the array the skinned mesh
/// deforms with, and that is the rig that moves.
/// </summary>
private static Transform FindHeadBone(Player player)
{
VisEquipment visEq = player.GetComponent<VisEquipment>();
if (visEq != null && visEq.m_bodyModel != null && visEq.m_bodyModel.bones != null)
{
Transform bone = FindBoneByName(visEq.m_bodyModel.bones, DvergarConfig.PlayerHeadBoneName);
if (bone != null) return bone;
}
// Last resort, and only so that something renders if the body model is not up yet.
Animator animator = player.GetComponentInChildren<Animator>();
return animator != null ? animator.GetBoneTransform(HumanBodyBones.Head) : null;
}
/// <summary>The scale the race is currently rendering its body at; 1 for anyone not resized.</summary>
private static float GetVisualScale(Player player)
{
GameObject visual = Traverse.Create(player).Field("m_visual").GetValue<GameObject>();
return visual != null ? visual.transform.localScale.x : 1f;
}
/// <summary>
/// One star and two stars use the emissive colours the game gives a starred dverger, read
/// off the same LevelSetup list the skin tint comes from. Only the base tier is ours.
/// </summary>
private static Color GetEyeColor(Player player)
{
LevelEffects.LevelSetup setup = GetStarSetup(GetStarTier(GetProgressionState(player)));
if (setup != null && setup.m_setEmissiveColor) return setup.m_emissiveColor;
return DvergarConfig.BaseEyeColor;
}
/// <summary>
/// Puts the two eyes where the face is, in the head bone's own coordinates, every frame.
///
/// The placement is measured rather than guessed. Character.m_eye is the game's own answer
/// to "where are this player's eyes", and asking the head bone to express that point in
/// its local space gives an offset that is correct by construction - no working out which
/// way the bone points, no hand-picked distance from the base of the skull. Being local,
/// it then rides every head animation for free.
///
/// The config offsets stay, as small adjustments in metres on top of that measurement.
/// </summary>
private static void PlaceEyes(Player player, Transform headBone, Transform holder)
{
float lossy = headBone.lossyScale.x;
if (Mathf.Abs(lossy) < 0.0001f) return;
Transform root = player.transform;
// Metres -> the head bone's local units, which the armature authors at roughly 100x.
float toLocal = 1f / lossy;
// Read back, never recomputed. Deriving these from the player root every frame is
// what kept the eyes from turning with the head: as the head rotates,
// InverseTransformDirection returns a direction rotated by exactly the opposite
// amount, so the offset counter-rotated and cancelled the head's own movement out.
// The eyes moved with the head and never turned with it, which is precisely what it
// looked like. Measured once at build time, they are fixed in the skull's frame and
// ride every animation for free.
EyeFrame frame = holder.GetComponent<EyeFrame>();
if (frame == null) return;
Vector3 localForward = frame.LocalForward;
Vector3 localUp = frame.LocalUp;
Vector3 localRight = frame.LocalRight;
// Measured from the head bone itself, and from nothing else.
//
// The previous version started from Character.m_eye, on the reasoning that it is the
// game's own answer to where a player's eyes are. It is not - it is where the camera
// goes, and the trace showed it sitting 0.51m straight above the head bone. That half
// metre was the entire drift: the offsets below are under a centimetre in local units
// and never stood a chance of mattering next to it.
float raceScale = GetVisualScale(player);
Vector3 baseLocal = localForward * (DvergarConfig.EyeForward * raceScale * toLocal)
+ localUp * (DvergarConfig.EyeHeight * raceScale * toLocal);
float eyeLocalSize = DvergarConfig.EyeSize * raceScale * toLocal;
for (int i = 0; i < holder.childCount; i++)
{
Transform eye = holder.GetChild(i);
float side = i == 0 ? -1f : 1f;
eye.localPosition = baseLocal + localRight * (side * DvergarConfig.EyeSeparation * raceScale * toLocal);
eye.localScale = Vector3.one * eyeLocalSize;
}
}
/// <summary>
/// Rounds a direction to the nearest of the six axis directions. Whichever component is
/// largest wins, sign included.
/// </summary>
private static Vector3 SnapToAxis(Vector3 direction)
{
float x = Mathf.Abs(direction.x);
float y = Mathf.Abs(direction.y);
float z = Mathf.Abs(direction.z);
if (x >= y && x >= z) return new Vector3(Mathf.Sign(direction.x), 0f, 0f);
if (y >= z) return new Vector3(0f, Mathf.Sign(direction.y), 0f);
return new Vector3(0f, 0f, Mathf.Sign(direction.z));
}
private static Transform BuildEyes(Player player, Transform headBone)
{
Shader glow = ResolveGlowShader();
if (glow == null) return null;
// Straight onto the head bone, with no rotation of its own: everything underneath is
// expressed in the bone's own local space by PlaceEyes, so position and rotation are
// inherited from the skull rather than recomputed against the body.
GameObject holder = new GameObject(EyesName);
holder.transform.SetParent(headBone, false);
holder.transform.localPosition = Vector3.zero;
holder.transform.localRotation = Quaternion.identity;
holder.transform.localScale = Vector3.one;
// Ask the rig which way it faces, once - and then round the answer to the skull's own
// axes. The raw measurement is taken at whatever pose the head happens to be in on
// this frame, so it arrives tilted: a "forward" leaning 20 degrees down put the eyes
// at the jaw instead of the eye line. A bone's real axes are square, and the tilt is
// nothing but the pose at the moment of asking, so it is rounded away.
Transform root = player.transform;
EyeFrame frame = holder.AddComponent<EyeFrame>();
frame.LocalForward = SnapToAxis(headBone.InverseTransformDirection(root.forward));
frame.LocalUp = SnapToAxis(headBone.InverseTransformDirection(root.up));
frame.LocalRight = SnapToAxis(headBone.InverseTransformDirection(root.right));
for (int i = 0; i < 2; i++)
{
float side = i == 0 ? -1f : 1f;
// Spheres, not quads. A quad has no thickness: seen edge-on it is a line and the
// eyes vanish, which is why they came and went with the camera angle. A sphere
// reads the same from every direction and is properly hidden by the skull when
// the head is between it and the camera.
GameObject eye = GameObject.CreatePrimitive(PrimitiveType.Sphere);
eye.name = "Eye" + i;
// A primitive comes with a collider, which on a player's face would be its own
// kind of bug.
foreach (Collider collider in eye.GetComponents<Collider>())
{
Object.Destroy(collider);
}
// Position and size are PlaceEyes' business, and it runs immediately after this.
eye.transform.SetParent(holder.transform, false);
eye.transform.localPosition = Vector3.zero;
eye.transform.localRotation = Quaternion.identity;
eye.transform.localScale = Vector3.zero;
Renderer renderer = eye.GetComponent<Renderer>();
renderer.material = new Material(glow);
renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
renderer.receiveShadows = false;
}
return holder.transform;
}
/// <summary>
/// Finds a shader that will render a flat colour past 1 so the bloom pass picks it up.
/// Unity strips shaders nothing references, so this asks for several and reports which one
/// the game actually shipped rather than assuming.
///
/// Opaque first, deliberately. The first version took Sprites/Default, which is a
/// transparent shader with depth writing switched off - so the eyes drew over the head
/// from angles that should have hidden them, and were visible from behind because it also
/// disables backface culling. An unlit opaque shader is occluded by the skull like any
/// other solid thing, which is the whole point of putting them in the face.
/// </summary>
private static Shader ResolveGlowShader()
{
if (glowShaderResolved) return cachedGlowShader;
glowShaderResolved = true;
string[] candidates = { "Unlit/Color", "Standard", "Particles/Standard Unlit", "Sprites/Default", "UI/Default" };
foreach (string name in candidates)
{
Shader shader = Shader.Find(name);
if (shader == null) continue;
Jotunn.Logger.LogInfo($"[Dvergar] Eye glow shader resolved to '{name}'.");
cachedGlowShader = shader;
return cachedGlowShader;
}
Jotunn.Logger.LogWarning(
"[Dvergar] No glow shader resolved (" + string.Join(", ", candidates) + "); eyes stay unlit.");
return null;
}
// ─── Shader survey ───────────────────────────────────────────────────
// What the player's body material can be asked to do, surveyed once and recorded here
// rather than logged every session:
//
// Custom/Player, 13 properties, of which exactly one is a colour - _SkinColor.
// No _Hue, no _Saturation, no _Value, no _Brightness, no _Grayscale.
//
// Which settles why a pale Dvergar is out of reach, and settles it as a property of the
// shader rather than of the numbers anyone picks. A real dverger goes pale at two stars
// through saturation -1 on the creature shader, which genuinely desaturates its texture.
// The player body has no such control: _SkinColor multiplies the human skin map, and a
// multiply can darken or bias but never desaturate - the pink is in the texture and
// survives being multiplied by grey. White is the multiplier's identity, so "paler" and
// "more human" are the same direction, which is what every attempt walked into.
//
// Getting there would mean replacing _MainTex with a desaturated copy of the skin texture,
// a per-player blit through a custom shader. Disproportionate for a cosmetic tier.
private static LevelEffects.LevelSetup GetStarSetup(int tier)
{
if (tier <= 0) return null;
LevelEffects.LevelSetup[] setups = ResolveStarSetups();
if (setups == null || setups.Length == 0) return null;
// m_levelSetups[0] is one star, [1] is two - the game indexes it as level - 2.
int index = Mathf.Min(tier - 1, setups.Length - 1);
return setups[index];
}
private static LevelEffects.LevelSetup[] ResolveStarSetups()
{
if (starSetupsResolved) return cachedStarSetups;
starSetupsResolved = true;
GameObject prefab = PrefabManager.Cache.GetPrefab<GameObject>(DvergarConfig.DvergerPrefabName);
LevelEffects effects = prefab != null ? prefab.GetComponentInChildren<LevelEffects>(true) : null;
if (effects == null || effects.m_levelSetups == null || effects.m_levelSetups.Count == 0)
{
Jotunn.Logger.LogWarning(
$"[Dvergar] No LevelEffects setups on '{DvergarConfig.DvergerPrefabName}'; " +
"star colouring stays at the base tint.");
return null;
}
cachedStarSetups = effects.m_levelSetups.ToArray();
// The offsets themselves, so a tier that lands on the wrong colour can be tuned
// against the real numbers rather than by eye.
for (int i = 0; i < cachedStarSetups.Length; i++)
{
LevelEffects.LevelSetup setup = cachedStarSetups[i];
Jotunn.Logger.LogInfo(
$"[Dvergar] Star {i + 1}: hue={setup.m_hue:F3} saturation={setup.m_saturation:F3} " +
$"value={setup.m_value:F3} emissive={(setup.m_setEmissiveColor ? setup.m_emissiveColor.ToString() : "none")} " +
$"-> skin {ShiftHsv(DvergarConfig.SkinColor, setup.m_hue, setup.m_saturation, setup.m_value)}");
}
return cachedStarSetups;
}
/// <summary>
/// Applies a star's HSV offset to our tint. Hue wraps the way the creature shader's does;
/// saturation and value are bounded rather than merely clamped to 0..1.
///
/// The bounds are the whole trick. The shader applies these offsets to a dverger's own
/// texture, where a bright desaturated result is a pale dverger. Ours multiplies the human
/// skin texture, where the same result is *white* - and a white multiplier is no tint at
/// all, which is why the two-star Dvergar came out looking like an ordinary pink human.
/// Keeping saturation off the floor and value off the ceiling means every tier stays a
/// colour.
/// </summary>
private static Color ShiftHsv(Color color, float hue, float saturation, float value)
{
Color.RGBToHSV(color, out float h, out float s, out float v);
h = Mathf.Repeat(h + hue, 1f);
s = Mathf.Clamp(s + saturation, DvergarConfig.StarMinSaturation, 1f);
v = Mathf.Clamp(v + value, DvergarConfig.StarMinValue, DvergarConfig.StarMaxValue);
Color shifted = Color.HSVToRGB(h, s, v);
shifted.a = color.a;
return shifted;
}
// ─── Scale ───────────────────────────────────────────────────────────
/// <summary>
/// Sizes a player, driven from a Player.Update postfix exactly the way the Trol is - which
/// is the arrangement that actually holds. Doing it from the plugin's own MonoBehaviour
/// left the scale in a fight it could not win: Trol's Player.Update postfix resets every
/// non-Trol player's visual to 1 on the same frame, and whichever ran last won.
/// </summary>
public static void ApplyScale(Player player, bool isDvergar)
{
if (player == null) return;
// The "Visual" child, never the root: the root carries the collider and the camera
// pivot, and shrinking those drops the player through the ground they stand on.
GameObject visual = Traverse.Create(player).Field("m_visual").GetValue<GameObject>();
if (visual == null) return;
if (isDvergar)
{
float target = DvergarConfig.VisualScale;
if (Mathf.Abs(visual.transform.localScale.x - target) > 0.001f)
{
visual.transform.localScale = new Vector3(target, target, target);
}
}
else if (Mathf.Abs(visual.transform.localScale.x - DvergarConfig.VisualScale) < 0.001f)
{
// Only ever undo our own scale - another race may legitimately be sizing this player.
visual.transform.localScale = Vector3.one;
}
}
// ─── Hood ────────────────────────────────────────────────────────────
/// <summary>
/// Keeps the hood and the hidden helmet in step. Safe to call every frame: each step
/// checks the current value first and does nothing when it already matches.
/// </summary>
public static void ApplyHood(Player player)
{
VisEquipment visEq = player != null ? player.GetComponent<VisEquipment>() : null;
if (visEq == null) return;
if (IsDvergarPlayer(player) && !player.IsDead())
{
EnsureHood(visEq);
HideEquippedHelmet(visEq);
}
else
{
RemoveHood(visEq);
}
}
/// <summary>
/// Blanks the mesh of whatever helmet is equipped. Scaled to zero rather than deactivated
/// because Valheim re-enables the instance whenever it refreshes visuals, and this is the
/// approach the Skeleton already proved out.
/// </summary>
private static void HideEquippedHelmet(VisEquipment visEq)
{
GameObject helmet = Traverse.Create(visEq).Field<GameObject>("m_helmetItemInstance").Value;
if (helmet != null && helmet.transform.localScale != Vector3.zero)
{
helmet.transform.localScale = Vector3.zero;
}
}
/// <summary>
/// Hangs the dvergr hood on the player's head.
///
/// The Dvergr ships as a single renderer whose mesh has Read/Write disabled - it reports
/// zero triangles - so the hood cannot be carved out of it as a submesh, which is what the
/// previous two attempts tried in one form or another. What the prefab does give us is a
/// hat1/hat2/hat3 bone chain that nothing but the hood is skinned to.
///
/// So the whole dvergr body is instantiated and then made to disappear: the hat chain is
/// detached from the skull, and the armature root is collapsed to zero scale, which drags
/// every vertex weighted to it into a single point. Only the hood is left standing, and it
/// is still skinned, so it keeps its own shape.
/// </summary>
private static void EnsureHood(VisEquipment visEq)
{
if (visEq.m_bodyModel == null || visEq.m_bodyModel.bones == null) return;
Transform playerHead = FindBoneByName(visEq.m_bodyModel.bones, DvergarConfig.PlayerHeadBoneName);
if (playerHead == null) return;
if (playerHead.Find(HoodName) != null) return; // already wearing it
GameObject sourceVisual = ResolveDvergerVisual();
if (sourceVisual == null) return; // already logged once by the resolver
bool wasActive = sourceVisual.activeSelf;
sourceVisual.SetActive(false);
GameObject hood = Object.Instantiate(sourceVisual, playerHead, false);
sourceVisual.SetActive(wasActive);
hood.name = HoodName;
StripComponents(hood);
hood.SetActive(true);
Transform hatBone = FindChildByName(hood.transform, DvergarConfig.HoodBoneName);
Transform bodyRoot = FindChildByName(hood.transform, DvergarConfig.BodyRootBoneName);
if (hatBone == null)
{
Jotunn.Logger.LogWarning(
$"[Dvergar] No '{DvergarConfig.HoodBoneName}' bone in the instantiated dvergr; hood dropped.");
Object.Destroy(hood);
return;
}
// Detached first: the hat chain hangs off the skull, so collapsing the body without
// this would collapse the hood along with it.
hatBone.SetParent(hood.transform, true);
if (bodyRoot != null) bodyRoot.localScale = Vector3.zero;
// Scale and rotation before alignment, since both move the hat bone.
hood.transform.localRotation = Quaternion.Euler(DvergarConfig.HoodOffsetRotation);
hood.transform.localScale = Vector3.one * DvergarConfig.HoodExtraScale;
// The hat now sits wherever the dvergr's own skull was. Shifting the whole object by
// the gap between that and the player's head bone lands it correctly without a single
// hand-measured offset.
hood.transform.position += playerHead.position - hatBone.position;
hood.transform.localPosition += DvergarConfig.HoodOffsetPosition;
foreach (SkinnedMeshRenderer renderer in hood.GetComponentsInChildren<SkinnedMeshRenderer>(true))
{
// The collapsed bones leave the mesh's own bounds meaningless, and a skinned
// renderer culls against those - without this the hood vanishes at some angles.
renderer.updateWhenOffscreen = true;
}
ApplyDitherShader(hood);
}
/// <summary>
/// Strips everything that would make a decorative mesh behave like a creature: AI, hover
/// prompts and physics, plus the Animator and LODGroup, which are not MonoBehaviours and
/// would otherwise keep driving or hiding the rig.
/// </summary>
private static void StripComponents(GameObject obj)
{
foreach (MonoBehaviour comp in obj.GetComponentsInChildren<MonoBehaviour>(true))
{
Object.DestroyImmediate(comp);
}
foreach (Animator animator in obj.GetComponentsInChildren<Animator>(true))
{
Object.DestroyImmediate(animator);
}
foreach (LODGroup lod in obj.GetComponentsInChildren<LODGroup>(true))
{
Object.DestroyImmediate(lod);
}
foreach (Rigidbody body in obj.GetComponentsInChildren<Rigidbody>(true))
{
Object.DestroyImmediate(body);
}
foreach (Collider col in obj.GetComponentsInChildren<Collider>(true))
{
Object.DestroyImmediate(col);
}
}
/// <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;
}
}
private static GameObject ResolveDvergerVisual()
{
if (visualResolved) return cachedVisual;
visualResolved = true;
GameObject prefab = PrefabManager.Cache.GetPrefab<GameObject>(DvergarConfig.DvergerPrefabName);
if (prefab == null)
{
Jotunn.Logger.LogWarning($"[Dvergar] Prefab '{DvergarConfig.DvergerPrefabName}' not found; no hood.");
return null;
}
Transform visual = prefab.transform.Find(DvergarConfig.DvergerVisualName);
if (visual == null)
{
// Fall back to whatever holds the renderer, in case the child is ever renamed.
SkinnedMeshRenderer renderer = prefab.GetComponentInChildren<SkinnedMeshRenderer>(true);
visual = renderer != null ? renderer.transform.parent : null;
}
if (visual == null)
{
Jotunn.Logger.LogWarning(
$"[Dvergar] '{DvergarConfig.DvergerPrefabName}' has no '{DvergarConfig.DvergerVisualName}' child and no renderer; no hood.");
return null;
}
Jotunn.Logger.LogInfo($"[Dvergar] Hood source resolved to '{DvergarConfig.DvergerPrefabName}/{visual.name}'.");
cachedVisual = visual.gameObject;
return cachedVisual;
}
private static void RemoveHood(VisEquipment visEq)
{
if (visEq.m_bodyModel == null || visEq.m_bodyModel.bones == null) return;
Transform playerHead = FindBoneByName(visEq.m_bodyModel.bones, DvergarConfig.PlayerHeadBoneName);
Transform hood = playerHead != null ? playerHead.Find(HoodName) : null;
if (hood == null) return; // never was a Dvergar - leave the helmet alone
// Destroy is deferred to the end of the frame, so the object is renamed first: without
// that, every call until it actually goes away finds it again and re-runs the restore.
hood.name = HoodName + "_Removed";
Object.Destroy(hood.gameObject);
GameObject helmet = Traverse.Create(visEq).Field<GameObject>("m_helmetItemInstance").Value;
if (helmet != null && helmet.transform.localScale == Vector3.zero)
{
helmet.transform.localScale = Vector3.one;
}
}
// ─── Bone lookup ─────────────────────────────────────────────────────
private static Transform FindBoneByName(Transform[] bones, string targetBoneName)
{
if (bones == null || string.IsNullOrEmpty(targetBoneName)) return null;
foreach (Transform bone in bones)
{
if (bone != null && bone.name == targetBoneName) return bone;
}
string target = targetBoneName.ToLower();
foreach (Transform bone in bones)
{
if (bone == null) continue;
string name = bone.name.ToLower();
if (name == target || name.Contains(target) || target.Contains(name)) return bone;
}
return null;
}
/// <summary>Depth-first search by exact name; the dvergr rig nests bones many levels deep.</summary>
private static Transform FindChildByName(Transform root, string name)
{
if (root == null) return null;
if (root.name == name) return root;
for (int i = 0; i < root.childCount; i++)
{
Transform found = FindChildByName(root.GetChild(i), name);
if (found != null) return found;
}
return null;
}
}
}