diff --git a/.claude/settings.json b/.claude/settings.json new file mode 100644 index 0000000..18ec309 --- /dev/null +++ b/.claude/settings.json @@ -0,0 +1,11 @@ +{ + "permissions": { + "allow": [ + "mcp__Claude_Browser__navigate", + "mcp__Claude_Browser__get_page_text", + "PowerShell(git status *)", + "PowerShell(git diff *)", + "PowerShell(git fetch *)" + ] + } +} diff --git a/JotunnModStub/Aswid/AswidPatches.cs b/JotunnModStub/Aswid/AswidPatches.cs index c6ce67b..e3f2724 100644 --- a/JotunnModStub/Aswid/AswidPatches.cs +++ b/JotunnModStub/Aswid/AswidPatches.cs @@ -23,6 +23,10 @@ namespace RacesOfValheim else if (player.m_customData != null && player.m_customData.TryGetValue("Race", out string savedRace)) race = savedRace; + // Before the race check, because it takes the eyes off anyone who has stopped being + // an Aswid as well as putting them on anyone who is one. + AswidVisuals.ApplyEyes(player); + if (race != "Aswid") return; int state = 0; diff --git a/JotunnModStub/Aswid/AswidVisuals.cs b/JotunnModStub/Aswid/AswidVisuals.cs new file mode 100644 index 0000000..a6a86dc --- /dev/null +++ b/JotunnModStub/Aswid/AswidVisuals.cs @@ -0,0 +1,339 @@ +using UnityEngine; + +namespace RacesOfValheim +{ + /// + /// The Aswid's glowing eyes: two small emissive spheres burned into the face, evil red. + /// + /// Built the same way the Dvergar's eyes are (see DvergarVisuals.ApplyEyes) and for the same + /// reason - a player's eyes are painted into the skin texture, and Custom/Player has no + /// emission channel to light them with. The geometry is shared work: both races render on the + /// plain human rig (Aswid tints it, same as Dvergar), so the head bone, its axes, and the + /// spherical-cap placement trick all carry over unchanged. Only the numbers differ, because an + /// Aswid stands at normal human scale most of the time instead of the Dvergar's 0.78. + /// + /// Runs for local and remote players alike, which is why it takes a Player rather than reading + /// Player.m_localPlayer. + /// + public static class AswidVisuals + { + private const string EyesName = "AswidEyes"; + + // ─── Glow colour ──────────────────────────────────────────────────── + // HDR on purpose - past 1 is what makes the bloom pass pick these up at all - but only + // just past it. The first attempt used (6, 0.08, 0.03) at full strength and came out as a + // white headlamp with a red halo: bloom spreads the excess outward and saturates the core, + // so beyond a point more brightness buys nothing but a bigger white disc and *less* red. + // The Dvergar hit this exact wall and answered it by dimming, which is the same answer + // here. + // + // The near-zero green and blue are what keep it red rather than pink as it brightens. + // Not tied to star tier: unlike the Dvergar, whose colour borrows a real creature's + // progression, the Aswid has no such reference to read from. + public static readonly Color EvilEyeColor = new Color(4f, 0.06f, 0.02f, 1f); + + // Darker than the Dvergar's 0.3, which put the red at an effective 1.2 - above 1, so the + // core clipped to a flat saturated red and the shade was decided by the clip rather than + // by the colour. 0.2 lands it at 0.8: under the clip, so the red keeps its depth and reads + // as blood rather than as a warning light. + // + // This is the one knob for how dark the eyes are - the hue is already pure red, so with + // green and blue at zero there is nothing left to darken *except* the intensity. Lower it + // further for deeper, but expect a floor: bloom only picks up what is bright enough to + // pass its threshold, so far enough down the eyes stop glowing and become flat dots. + public static readonly float EyeGlowStrength = 0.2f; + + // ─── Placement ────────────────────────────────────────────────────── + // The Dvergar's numbers, carried over unchanged. That is not laziness - it is the only + // correct conversion, and the arithmetic says so: + // + // local offset = config x scale x (1 / headBone.lossyScale) + // lossyScale = 100 (the armature's authored scale) x scale + // => config x scale / (100 x scale) = config / 100 + // + // The scale cancels. These constants live in the *unscaled* rig's units, and the face they + // have to land on shrinks and grows by exactly the same factor, so the same config value + // lands on the same part of the face at any size. Both races render on the plain human + // rig, so the Dvergar's tuning transfers verbatim. + // + // The first version of this file rescaled them by 0.78 on the theory that the Dvergar's + // values were "pre-shrink" and needed converting up to human size. They are not, and it + // put the eyes 18mm deeper and 40mm lower in rig units - on a human skull, the drop from + // the eye line to the mouth. + // + // What this also means: the Fader-tier +10% (Aswid_PlayerUpdate_Patch in AswidPatches.cs) + // needs no special case. It is not that the multiply handles it - the multiply cancels + // out. It is that the offsets are expressed in the head bone's own local space, and a + // child transform rides its parent's scale for free. + public static readonly float EyeSeparation = 0.032f; // half the distance between them + public static readonly float EyeForward = 0.081f; // centre out from the head bone + public static readonly float EyeHeight = 0.181f; // up from the head bone + public static readonly float EyeSize = 0.062f; // across, so a 24mm radius at 0.78 + + // Carried over from the Dvergar's own tuning on this same rig: the face is not flat, so + // two eyes placed symmetrically do not come out looking symmetrical. May need a pass in + // game to confirm it holds at Aswid's own scale - flip to index 1 in PlaceEyes if it turns + // out to be the wrong eye. + public static readonly float LeftEyeSizeMultiplier = 0.85f; + + public const string PlayerHeadBoneName = "Head"; + + // ─── Race check ───────────────────────────────────────────────────── + + /// + /// 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. Mirrors the check + /// AswidSkinColorPatch already does inline in AswidPatches.cs. + /// + private static bool IsAswidPlayer(Player player) + { + if (player == null) return false; + + ZNetView nview = player.GetComponent(); + if (nview != null && nview.IsValid()) + { + return nview.GetZDO().GetString("RacesOfValheim_Race", "Human") == "Aswid"; + } + + return player.m_customData != null && + player.m_customData.TryGetValue("Race", out string race) && + race == "Aswid"; + } + + // ─── Eyes ─────────────────────────────────────────────────────────── + + /// + /// 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. + /// + 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; + + /// + /// Keeps two small emissive spheres burning over the player's painted-on eyes. Safe to call + /// for anyone: it removes them again from whoever is not a living Aswid. + /// + /// Parented straight onto the head bone rather than Character.m_eye - the Dvergar tried + /// m_eye first and found it sits half a metre above the head bone, outside the scaled rig + /// entirely, which floated the eyes above the model and turned them with the camera + /// instead of the face. Anchoring on the bone itself sidesteps both. + /// + 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 (!IsAswidPlayer(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(headBone); + if (eyes == null) return; // already logged once by the resolver + + PlaceEyes(player, headBone, eyes); + + Color glow = GetEyeColor(); + foreach (Renderer renderer in eyes.GetComponentsInChildren(true)) + { + Material material = renderer.material; + if (material == null) continue; + + material.color = glow; + if (material.HasProperty("_EmissionColor")) material.SetColor("_EmissionColor", glow); + } + } + + /// + /// The head bone the body mesh is actually skinned to - not the Animator's. See + /// DvergarVisuals.FindHeadBone for why: the avatar's HumanBodyBones.Head moves with the + /// player but ignores the head's own idle animation, and only VisEquipment.m_bodyModel's + /// own bone array is the one the skinned mesh - and every animation - actually drives. + /// + private static Transform FindHeadBone(Player player) + { + VisEquipment visEq = player.GetComponent(); + if (visEq != null && visEq.m_bodyModel != null && visEq.m_bodyModel.bones != null) + { + foreach (Transform bone in visEq.m_bodyModel.bones) + { + if (bone != null && bone.name == PlayerHeadBoneName) return bone; + } + } + + // Last resort, and only so that something renders if the body model is not up yet. + Animator animator = player.GetComponentInChildren(); + return animator != null ? animator.GetBoneTransform(HumanBodyBones.Head) : null; + } + + /// + /// How much bigger than baseline this particular Aswid currently is. Read straight off the + /// player root, not off the "Visual" child the Dvergar reads: the Fader-tier growth + /// (AswidPatches.cs, Aswid_PlayerUpdate_Patch) scales __instance.transform - the root - + /// directly, so that is where the +10% actually lives. + /// + private static float GetPlayerScale(Player player) => player.transform.localScale.x; + + private static Color GetEyeColor() + { + float strength = EyeGlowStrength; + return new Color( + EvilEyeColor.r * strength, + EvilEyeColor.g * strength, + EvilEyeColor.b * strength, + EvilEyeColor.a); + } + + /// + /// Puts the two eyes where the face is, in the head bone's own coordinates, every frame. + /// See DvergarVisuals.PlaceEyes for the full derivation of the axes. + /// + /// The scale term is kept for the Dvergar's sake and because it is honest about intent, + /// but it does not do the work it looks like it does: lossyScale already contains the + /// player's scale, so the multiply and the divide cancel and the local offset is simply + /// config/100 at every size. Growth is handled by the parenting, not by this arithmetic - + /// see the note on the placement constants above. + /// + 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(); + if (frame == null) return; + + Vector3 localForward = frame.LocalForward; + Vector3 localUp = frame.LocalUp; + Vector3 localRight = frame.LocalRight; + + float scale = GetPlayerScale(player); + Vector3 baseLocal = localForward * (EyeForward * scale * toLocal) + + localUp * (EyeHeight * 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 - the + // one on your right as you face it. + float side = i == 0 ? -1f : 1f; + float size = i == 0 ? eyeLocalSize * LeftEyeSizeMultiplier : eyeLocalSize; + + eye.localPosition = baseLocal + localRight * (side * EyeSeparation * scale * toLocal); + eye.localScale = Vector3.one * size; + } + } + + /// + /// Rounds a direction to the nearest of the six axis directions. Whichever component is + /// largest wins, sign included. + /// + 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(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 - + // see DvergarVisuals.BuildEyes for why the raw, unrounded measurement puts the eyes at + // the jaw instead of the eye line. + Transform root = headBone.root; + EyeFrame frame = holder.AddComponent(); + frame.LocalForward = SnapToAxis(headBone.InverseTransformDirection(root.forward)); + frame.LocalUp = SnapToAxis(headBone.InverseTransformDirection(root.up)); + frame.LocalRight = Vector3.Cross(frame.LocalUp, frame.LocalForward).normalized; + + for (int i = 0; i < 2; i++) + { + // Spheres, not quads: a quad seen edge-on is a line and vanishes, which is why an + // earlier attempt on the Dvergar 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; + + foreach (Collider collider in eye.GetComponents()) + { + 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.material = new Material(glow); + renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off; + renderer.receiveShadows = false; + } + + return holder.transform; + } + + /// + /// Finds a shader that will render a flat colour past 1 so the bloom pass picks it up. + /// Opaque first, deliberately - see DvergarVisuals.ResolveGlowShader: a transparent shader + /// with depth writing off draws over the head from angles that should hide it. + /// + 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($"[Aswid] Eye glow shader resolved to '{name}'."); + cachedGlowShader = shader; + return cachedGlowShader; + } + + Jotunn.Logger.LogWarning( + "[Aswid] No glow shader resolved (" + string.Join(", ", candidates) + "); eyes stay unlit."); + return null; + } + } +}