RacesOfValheim/JotunnModStub/Sverm/SvermVisuals.cs
kanym 026def2fde fix(eyes): female face placement, smaller Dvergar/Aswid eyes, grey Alfar eyes
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.
2026-10-27 15:01:44 +01:00

874 lines
42 KiB
C#

using System.Collections.Generic;
using HarmonyLib;
using Jotunn.Managers;
using UnityEngine;
namespace RacesOfValheim
{
/// <summary>
/// Everything a Sverm looks like, and every bit of it grown from vanilla assets.
///
/// THE TINT RAMP IS THE PROGRESSION. The carapace silhouette never changes - it is the
/// Mistlands carapace set at every tier, because the bronze set retinted brown is still bronze
/// in its SHAPE while the carapace is already modelled chitin. What changes is the colour, and
/// it tells the age of the animal: pale violet while the shell is still soft, full amber once
/// it has hardened, near black with a red burn at Fader. No new assets, and the character
/// matures on screen as it advances.
///
/// What gets mounted, all of it borrowed from vanilla:
/// the claws - the Chitin Claws, on both hands, always;
/// the spines - UndeadBjornRibcage worn spine-up, a static crest, from tier 5;
/// the eyes - two emissive spheres, the Aswid's geometry unchanged;
/// the motes - a firefly swarm under the body, only while falling;
/// the ember - emission written into the carapace materials at Fader.
///
/// Runs for local and remote players alike, which is why every entry point takes a Player
/// rather than reading Player.m_localPlayer: the race is on the ZDO, so each client can grow
/// the right body for everyone it can see.
/// </summary>
public static class SvermVisuals
{
private const string EyesName = "SvermEyes";
private const string ClawsName = "SvermClaw";
private const string SpinesName = "SvermSpines";
// The Aswid's tuning on this same rig, carried over unchanged. That is not laziness: the
// offsets live in the head bone's OWN local space, so the scale cancels and the same
// numbers land on the same part of the face at any size - which is also why Surrenal
// Glands' +10% at tier 7 needs no special case here.
private const float EyeSeparation = 0.032f;
private const float EyeForward = 0.081f;
private const float EyeHeight = 0.181f;
private const float EyeSize = 0.062f;
/// <summary>
/// 1, not the Dvergar's 0.85.
///
/// That 0.85 is a HUMAN face correction: a skull is not flat, so two eyes placed
/// symmetrically in bone space do not read as symmetrical, and the Dvergar shrinks one to
/// compensate. An insect's eyes are a matched pair and are supposed to look like one, so
/// the correction is not just unnecessary here - it is the defect. Both eyes take the
/// larger size.
/// </summary>
private const float LeftEyeSizeMultiplier = 1f;
private const string HeadBoneName = "Head";
private const string RightHandBoneName = "RightHand";
private const string LeftHandBoneName = "LeftHand";
// ─── Race check ──────────────────────────────────────────────────────
/// <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 but does have the saved
/// custom data. Same shape as SkeletonVisuals.GetPlayerRace.
/// </summary>
public static string GetPlayerRace(Player player)
{
if (player == null) return "Human";
ZNetView nview = player.GetComponent<ZNetView>();
if (nview != null && nview.IsValid())
{
string race = nview.GetZDO().GetString("RacesOfValheim_Race", "");
if (!string.IsNullOrEmpty(race)) return race;
}
if (player.m_customData != null && player.m_customData.TryGetValue("Race", out string custom))
{
return custom;
}
return "Human";
}
public static bool IsSvermPlayer(Player player) => GetPlayerRace(player) == SvermConfig.RaceId;
/// <summary>
/// The tier to render this player at.
///
/// For the local player that is simply the progression state. For a remote player the
/// local progression is the wrong answer - it is OUR tier, not theirs - so the ZDO is
/// asked first. Races that never wrote the key fall back to the local state, which is what
/// every other race in the mod already does and is right far more often than it is wrong.
/// </summary>
public static int GetRenderState(Player player)
{
if (player != null && player != Player.m_localPlayer)
{
ZNetView nview = player.GetComponent<ZNetView>();
if (nview != null && nview.IsValid())
{
int remote = nview.GetZDO().GetInt(SvermConfig.StateZdoKey, 0);
if (remote > 0) return Mathf.Clamp(remote, BossProgressionManager.MinState, BossProgressionManager.MaxState);
}
}
return BossProgressionManager.GetCurrentProgressionState();
}
public static Color GetSkinColor(Player player) => SvermConfig.SkinColor;
// ─── Scale ───────────────────────────────────────────────────────────
/// <summary>
/// Surrenal Glands: +10% from the Queen on.
///
/// The "Visual" child, never the root - the root carries the collider and the camera
/// pivot. Only ever undoes ITS OWN scale, because another race may legitimately be sizing
/// this player and RaceScale exists precisely so the two do not fight.
/// </summary>
public static void ApplyScale(Player player, bool isSverm)
{
if (player == null) return;
GameObject visual = Traverse.Create(player).Field("m_visual").GetValue<GameObject>();
if (visual == null) return;
float target = isSverm ? SvermProgression.GetRules(GetRenderState(player)).BodyScale : 1f;
if (!isSverm)
{
// Do not stamp on a Trol or a Furling: only reset a scale that looks like ours.
if (Mathf.Abs(visual.transform.localScale.x - SvermConfig.BodyScaleAtQueen) > 0.001f) return;
target = 1f;
}
if (Mathf.Abs(visual.transform.localScale.x - target) > 0.001f)
{
visual.transform.localScale = new Vector3(target, target, target);
}
}
// ─── Eyes ────────────────────────────────────────────────────────────
/// <summary>
/// Records which way the skull faces, worked out once when the eyes are built.
/// </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>
/// Two small emissive spheres burning over the painted-on eyes.
///
/// This is AswidVisuals.ApplyEyes ported across, not re-derived, and the first version of
/// this file paid for re-deriving it. Two things it was missing and both are fatal on
/// their own:
///
/// THE DIVIDE BY lossyScale. The player armature is authored at scale 100, so an offset
/// of 0.081 written straight into the head bone's local space puts the eye eight metres
/// in front of the face and eyeballs the size of a house. Everything here is expressed
/// in metres and converted with 1/lossyScale, which is what makes the constants mean
/// what they say.
///
/// THE SHADER. A primitive sphere arrives with whatever the default material is, and
/// Valheim's build has no reason to carry one that renders past 1 - so the sphere either
/// comes out flat pink or does not render at all. ResolveGlowShader picks one that will
/// take an HDR colour so the bloom pass has something to find.
/// </summary>
public static void ApplyEyes(Player player)
{
if (player == null) return;
Transform headBone = FindBone(player, HeadBoneName);
if (headBone == null) return; // rig not up yet; try again next frame
Transform eyes = headBone.Find(EyesName);
if (!IsSvermPlayer(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 / DvergarVisuals.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 has picked the wrong side and left
// eyes behind the skull before.
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 = SvermConfig.EyeColor * SvermConfig.EyeGlowStrength;
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);
// Custom/Creature is a LIT shader, unlike the Unlit/Color the first version
// resolved to. On a lit shader the glow comes from emission and emission is
// gated behind a keyword, so writing the colour without this leaves two dull
// grey beads.
material.EnableKeyword("_EMISSION");
}
}
}
/// <summary>
/// Puts the two eyes where the face is, in the head bone's own coordinates, every pass.
///
/// The scale term looks like it handles Surrenal Glands' +10% and it does not: lossyScale
/// already contains the player's scale, so the multiply and the divide cancel and the
/// local offset is simply config/100 at any size. Growth is handled by the parenting.
/// It is kept because it is honest about intent and because that is how the Aswid's
/// version reads.
/// </summary>
private static void PlaceEyes(Player player, Transform headBone, Transform holder)
{
float lossy = headBone.lossyScale.x;
if (Mathf.Abs(lossy) < 0.0001f) return;
float toLocal = 1f / lossy;
EyeFrame frame = holder.GetComponent<EyeFrame>();
if (frame == null) return;
float scale = player.transform.localScale.x;
float height = EyeHeight;
float separation = EyeSeparation;
float eyeSize = EyeSize;
PlayerFace.AdjustEyes(player, ref height, ref separation, ref eyeSize);
Vector3 baseLocal = frame.LocalForward * (EyeForward * scale * toLocal)
+ frame.LocalUp * (height * scale * toLocal);
float eyeLocalSize = eyeSize * scale * 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.
float side = i == 0 ? -1f : 1f;
float size = i == 0 ? eyeLocalSize * LeftEyeSizeMultiplier : eyeLocalSize;
eye.localPosition = baseLocal + frame.LocalRight * (side * separation * scale * toLocal);
eye.localScale = Vector3.one * size;
}
}
private static Transform BuildEyes(Player player, Transform headBone)
{
Shader glow = ResolveGlowShader();
if (glow == null) return null;
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 ROUND the answer to the skull's own axes.
// The raw, unrounded measurement puts the eyes on the jaw - DvergarVisuals found that
// out first.
//
// player.transform, NOT headBone.root - walking .root up from a bone in
// VisEquipment.m_bodyModel's own array does not reliably land back on the player, and
// gave a wrong answer on every single build rather than an occasional bad-timing one.
// DvergarVisuals.BuildEyes already reads player.transform directly; this now matches it.
// From the BIND POSE, not from this frame's animation - see RigBindPose. Read live, the
// snap-to-axis 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 freshly spawned Sverm
// could come up with its eyes off the face and be fine again after a relog.
EyeFrame frame = holder.AddComponent<EyeFrame>();
RigBindPose.MeasureHeadFrame(player, headBone, "Sverm",
out frame.LocalForward, out frame.LocalUp, out frame.LocalRight);
for (int i = 0; i < 2; i++)
{
// Spheres, not quads: a quad seen edge-on is a line and vanishes. A sphere reads
// the same from every direction and is properly hidden by the skull.
GameObject eye = GameObject.CreatePrimitive(PrimitiveType.Sphere);
eye.name = "Eye" + i;
foreach (Collider collider in eye.GetComponents<Collider>())
{
Object.Destroy(collider);
}
eye.transform.SetParent(holder.transform, false);
eye.transform.localPosition = Vector3.zero;
eye.transform.localRotation = Quaternion.identity;
eye.transform.localScale = Vector3.zero; // PlaceEyes runs immediately after this
Renderer renderer = eye.GetComponent<Renderer>();
renderer.material = new Material(glow);
renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
renderer.receiveShadows = false;
}
return holder.transform;
}
/// <summary>
/// A shader that will render a colour past 1 so the bloom pass picks it up, AND that fades
/// with the body.
///
/// CUSTOM/CREATURE FIRST, and that is the fix for the second inherited defect. Valheim
/// dithers the player away when the camera gets inside them, but the dither lives in the
/// game's own shaders - so eyes on Unlit/Color stayed solid while the face around them
/// dissolved, and two red dots hung in the air. FurlingPatches.cs:175 hit exactly this with
/// a borrowed trophy and answered it the same way: keep the material, change the shader to
/// one that knows about the camera.
///
/// The rest of the list is unchanged and still opaque-first: a transparent shader with
/// depth writing off draws over the head from angles that should hide it.
/// </summary>
private static Shader ResolveGlowShader()
{
if (glowShaderResolved) return cachedGlowShader;
glowShaderResolved = true;
string[] candidates = { "Custom/Creature", "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($"[Sverm] Eye glow shader resolved to '{name}'.");
cachedGlowShader = shader;
return cachedGlowShader;
}
Jotunn.Logger.LogWarning(
"[Sverm] No glow shader resolved (" + string.Join(", ", candidates) + "); eyes stay unlit.");
return null;
}
// ─── Claws ───────────────────────────────────────────────────────────
/// <summary>
/// RETIRED, and kept only to clean up after itself.
///
/// The claws used to be a model bolted to the hand bones, so they could stay on while the
/// player held something else. That worked, but it put the claws and the carapace on the
/// same losing footing: the game rebuilds equipment visuals from what is REALLY in the
/// slots, so anything faked has to be put back after every rebuild, one frame late and
/// visibly. They are a real equipped item now - see SvermClawSlot - and this walks both
/// hand bones removing any holder the old path left behind.
/// </summary>
public static void ApplyClaws(Player player)
{
if (player == null) return;
RemoveLegacyClaw(player, RightHandBoneName);
RemoveLegacyClaw(player, LeftHandBoneName);
}
private static void RemoveLegacyClaw(Player player, string boneName)
{
Transform bone = FindBone(player, boneName);
Transform existing = bone != null ? bone.Find(ClawsName) : null;
if (existing == null) return;
// Renamed first: Destroy is deferred to the end of the frame, and every call until
// then would otherwise find it again.
existing.name = ClawsName + "_Removed";
Object.Destroy(existing.gameObject);
}
// ─── Dorsal spines ───────────────────────────────────────────────────
/// <summary>
/// A ribcage worn spine-up: a ridge of bone standing out of the back, xenomorph rather
/// than bird.
///
/// This replaced wings, and the reason is worth keeping. Wing_gib was never a prefab - it
/// is a child buried in somebody's death effect, reachable only by walking a hierarchy and
/// guessing at the parent - and a wing that cannot flap is a prop no matter how well it is
/// placed. UndeadBjornRibcage resolves by name like any other prefab and is MEANT to be
/// still, so being static stops being a compromise and starts being the point.
///
/// Small at tier 5, full crest from the Queen on.
/// </summary>
public static void ApplySpines(Player player)
{
if (player == null) return;
// This bone or nothing. The fallback chain that used to be here degraded to "somewhere
// on the back, roughly", which is worthless for a crest whose angle was found by eye
// against one specific bone.
Transform bone = FindBone(player, SvermConfigManagement.Bone);
if (bone == null)
{
WarnMissingSpineBone(player);
return;
}
// Size is read from the .cfg here rather than off the cached rules struct: that cache
// is built per state on first use, so a size edited between two sessions would not be
// picked up until a relog. Which tier gets which size is still the rules' decision -
// only the two numbers are live.
int state = GetRenderState(player);
float wanted = 0f;
if (SvermConfigManagement.Spines && IsSvermPlayer(player) && !player.IsDead() && SvermProgression.GetRules(state).SpineSize > 0f)
{
wanted = state >= SvermConfig.FullWingspanState
? SvermConfigManagement.SizeFull
: SvermConfigManagement.SizeSmall;
}
Transform existing = bone.Find(SpinesName);
if (wanted <= 0f)
{
if (existing != null)
{
existing.name = SpinesName + "_Removed";
Object.Destroy(existing.gameObject);
}
return;
}
// ROTATION IS PART OF THE COMPARISON, not just size, and that is what makes the crest
// tunable while the game is running. ModelBorrow rotates the copy FIRST and then
// measures and grounds it, so the fit belongs to that rotation - turning an
// already-fitted model afterwards would leave it floating or buried. A rebuild is the
// only honest way to change the angle, and at 0.5 s a pass it is imperceptible.
//
// A size change needs a rebuild for the same reason: re-fitting an already-fitted copy
// compounds the two scales instead of replacing one with the other. The tag records
// metres and degrees - what was ASKED for - not bone-local numbers.
Quaternion wantedRotation = SvermConfigManagement.SpineRotation();
// Basing the whole crest AT the bone and growing it upward (ModelBorrow.Attach grounds
// a borrowed model's bottom at the mount point) reached up past the shoulders and onto
// the head once the crest got tall - Spine2's own local up axis runs toward the head,
// not out and away from the back. Centring it on the bone instead - half its height
// below the mount point, half above - keeps the same rotation an eye already approved
// while stopping the Full Crest size from overshooting. SpineOffsetY is an additional
// nudge along the same axis, for whatever still needs adjusting by eye.
float wantedOffsetY = -wanted / 2f + SvermConfigManagement.SpineOffset;
SvermSpineTag tag = existing != null ? existing.GetComponent<SvermSpineTag>() : null;
if (existing != null && (tag == null
|| !Mathf.Approximately(tag.Size, wanted)
|| !Mathf.Approximately(tag.OffsetY, wantedOffsetY)
|| Quaternion.Angle(tag.Rotation, wantedRotation) > 0.5f))
{
existing.name = SpinesName + "_Removed";
Object.Destroy(existing.gameObject);
existing = null;
}
if (existing == null)
{
// Same rig-scale conversion as the claws: metres in, bone units out.
float lossy = bone.lossyScale.x;
if (Mathf.Abs(lossy) < 0.0001f) return;
GameObject holder = ModelBorrow.Attach(
bone,
SpinesName,
SvermConfig.SpinesPrefab,
new Vector3(0f, wantedOffsetY / lossy, 0f),
wantedRotation,
wanted / lossy,
"Sverm");
if (holder == null) return;
SvermSpineTag built = holder.AddComponent<SvermSpineTag>();
built.Size = wanted;
built.Rotation = wantedRotation;
built.OffsetY = wantedOffsetY;
existing = holder.transform;
}
TintBorrowed(existing.gameObject, state);
}
private static bool warnedMissingSpineBone;
/// <summary>
/// Said once, not forty times a minute. The cosmetic pass runs on a timer, so an
/// unqualified LogWarning here would bury the log in the time it takes to read it.
/// </summary>
private static void WarnMissingSpineBone(Player player)
{
if (warnedMissingSpineBone) return;
warnedMissingSpineBone = true;
// The bone names are listed too, because the first time this fired the answer was that
// the rig simply has no Spine3 - it counts Spine, Spine1, Spine2 - and there was no
// way to know that from a warning that only said what was missing.
System.Text.StringBuilder spine = new System.Text.StringBuilder();
// Read off the player being dressed, not Player.m_localPlayer. On the main menu the one
// being dressed is the character preview and m_localPlayer is still null, so the old read
// answered "none found" about a rig that has three spine bones.
VisEquipment visEq = player != null ? player.GetComponent<VisEquipment>() : null;
if (visEq != null && visEq.m_bodyModel != null && visEq.m_bodyModel.bones != null)
{
foreach (Transform b in visEq.m_bodyModel.bones)
{
if (b != null && b.name.ToLowerInvariant().Contains("spine")) spine.Append(b.name).Append(' ');
}
}
Jotunn.Logger.LogWarning($"[Sverm] No bone called '{SvermConfigManagement.Bone}' in this rig; " +
"the crest has nowhere to sit. Spine bones this rig actually has: " +
(spine.Length > 0 ? spine.ToString().Trim() : "none found") +
". Set one of those in the Bone key under [Sverm - Dorsal Spines].");
}
/// <summary>
/// What a mounted crest was built with, so "has the setting changed?" is a comparison
/// rather than a guess. This is the whole mechanism behind tuning the crest live from
/// Configuration Manager.
/// </summary>
public class SvermSpineTag : MonoBehaviour
{
public float Size;
public Quaternion Rotation = Quaternion.identity;
public float OffsetY;
}
// ─── Glide motes ─────────────────────────────────────────────────────
private const string MotesName = "SvermGlideMotes";
/// <summary>
/// What holds a falling Sverm up: a swarm of fireflies boiling up under the body, on
/// screen for exactly as long as the fall lasts.
///
/// Vestigial Wings is otherwise an invisible perk - the fall damage is simply not there,
/// and nothing tells the player why. This is the perk made visible, and it costs one
/// vanilla particle system.
///
/// Built once and then switched on and off. Rebuilding a particle system every time the
/// player leaves the ground would restart its emission from nothing and show a swarm that
/// is always just beginning.
/// </summary>
public static void ApplyGlideMotes(Player player)
{
if (player == null) return;
GameObject visual = Traverse.Create(player).Field("m_visual").GetValue<GameObject>();
if (visual == null) return;
bool eligible = IsSvermPlayer(player)
&& !player.IsDead()
&& SvermProgression.GetRules(GetRenderState(player)).FallDamageModifier < 0f;
Transform existing = visual.transform.Find(MotesName);
if (!eligible)
{
if (existing != null)
{
existing.name = MotesName + "_Removed";
Object.Destroy(existing.gameObject);
}
return;
}
if (existing == null)
{
existing = BuildGlideMotes(visual.transform);
if (existing == null) return;
}
// Airborne and going down. Rising - a jump, a launch - is not what the perk answers,
// so the swarm stays out of it and only appears when there is a fall to soften.
bool falling = !player.IsOnGround() && !player.IsSwimming() && player.GetVelocity().y < -0.5f;
if (existing.gameObject.activeSelf != falling)
{
existing.gameObject.SetActive(falling);
}
if (falling) TintBorrowed(existing.gameObject, GetRenderState(player));
}
/// <summary>
/// Instantiates the vanilla firefly swarm under the player.
///
/// Deliberately NOT through ModelBorrow: that helper measures a mesh in order to size it,
/// and a particle system has no mesh to measure - it would log a warning about an
/// unreadable model on every build and then leave the scale alone anyway. The one trick
/// worth borrowing is the inactive holder, so nothing on the copy wakes before its
/// networking has been stripped off.
/// </summary>
private static Transform BuildGlideMotes(Transform parent)
{
GameObject source = PrefabManager.Cache.GetPrefab<GameObject>(SvermConfig.GlideMotesPrefab);
if (source == null)
{
Jotunn.Logger.LogWarning($"[Sverm] No '{SvermConfig.GlideMotesPrefab}' to borrow; falls stay unlit.");
return null;
}
GameObject holder = new GameObject(MotesName);
holder.transform.SetParent(parent, false);
holder.transform.localPosition = Vector3.zero;
holder.SetActive(false);
GameObject copy = Object.Instantiate(source, holder.transform);
copy.name = "motes";
copy.transform.localPosition = Vector3.zero;
copy.transform.localRotation = Quaternion.identity;
foreach (MonoBehaviour behaviour in copy.GetComponentsInChildren<MonoBehaviour>(true))
{
if (behaviour != null) Object.DestroyImmediate(behaviour);
}
foreach (Collider collider in copy.GetComponentsInChildren<Collider>(true))
{
if (collider != null) Object.DestroyImmediate(collider);
}
foreach (ZNetView nview in copy.GetComponentsInChildren<ZNetView>(true))
{
if (nview != null) Object.DestroyImmediate(nview);
}
Jotunn.Logger.LogInfo($"[Sverm] Glide motes built from '{SvermConfig.GlideMotesPrefab}'.");
return holder.transform;
}
// ─── The carapace, and the ramp ──────────────────────────────────────
/// <summary>
/// Forces the three sealed slots to render as carapace whatever the player is carrying,
/// then paints every piece with the tier's tint.
///
/// Called from the UpdateVisuals postfix rather than once at spawn, because Valheim
/// rebuilds these instances on every equipment change and hands back plain white models.
/// </summary>
/// <summary>
/// Worn by a player whose three armour slots are currently showing carapace rather than
/// whatever they actually have equipped. A marker component rather than a static set of
/// players: it dies with the GameObject, so a player who logs out or is destroyed cannot
/// leave an entry behind.
/// </summary>
private class CarapaceMark : MonoBehaviour { }
public static void ApplyCarapace(Player player)
{
if (player == null) return;
VisEquipment visEq = player.GetComponent<VisEquipment>();
if (visEq == null) return;
if (!IsSvermPlayer(player))
{
// TAKING IT OFF IS THIS METHOD'S JOB TOO, and for a long time it was nobody's:
// this returned here and the only caller was itself behind an `if (isSverm)`, so
// the three slots kept showing carapace after the player had stopped being one.
// The visuals are a plain override written with SetChestItem and friends, so
// nothing in the game corrects them on its own - which is why equipping anything
// appeared to "fix" it. That was Valheim's own refresh writing the real gear back
// over ours, and until it happened the player wore chitin they no longer had.
//
// Every other cosmetic in this file already removes itself from whoever is not a
// Sverm (ApplyEyes, ApplyClaws, ApplySpines all do); the carapace was the one that
// did not.
CarapaceMark mark = player.GetComponent<CarapaceMark>();
if (mark != null)
{
Object.Destroy(mark);
RestoreEquipmentVisuals(player, visEq);
}
return;
}
if (player.GetComponent<CarapaceMark>() == null) player.gameObject.AddComponent<CarapaceMark>();
// Since Valheim 1.0 these three take an item hash rather than a prefab name.
visEq.SetChestItem(VisualHash(SvermConfig.CarapaceChestVisual));
visEq.SetLegItem(VisualHash(SvermConfig.CarapaceLegsVisual));
visEq.SetHelmetItem(VisualHash(SvermConfig.CarapaceHelmetVisual));
int state = GetRenderState(player);
TintInstances(Traverse.Create(visEq).Field("m_chestItemInstances").GetValue(), state);
TintInstances(Traverse.Create(visEq).Field("m_legItemInstances").GetValue(), state);
TintInstances(Traverse.Create(visEq).Field("m_helmetItemInstance").GetValue(), state);
}
/// <summary>
/// Puts the three slots back to whatever the player actually has equipped.
///
/// The same three lines vanilla's own Humanoid.SetupVisEquipment writes - the item's drop
/// prefab name hashed, or 0 when empty - rather than calling that method, because it also
/// rewrites the hands, the shoulders and the utility slot, and the Sverm never touched
/// those. Restoring only what was overridden cannot disturb another race's visuals or a
/// weapon that some other patch is mid-way through swapping.
///
/// Read through Traverse because the equipment fields are not public in the shipped
/// assembly, which is the same reason SvermClawSlot reads m_rightItem that way.
/// </summary>
private static void RestoreEquipmentVisuals(Player player, VisEquipment visEq)
{
visEq.SetChestItem(EquippedVisualHash(player, "m_chestItem"));
visEq.SetLegItem(EquippedVisualHash(player, "m_legItem"));
visEq.SetHelmetItem(EquippedVisualHash(player, "m_helmetItem"));
}
/// <summary>
/// What VisEquipment has wanted since Valheim 1.0: an item hash instead of a prefab name.
/// 0 is the empty slot - the same value vanilla Humanoid.SetupVisEquipment passes for a
/// slot holding nothing.
/// </summary>
private static int VisualHash(string prefabName) =>
string.IsNullOrEmpty(prefabName) ? 0 : prefabName.GetStableHashCode();
/// <summary>The item hash VisEquipment wants for an equipped slot, or 0 when it is empty.</summary>
private static int EquippedVisualHash(Player player, string field)
{
ItemDrop.ItemData item = Traverse.Create((Humanoid)player).Field<ItemDrop.ItemData>(field).Value;
if (item == null || item.m_dropPrefab == null) return 0;
return VisualHash(item.m_dropPrefab.name);
}
private static void TintInstances(object value, int state)
{
if (value is GameObject single)
{
Tint(single, state);
}
else if (value is List<GameObject> list)
{
foreach (GameObject instance in list) Tint(instance, state);
}
}
/// <summary>
/// Emberform's emission: the hue, dimmed to something a whole body can wear.
///
/// Kept as one call rather than two literals so the carapace and the borrowed pieces can
/// never drift apart, and so the strength has exactly one place to be turned down - which
/// it already had to be once, after the first version went out at full HDR and blinded
/// anyone standing next to it.
/// </summary>
private static Color EmberColor()
{
return SvermConfig.EmberEmission * SvermConfigManagement.EmberStrength;
}
/// <summary>
/// The ramp, written onto whatever renderers the piece happens to have.
///
/// _Color rather than _SkinColor: these are equipment materials, not the body, and the
/// body's Custom/Player shader is the only thing in the game that answers to _SkinColor.
/// Both are tried because armour pieces do not all use the same shader.
///
/// At Fader the same call also writes emission, which is the entire Emberform effect: the
/// chitin has already ramped to near black by then, so the red burn has something dark to
/// come through.
/// </summary>
private static void Tint(GameObject instance, int state)
{
if (instance == null) return;
Color tint = SvermCarapace.GetTint(state);
bool ember = SvermProgression.GetRules(state).Emberform;
foreach (Renderer renderer in instance.GetComponentsInChildren<Renderer>(true))
{
foreach (Material material in renderer.materials)
{
if (material == null) continue;
if (material.HasProperty("_Color")) material.SetColor("_Color", tint);
if (material.HasProperty("_SkinColor")) material.SetColor("_SkinColor", tint);
if (material.HasProperty("_EmissionColor"))
{
material.SetColor("_EmissionColor", ember ? EmberColor() : Color.black);
if (ember) material.EnableKeyword("_EMISSION");
}
}
}
}
/// <summary>
/// Same tint for a model borrowed onto a bone, plus the dither shader.
///
/// The body material cannot be applied to a foreign mesh - the UVs do not match and the
/// object simply vanishes, which is the trap FurlingPatches documents. The original
/// material is kept and only its SHADER is swapped, to Custom/Creature, so the piece fades
/// with the camera like everything else on the player.
/// </summary>
private static void TintBorrowed(GameObject holder, int state)
{
if (holder == null) return;
Color tint = SvermCarapace.GetTint(state);
bool ember = SvermProgression.GetRules(state).Emberform;
Shader dither = Shader.Find("Custom/Creature");
foreach (Renderer renderer in holder.GetComponentsInChildren<Renderer>(true))
{
foreach (Material material in renderer.materials)
{
if (material == null) continue;
if (dither != null) material.shader = dither;
if (material.HasProperty("_Color")) material.SetColor("_Color", tint);
if (material.HasProperty("_EmissionColor"))
{
material.SetColor("_EmissionColor", ember ? EmberColor() : Color.black);
if (ember) material.EnableKeyword("_EMISSION");
}
}
}
}
// ─── Bones ───────────────────────────────────────────────────────────
/// <summary>
/// The bone the body mesh is actually skinned to, not the Animator's avatar bone.
///
/// DvergarVisuals learned this the expensive way: the avatar's Head moves with the player
/// but is not the transform the head animation drives, so anything parented to it ignored
/// every idle bob. VisEquipment.m_bodyModel.bones is the rig that moves.
/// </summary>
private static Transform FindBone(Player player, string boneName)
{
VisEquipment visEq = player.GetComponent<VisEquipment>();
if (visEq == null || visEq.m_bodyModel == null || visEq.m_bodyModel.bones == null) return null;
foreach (Transform bone in visEq.m_bodyModel.bones)
{
if (bone != null && bone.name == boneName) return bone;
}
// Loose match, because rigs are not consistent about capitalisation or prefixes.
string wanted = boneName.ToLowerInvariant();
foreach (Transform bone in visEq.m_bodyModel.bones)
{
if (bone != null && bone.name.ToLowerInvariant().Contains(wanted)) return bone;
}
return null;
}
}
}