Placement is right and the trace proves it - 0.095m from the head bone, exactly the offsets after the race scale, parented to Head and following it. They were simply still inside the skull, and the shader that resolved is depth-tested, so the head hid them completely.
The bone sits at the base of the skull and a face is further forward than it looks. Offsets raised to land about 0.109m out on a Dvergar. The trace now also reports how far up the eye ended up and whether it is on the face side of the head at all, so the next look distinguishes too shallow from the wrong direction entirely.
The trace found it. An eye sat at local (0, 0.0066, 0) on a bone with a scale of
78, which is 0.513m straight up - exactly the distance being reported from the
head. The offsets in play are 0.0007 local units, three orders of magnitude too
small to account for that, so the drift was never in them.
It was the origin. 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, and it
is not: it is where the camera goes, half a metre above the head bone. Everything
after that was correct arithmetic applied to the wrong point, which is why five
rounds of adjusting the offsets changed nothing.
Placement now starts at the head bone and nowhere else. The offsets return to
real distances for a face - forward to the surface of the skull, up from its base
- and the frame conversion is left alone, since the same trace proved it right:
0.0002 local units on a bone scaled 78 rendered as a 0.016m eye, exactly as
asked.
The arithmetic puts them 7cm from the head bone and the screen puts them metres away, so the offsets are not the thing to keep adjusting. Traces position, parent, local and world transforms and the distance from the head, six times over the first few seconds - enough to tell a bad offset from an object that is not parented, or one that is parented and then moved.
A child transform cannot ignore its parent's rotation, so eyes that followed the
body but sat out every idle bob of the head were never parented to the head that
was moving. They were parented to the Animator avatar's HumanBodyBones.Head,
which on this rig is a transform that travels with the player and is not the one
the animation drives.
The rest of the mod has never used the avatar for this. The hood, the Skeleton's
body swap and the Furling's head all take the bone off
VisEquipment.m_bodyModel.bones - the array the skinned mesh deforms with, which
is by definition the rig that moves. The eyes do too now, with the avatar left as
a fallback only for the case where the body model is not up yet.
The one-shot log prints both candidates side by side and says whether they are
the same transform, so the next report confirms or kills this outright rather
than leaving it to inference.
Three attempts have now placed these by picking a distance from a bone and hoping,
and all three landed somewhere wrong - above the head, on the camera, and inside
the skull. The distance was never the thing to fix.
Character.m_eye is the game's own answer to where a player's eyes are. 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, and because the result is local it rides
every head animation without being recomputed. The config offsets stay as small
nudges in metres on top of that, with EyeForward pushing out of the skull to the
surface of the face.
Also logs the bone name, its scale and the measured eye point once per session,
so the next round starts from numbers rather than from another guess.
They were placed from the player root's axes every frame, which follows where the
body faces and knows nothing about where the head is looking - so an idle
animation turned the head and left the eyes behind, reading as attached to the
camera rather than to the face.
They are children of the head bone now, so position and rotation are inherited
and no longer computed. The reason that was avoided in the first place was not
knowing which way a rig bone points, and the answer turned out to be to stop
guessing: the body's forward and up, expressed in the head bone's local space,
are exactly the directions wanted, and because they are local they go on meaning
the same thing as the head turns. Measured once at build time, while the head is
still looking where the body is.
Scale is the only thing still asserted each frame, because it can change under
us. The bone carries the armature's hundredfold scale multiplied by whatever the
race renders at; dividing it out leaves the holder standing at exactly the race's
scale, which keeps the offsets underneath honest metres and keeps the eyes
shrinking with a Dvergar.
Two symptoms, one cause each, and both were choices from the first version.
Vanishing from certain angles: the eyes were quads. A quad has no thickness, so
seen edge-on it is a line and there is nothing to draw. Now spheres, which read
the same from every direction.
Drawing in front of the face, and visible from behind: the shader resolver was
asked for Sprites/Default first and got it. That is a transparent shader with
depth writing off and backface culling off - so the eyes drew over whatever was
in front of them and stayed visible through the back of the head. The resolver
now asks for an unlit opaque shader first, which the skull occludes like any
other solid thing.
Between them, an eye is now a small solid glowing ball in a face rather than a
sticker that only exists at some angles.
Both faults reported came from the same wrong anchor. Character.m_eye is the
camera's eye point, not the model's: it lives outside the scaled rig, so on a
Dvergar - who renders at 78% - the quads hung where a full-height human's face
would have been, a foot above the head. And it turns with the look direction
rather than with the face, so they pointed wherever the player was looking rather
than wherever the head was.
They now hang off the player root, unscaled, and are placed onto the head bone in
world space every frame: position from the bone, orientation from the player's
own facing, and every offset multiplied by the race's visual scale so they shrink
with the body. That also means the placement constants are honest metres measured
from the base of the skull, which is what makes them tunable at all.
Driven per frame from the two places that already tick a Dvergar - the race
script for the local player, the visual controller for remote ones - because
world-space placement has to be re-applied rather than inherited.
A player's eyes are painted into the skin texture, and Custom/Player has no
emission channel to light them with - the shader survey in the last commit is
what established that. So a Dvergar wears two small emissive quads over them
instead. There was no working example to copy: the Aswid's red eyes were never
built, only cleaned up, which is why they never glowed.
Colour comes from the same LevelSetup list the skin tint does. One star is
RGBA(0, 4, 3.3), two stars RGBA(12, 0, 8.8) - both far past 1, which is what
makes them bloom rather than merely look bright. Only the base tier's colour is
ours to choose.
The quads hang off Character.m_eye, which already sits at eye height and already
faces the look direction, so the offsets are plain metres in an obvious frame:
no working out which way a rig bone points, and no fighting the 100x scale the
player armature is authored at. Everything about the placement is a named
constant, since none of it can be judged without seeing it.
Applied from the UpdateColors postfix rather than UpdateVisuals so that the
refresh DvergarRace already forces when a boss falls recolours the eyes in the
same frame it recolours the skin. It runs before the race check so it also takes
them off again.
The glow shader is resolved from a list and the winner is logged, because Unity
strips shaders nothing references and assuming one would be a silent failure.
Custom/Player carries 13 properties and exactly one colour among them,
_SkinColor. No _Hue, no _Saturation, no _Value, no _Brightness, no _Grayscale.
That closes the question the last three commits kept circling. A real dverger
turns pale at two stars through saturation -1 on the creature shader, which
genuinely desaturates its texture. The player body has no equivalent control:
_SkinColor multiplies the human skin map, and a multiply can darken or bias but
never desaturate, because the pink lives 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 exactly what every attempt walked into.
Reaching it would mean swapping _MainTex for a desaturated copy of the skin
texture, a per-player blit through a custom shader. Disproportionate for a
cosmetic tier.
The survey stays as a check rather than being deleted, in case a game update ever
changes the player shader, and the finding is written where the next person will
look for it.
The star offsets read off the prefab, for the record:
Star 1: hue +0.100, saturation +0.200, value 0, emissive RGBA(0, 4, 3.294)
Star 2: hue 0, saturation -1.000, value 0, emissive RGBA(11.984, 0, 8.784)
Both emissive colours are HDR and are what a starred dverger's eyes glow with.
Deriving it from the creature's own two-star offset put the tier a shade away
from ordinary human skin, and no amount of clamping fixes that, because the
derivation is asking for something a multiplier cannot do. Those offsets
brighten and desaturate a dverger's own texture. Ours multiplies the human skin
map, where less saturation means less tint, and less tint means more flesh - the
opposite direction from the one intended.
A multiplier can darken and it can bias. It cannot desaturate: the pink lives in
the texture and survives being multiplied by grey, only dimmer. So two stars now
states a colour outright - dark, and cold enough to sit on top of the flesh tone
rather than under it.
One star keeps deriving from the prefab, since that tier reads correctly.
SkeletonRace hides it every frame, but that script only ever runs for the local
player in a loaded world - so the moment the body swap started working in the
menu, the helmet came back with it. Hiding it from the visuals postfix instead
covers the preview, remote players and the first frame after a race change, none
of which reach SkeletonRace. Scaled to zero rather than deactivated, since
Valheim re-enables the instance on every refresh, and restored only from zero so
another race scaling the same helmet is left alone.
Armour is untouched, as asked.
fix(dvergar): stop the two-star tier turning back into a pink human
The star offsets are authored against a dverger's own texture, where a brightened,
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 exactly what two stars produced: an ordinary human. One star survived only
because its offset was smaller.
Saturation now has a floor and value a ceiling, so a tier can shift the colour but
never wash it out. The resolved offsets and the colour each one lands on are
logged once per session, so if a tier still reads wrong it can be tuned against
the real numbers rather than by eye.
The body swap read the race off the ZDO and gave up when there was none, which
is exactly the situation on the menu preview - FejdStartup instantiates a Player
and calls PlayerProfile.LoadPlayerData on it, so the preview knows its own custom
data and therefore its race, but it has no business owning a network view. It now
falls back to m_customData the way every other race in the mod already does, so a
Skeleton character looks like one before you press Start.
The tier falls back the same way. In the menu there is no world loaded to have
killed anything, so the preview is the base skeleton whatever the character has
done elsewhere.
feat(dvergar): age into a starred dverger's colours
One star at Bonemass, two at Fader.
Nothing is picked by eye. A starred creature in Valheim is not a second model: it
is the same one recoloured by LevelEffects, whose LevelSetup list holds a
hue/saturation/value offset per star. Those offsets are read off the Dverger
prefab at runtime and applied to the race's own slate blue-grey, so the tiers land
on the tints the game itself uses and keep following them if the prefab changes.
The tier comes from the ZDO key DvergarRace already publishes, so a remote Dvergar
is coloured at their own standing rather than the observer's - which matters as
soon as anyone runs personal progression.
Crossing a tier pushes a colour refresh through immediately, since the tint is
only written from the UpdateColors postfix and Valheim runs that on its own
schedule. Same treatment the health malus already gets a few lines above.
The hood is deliberately untouched.
Rename covers the folder, all seven filenames and every identifier, status
effect name and display string. Valheim's own Dverger/dvergr prefab references
are untouched - the names never collided.
The race id is what sits in m_customData and the ZDO, so renaming it alone would
have handed every existing character the selection menu again. DvergarRace
migrates the old id on spawn, before anything else reads it.
Runic Spark is modelled on Skadi's Ice Affinity and deliberately shares its
shape: live from the base tier and growing a flat step per progression state, so
+2 at Base through +16 after Fader. Lightning rather than frost, and like
Skadi's it rides every blow rather than melee only. AddFlat gained the elemental
channels while it was there - lightning would otherwise have landed in generic
damage.
The Trol remote-sync trace fired on a two-second timer for as long as a remote
player existed, which in the main menu is forever: Player.m_localPlayer is null
there, so the character preview counts as remote and it never stopped. Keyed on
the state it reports instead, so it still catches a remote player being sized
wrongly without narrating an idle menu.
2026-08-04 00:22:58 +02:00
Renamed from JotunnModStub/Dvergur/DvergurVisuals.cs (Browse further)