The female body maps the painted eyes about 6 mm lower and a quarter closer together than the male one (read from bodymale/bodyfem and the skin UVs), so every race's male-tuned eyes sat on the female brow. PlayerFace moves them for the Dvergar, Aswid, Sverm and Alfar. Dvergar eyes shrink to an 18 mm radius. The Aswid's borrowed sockets are halved before the config multiplier and the smoke is off by default. Alfar eyes become slanted, wrapped black almonds with a wet sheen. They are placed in fixed head-local units: the live lossyScale under the non-uniform Alfar body drifted as the head turned, and the 0.5 s cosmetic pass made the eyes trail the face.
753 lines
36 KiB
C#
753 lines
36 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)
|
|
{
|
|
// See AswidVisuals.ApplyEyes for the full reasoning - BuildEyes takes a one-time
|
|
// reading of the head bone's pose to work out which way the skull faces, and
|
|
// caches it for as long as the eyes exist. Sitting, attached, mid-attack or asleep,
|
|
// the head can be turned away from the body's own forward at that instant, which is
|
|
// how the snap-to-axis picked the wrong side and left the eyes behind the skull.
|
|
if (player.IsAttached() || player.IsAttachedToShip() || player.InAttack() || player.IsSleeping())
|
|
{
|
|
return;
|
|
}
|
|
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)));
|
|
Color glow = setup != null && setup.m_setEmissiveColor
|
|
? setup.m_emissiveColor
|
|
: DvergarConfig.BaseEyeColor;
|
|
|
|
// Dimmed on the way out. Alpha is left alone - it is not part of the brightness.
|
|
float strength = DvergarConfig.EyeGlowStrength;
|
|
return new Color(glow.r * strength, glow.g * strength, glow.b * strength, glow.a);
|
|
}
|
|
|
|
/// <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);
|
|
|
|
float height = DvergarConfig.EyeHeight;
|
|
float separation = DvergarConfig.EyeSeparation;
|
|
float eyeSize = DvergarConfig.EyeSize;
|
|
PlayerFace.AdjustEyes(player, ref height, ref separation, ref eyeSize);
|
|
|
|
Vector3 baseLocal = localForward * (DvergarConfig.EyeForward * raceScale * toLocal)
|
|
+ localUp * (height * raceScale * toLocal);
|
|
|
|
float eyeLocalSize = eyeSize * raceScale * toLocal;
|
|
|
|
for (int i = 0; i < holder.childCount; i++)
|
|
{
|
|
Transform eye = holder.GetChild(i);
|
|
|
|
// Index 0 is offset against the right axis, so it is the model's left eye - the
|
|
// one on your right as you face it. It gets its own size, because the face is
|
|
// curved and the two sides do not present the same surface to a ball of this
|
|
// radius.
|
|
float side = i == 0 ? -1f : 1f;
|
|
float size = i == 0 ? eyeLocalSize * DvergarConfig.LeftEyeSizeMultiplier : eyeLocalSize;
|
|
|
|
eye.localPosition = baseLocal + localRight * (side * separation * raceScale * toLocal);
|
|
eye.localScale = Vector3.one * size;
|
|
}
|
|
}
|
|
|
|
|
|
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;
|
|
|
|
// Which way the rig faces, rounded to the skull's own square axes - and taken from the
|
|
// BIND POSE rather than from whatever pose the head holds on this frame. See
|
|
// RigBindPose: read live, the rounding lands on the neighbouring axis whenever the head
|
|
// is caught mid-turn, and a race change rebuilds at exactly such a moment. That is why
|
|
// a Dvergar could come out of a reset with its eyes misplaced and be right again after
|
|
// a logout - the logout was simply a rebuild at a calmer moment, not a fix.
|
|
EyeFrame frame = holder.AddComponent<EyeFrame>();
|
|
RigBindPose.MeasureHeadFrame(player, headBone, "Dvergar",
|
|
out frame.LocalForward, out frame.LocalUp, out frame.LocalRight);
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|