Merge branch 'fix-eye-position-glitch' into main
This commit is contained in:
commit
7668a0a996
3 changed files with 156 additions and 29 deletions
|
|
@ -242,28 +242,49 @@ namespace RacesOfValheim
|
|||
new ConfigDescription("How bright the final-stage red burns - the single knob for it, since the hue is already pure. Expect a floor: below the bloom threshold the eyes stop glowing and become flat dots.",
|
||||
new AcceptableValueRange<float>(0f, 3f), new ConfigurationManagerAttributes { Order = 87 }));
|
||||
|
||||
EyeSizeMultiplier = config.Bind(eyes, "Eye Size Multiplier", 1f,
|
||||
new ConfigDescription("Scales both sockets. 1 is the size the source creature wears them at.",
|
||||
new AcceptableValueRange<float>(0.1f, 5f), new ConfigurationManagerAttributes { Order = 80 }));
|
||||
// ─── Ranges are deliberately wide ────────────────────────────────
|
||||
// These started at +/-0.1 m and 0.1-5x, on the assumption that the borrowed sockets
|
||||
// land close to right and only need nudging. They do not, and a slider that cannot
|
||||
// reach the correct value is worse than no slider - it looks like the setting does not
|
||||
// work. Wide enough to dig the pair out of the skull from any starting point, and to
|
||||
// find the right size by eye when the source model's own scale does not transfer.
|
||||
// Every one of these is live: the eye ticker reapplies them each frame, so a drag in
|
||||
// Configuration Manager moves them while you watch.
|
||||
|
||||
EyeForwardOffset = config.Bind(eyes, "Eye Forward Offset", 0f,
|
||||
new ConfigDescription("Moves both eyes out of (or into) the face. 0 leaves them where the source creature wears them.",
|
||||
new AcceptableValueRange<float>(-0.1f, 0.1f), new ConfigurationManagerAttributes { Order = 70 }));
|
||||
// ─── The defaults below were found in game, not derived ──────────
|
||||
// The borrowed sockets do not arrive on the face by themselves: their authored pose
|
||||
// and scale belong to the Skeleton's own rig and none of it transfers cleanly to a
|
||||
// player armature (see AswidVisuals.BuildEyes for what does and does not carry over).
|
||||
// Four attempts to compute the remainder each missed, so it was dialled in on screen
|
||||
// instead and the answer written down here. That is what these seven numbers are - a
|
||||
// measurement, not a taste. Treat them as the working baseline: a fresh install lands
|
||||
// on a correct face, and the sliders are then free to be about taste again.
|
||||
//
|
||||
// The -180 on Z is the honest shape of it: the socket arrives upside down relative to
|
||||
// the player's head bone, and this is the half turn that rights it.
|
||||
|
||||
EyeSizeMultiplier = config.Bind(eyes, "Eye Size Multiplier", 1.1f,
|
||||
new ConfigDescription("Scales both sockets. 1 is the size the source creature wears them at.",
|
||||
new AcceptableValueRange<float>(0.01f, 50f), new ConfigurationManagerAttributes { Order = 80 }));
|
||||
|
||||
EyeForwardOffset = config.Bind(eyes, "Eye Forward Offset", 0.01f,
|
||||
new ConfigDescription("Moves both eyes out of (or into) the face, in metres. Positive is forward, out of the skull.",
|
||||
new AcceptableValueRange<float>(-0.5f, 0.5f), new ConfigurationManagerAttributes { Order = 70 }));
|
||||
EyeHeightOffset = config.Bind(eyes, "Eye Height Offset", 0f,
|
||||
new ConfigDescription("Moves both eyes up or down the face.",
|
||||
new AcceptableValueRange<float>(-0.1f, 0.1f), new ConfigurationManagerAttributes { Order = 69 }));
|
||||
EyeSeparationOffset = config.Bind(eyes, "Eye Separation Offset", 0f,
|
||||
new ConfigDescription("Pushes the two eyes apart (or together). Each moves away from the centre of the face, so this is half the change in the gap.",
|
||||
new AcceptableValueRange<float>(-0.1f, 0.1f), new ConfigurationManagerAttributes { Order = 68 }));
|
||||
new ConfigDescription("Moves both eyes up or down the face, in metres. Positive is up.",
|
||||
new AcceptableValueRange<float>(-0.5f, 0.5f), new ConfigurationManagerAttributes { Order = 69 }));
|
||||
EyeSeparationOffset = config.Bind(eyes, "Eye Separation Offset", 0.007f,
|
||||
new ConfigDescription("Pushes the two eyes apart (or together), in metres. Each moves away from the centre of the face, so this is half the change in the gap.",
|
||||
new AcceptableValueRange<float>(-0.5f, 0.5f), new ConfigurationManagerAttributes { Order = 68 }));
|
||||
|
||||
EyeRotationX = config.Bind(eyes, "Eye Rotation X", 0f,
|
||||
new ConfigDescription("Turns both eyes on the spot. Only matters if the borrowed socket is flat enough to be seen edge-on.",
|
||||
new AcceptableValueRange<float>(-180f, 180f), new ConfigurationManagerAttributes { Order = 60 }));
|
||||
EyeRotationY = config.Bind(eyes, "Eye Rotation Y", 0f,
|
||||
new ConfigDescription("As above, around the second axis.",
|
||||
EyeRotationY = config.Bind(eyes, "Eye Rotation Y", 24.664f,
|
||||
new ConfigDescription("As above, around the second axis - but MIRRORED: the left eye turns the opposite way, so the pair toes in or out together instead of both pointing off the same shoulder.",
|
||||
new AcceptableValueRange<float>(-180f, 180f), new ConfigurationManagerAttributes { Order = 59 }));
|
||||
EyeRotationZ = config.Bind(eyes, "Eye Rotation Z", 0f,
|
||||
new ConfigDescription("As above, around the third axis.",
|
||||
EyeRotationZ = config.Bind(eyes, "Eye Rotation Z", -180f,
|
||||
new ConfigDescription("As above, around the third axis. The default half turn is what rights the borrowed socket, which arrives upside down on a player's head bone.",
|
||||
new AcceptableValueRange<float>(-180f, 180f), new ConfigurationManagerAttributes { Order = 58 }));
|
||||
|
||||
EyeSmoke = config.Bind(eyes, "Eye Smoke", true,
|
||||
|
|
|
|||
|
|
@ -44,6 +44,20 @@ namespace RacesOfValheim
|
|||
// scale cancels and a given config value lands on the same part of the face at any size -
|
||||
// Fader-tier growth included. Kept in the arithmetic because it is honest about intent.
|
||||
|
||||
// The eye_l/eye_r pair is borrowed for its MESH AND MATERIAL only, never for its position.
|
||||
// Their authored local offset lives in the Skeleton creature's own rig, at whatever scale
|
||||
// that rig happens to use at the eye bone - measured at 0.02 lossy scale against this
|
||||
// player rig's 95-100, a roughly 5000x difference with no fixed ratio to correct for,
|
||||
// because nothing ties one prefab's rig scale to another's. Carrying that number over
|
||||
// unchanged (even after remapping which axis is which) put the eyes some 0.2 world units
|
||||
// off the head bone - visibly floating above the face. These three are the pre-rewrite
|
||||
// sphere code's own numbers, tuned by eye on THIS player rig and confirmed by playtest
|
||||
// before the borrowed-eye-light rewrite - the one measurement in this file that is
|
||||
// actually expressed in the right units to begin with.
|
||||
private const float BaseEyeForward = 0.081f;
|
||||
private const float BaseEyeHeight = 0.181f;
|
||||
private const float BaseEyeSeparation = 0.032f;
|
||||
|
||||
// ─── Race check ─────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
|
|
@ -298,11 +312,6 @@ namespace RacesOfValheim
|
|||
Vector3 shift = frame.LocalForward * (AswidConfig.EyeForwardOffset.Value * scale)
|
||||
+ frame.LocalUp * (AswidConfig.EyeHeightOffset.Value * scale);
|
||||
|
||||
Quaternion twist = Quaternion.Euler(
|
||||
AswidConfig.EyeRotationX.Value,
|
||||
AswidConfig.EyeRotationY.Value,
|
||||
AswidConfig.EyeRotationZ.Value);
|
||||
|
||||
for (int i = 0; i < holder.childCount; i++)
|
||||
{
|
||||
Transform eye = holder.GetChild(i);
|
||||
|
|
@ -315,6 +324,19 @@ namespace RacesOfValheim
|
|||
float side = Mathf.Sign(Vector3.Dot(authored.Position, frame.LocalRight));
|
||||
if (side == 0f) side = i == 0 ? -1f : 1f;
|
||||
|
||||
// YAW IS MIRRORED, the other two are not. Turning both eyes the same way on Y
|
||||
// makes the pair look sideways - both point off the same shoulder, because a face
|
||||
// is symmetric about its centre line and yaw is the axis that crosses it. Negating
|
||||
// it on the left eye turns them out from (or in towards) the nose together, which
|
||||
// is what "toe them in a bit" actually means on a pair of eyes.
|
||||
//
|
||||
// Pitch and roll are shared deliberately: both eyes looking up is a face looking
|
||||
// up, and mirroring either of those would cross them instead of aiming them.
|
||||
Quaternion twist = Quaternion.Euler(
|
||||
AswidConfig.EyeRotationX.Value,
|
||||
AswidConfig.EyeRotationY.Value * side,
|
||||
AswidConfig.EyeRotationZ.Value);
|
||||
|
||||
eye.localPosition = authored.Position + shift +
|
||||
frame.LocalRight * (side * AswidConfig.EyeSeparationOffset.Value * scale);
|
||||
eye.localRotation = twist * authored.Rotation;
|
||||
|
|
@ -381,6 +403,11 @@ namespace RacesOfValheim
|
|||
List<Transform> sources = FindSourceEyes(modelName);
|
||||
if (sources.Count == 0) return null; // already logged once by the finder
|
||||
|
||||
// The placement below divides by this, and the rig reports 0 for a frame or two while
|
||||
// it is still coming up. Returning null costs nothing - ApplyEyes calls again next
|
||||
// tick - where dividing by it would put the pair somewhere unrecoverable.
|
||||
if (Mathf.Abs(headBone.lossyScale.x) < 0.0001f) return null;
|
||||
|
||||
// Anything of ours left anywhere else on this player goes first. ApplyEyes only ever
|
||||
// looks under the head bone, so a holder that ended up on some other transform is
|
||||
// invisible to it - it would build a second pair beside the wrong one rather than
|
||||
|
|
@ -396,7 +423,15 @@ namespace RacesOfValheim
|
|||
// 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;
|
||||
//
|
||||
// player.transform, NOT headBone.root. headBone comes off VisEquipment.m_bodyModel's
|
||||
// own bone array, and walking .root from there does not reliably land back on the
|
||||
// player - the eyes came out wrong on every single build, not just an unlucky one, which
|
||||
// is what a bad-timing read (the guard above already handles that) would look like.
|
||||
// A CONSISTENTLY wrong answer means a consistently wrong reference, not a bad moment to
|
||||
// ask it in. DvergarVisuals.BuildEyes already reads player.transform directly for
|
||||
// exactly this reason; this now matches it.
|
||||
Transform root = player.transform;
|
||||
EyeFrame frame = holder.AddComponent<EyeFrame>();
|
||||
frame.LocalForward = SnapToAxis(headBone.InverseTransformDirection(root.forward));
|
||||
frame.LocalUp = SnapToAxis(headBone.InverseTransformDirection(root.up));
|
||||
|
|
@ -404,21 +439,74 @@ namespace RacesOfValheim
|
|||
frame.SourceModel = modelName;
|
||||
frame.FlatShader = AswidConfig.EyeFlatColorShader.Value;
|
||||
|
||||
// canonicalToFrame turns "face forward, as authored" into "face forward, on THIS
|
||||
// rig's own axes" - the rotation that carries the ordinary (X,Y,Z) convention onto
|
||||
// (frame.LocalRight, frame.LocalUp, frame.LocalForward). Used for the socket's base
|
||||
// facing below; NOT used for position - see BaseEyeForward/Height/Separation for why.
|
||||
Quaternion canonicalToFrame = Quaternion.LookRotation(frame.LocalForward, frame.LocalUp);
|
||||
|
||||
foreach (Transform source in sources)
|
||||
{
|
||||
GameObject eye = Object.Instantiate(source.gameObject, holder.transform);
|
||||
eye.name = source.name;
|
||||
|
||||
// LEFT vs RIGHT read from the source object's own name, not from list order -
|
||||
// "eye_l"/"eye_r" is the actual contract FindSourceEyes matches against; the order
|
||||
// GetComponentsInChildren happens to walk the source hierarchy in is not.
|
||||
float side = source.name.ToLowerInvariant().Contains("_l") ? -1f : 1f;
|
||||
|
||||
// Placed from the player's own measured frame and three fixed constants, NOT from
|
||||
// source.localPosition. The borrowed position is authored on the Skeleton
|
||||
// creature's own rig, at whatever scale that rig happens to use at the eye bone -
|
||||
// measured at 0.02 lossy scale against this player rig's ~95-100, and nothing ties
|
||||
// one prefab's rig scale to another's, so there is no reliable factor to correct
|
||||
// it by. In game it landed 0.22 m straight up from the head bone and barely any
|
||||
// forward, where 0.181 up / 0.081 forward is the face - eyes above the skull.
|
||||
//
|
||||
// THE / lossyScale IS NOT OPTIONAL. The constants are world metres; localPosition
|
||||
// is in the head bone's own space, which the armature authors at ~95-100x. Setting
|
||||
// them without this term puts the eyes 0.081 x 95 = 7.7 m out - off the model
|
||||
// entirely and invisible, which is exactly what dropping this term did once
|
||||
// already. PlaceEyes applies the config offsets through the same 1/lossy factor
|
||||
// for the same reason, and the pre-rewrite sphere code always had it.
|
||||
float toLocal = 1f / headBone.lossyScale.x;
|
||||
|
||||
Vector3 basePosition = frame.LocalForward * (BaseEyeForward * toLocal)
|
||||
+ frame.LocalUp * (BaseEyeHeight * toLocal)
|
||||
+ frame.LocalRight * (side * BaseEyeSeparation * toLocal);
|
||||
|
||||
// The socket's own authored tilt is skipped for the same reason its position is -
|
||||
// canonicalToFrame alone (face forward, on this rig's axes) is what the config's
|
||||
// twist then nudges from in PlaceEyes.
|
||||
Quaternion baseRotation = canonicalToFrame;
|
||||
|
||||
// SCALE IS INHERITED, so the authored localScale cannot come across either.
|
||||
//
|
||||
// source.localScale is authored under the Skeleton's own parent chain, which puts
|
||||
// that object at 0.02 lossy scale in the world. Re-parented under a head bone at
|
||||
// ~95 and left alone, the same number renders the mesh some 4750x too big: an eye
|
||||
// the size of the character, centred near the face, therefore mostly INSIDE the
|
||||
// skull, with the corners that clear it reading as flat rectangles rather than as
|
||||
// eyes. That is one bug with two faces - "wrong place" and "blocky" were the same
|
||||
// scale error seen from outside and from in front.
|
||||
//
|
||||
// lossyScale (world) rather than localScale (relative to a parent we do not have)
|
||||
// is the honest quantity to carry over: it is the size the game actually draws
|
||||
// this object at on a real skeleton. Divided into the new parent's scale, the pair
|
||||
// lands at exactly the size vanilla wears them, which is the whole point of
|
||||
// borrowing them instead of drawing spheres.
|
||||
Vector3 baseScale = source.lossyScale * toLocal;
|
||||
|
||||
// Remembered before anything moves it, because everything the config does is
|
||||
// expressed as a delta on this.
|
||||
EyeBase authored = eye.AddComponent<EyeBase>();
|
||||
authored.Position = source.localPosition;
|
||||
authored.Rotation = source.localRotation;
|
||||
authored.Scale = source.localScale;
|
||||
authored.Position = basePosition;
|
||||
authored.Rotation = baseRotation;
|
||||
authored.Scale = baseScale;
|
||||
|
||||
eye.transform.localPosition = source.localPosition;
|
||||
eye.transform.localRotation = source.localRotation;
|
||||
eye.transform.localScale = source.localScale;
|
||||
eye.transform.localPosition = basePosition;
|
||||
eye.transform.localRotation = baseRotation;
|
||||
eye.transform.localScale = baseScale;
|
||||
|
||||
// Allowlist, not a blocklist - the same rule the skeleton's own glow and the head
|
||||
// flame are cloned under. Whatever rode along goes, whatever type it turns out to
|
||||
|
|
|
|||
|
|
@ -192,7 +192,20 @@ namespace RacesOfValheim
|
|||
return;
|
||||
}
|
||||
|
||||
if (eyes == null) eyes = BuildEyes(headBone);
|
||||
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);
|
||||
|
|
@ -256,7 +269,7 @@ namespace RacesOfValheim
|
|||
}
|
||||
}
|
||||
|
||||
private static Transform BuildEyes(Transform headBone)
|
||||
private static Transform BuildEyes(Player player, Transform headBone)
|
||||
{
|
||||
Shader glow = ResolveGlowShader();
|
||||
if (glow == null) return null;
|
||||
|
|
@ -270,7 +283,12 @@ namespace RacesOfValheim
|
|||
// 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.
|
||||
Transform root = headBone.root;
|
||||
//
|
||||
// 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.
|
||||
Transform root = player.transform;
|
||||
EyeFrame frame = holder.AddComponent<EyeFrame>();
|
||||
frame.LocalForward = SnapToAxis(headBone.InverseTransformDirection(root.forward));
|
||||
frame.LocalUp = SnapToAxis(headBone.InverseTransformDirection(root.up));
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue