Swimming pose and stroke on the player model

The player's model never read the swimming pose: sprint-swimming and
crawling drew it upright and walking. Add LivingEntity.swimAmount
(eased 0.09 a tick toward isVisuallySwimming), AvatarRenderer's swim
rotation (tipped by the pitch in water, -90 out of it, laid along the
swimming box) and HumanoidModel.setupSwimAnimation (the 26-unit arm
stroke, head down, flutter kick). The avatar rotations now follow
LivingEntityRenderer.setupRotations' death and upside-down turns, as in
vanilla.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-17 08:45:23 +02:00
parent ef3cd64475
commit c7ad9b861f
4 changed files with 221 additions and 11 deletions
@@ -313,6 +313,15 @@ impl Game<'_> {
.map_or(25, |s| Self::charge_ticks(s).max(1)) as i32;
let attack = (self.swing.old_animation, self.swing.animation);
let swinging = self.swing.swinging();
// currentSwing.hand().asArm(mainArm).
let swing_right_arm = swinging.then(|| {
(self.swing.attack_hand() == horizon_client::first_person::Hand::Main)
!= self.settings.main_hand_left
});
// LivingEntity.isVisuallySwimming and Entity.isInWater.
let visually_swimming =
p.pose == Pose::Swimming || (!p.fall_flying && p.pose == Pose::FallFlying);
let in_water = p.fluids.was_touching_water;
let (yaw, pitch) = (self.yaw, self.pitch);
let main = self.inventory[self.selected]
.as_ref()
@@ -378,6 +387,8 @@ impl Game<'_> {
m.extra.charged = charged;
m.extra.ints[5] = charge_duration;
m.extra.elytra.tick(fall_flying, crouching, velocity);
m.extra.swim.tick(visually_swimming, in_water);
m.extra.swing_right_arm = swing_right_arm;
m.hurt_time = hurt;
}
/// Whether the player's own model shows in the world view.
+33
View File
@@ -690,6 +690,10 @@ pub struct Extra {
pub fall_fly_ticks: i32,
pub main_hand_left: bool,
pub elytra: ElytraAnimation,
pub swim: SwimAnimation,
/// The arm the current swing moves (`currentSwing.hand().asArm`): `Some(true)`
/// for the right arm.
pub swing_right_arm: Option<bool>,
pub flag: bool,
pub flag2: bool,
/// Species scratch values (the wither's head targets and clocks).
@@ -2068,6 +2072,35 @@ impl ElytraAnimation {
}
}
/// `LivingEntity.swimAmount` and the render state the swimming pose reads
/// (`isVisuallySwimming`, `isInWater`).
#[derive(Clone, Copy, Debug, Default)]
pub struct SwimAnimation {
pub old: f32,
pub amount: f32,
/// `isVisuallySwimming`: in the swimming pose (or still in the gliding
/// pose after a glide ended).
pub visually: bool,
pub in_water: bool,
}
impl SwimAnimation {
/// `LivingEntity.updateSwimAmount`.
pub fn tick(&mut self, visually: bool, in_water: bool) {
self.old = self.amount;
self.amount = if visually {
(self.amount + 0.09).min(1.0)
} else {
(self.amount - 0.09).max(0.0)
};
self.visually = visually;
self.in_water = in_water;
}
/// `LivingEntity.getSwimAmount`.
pub fn amount(&self, partial: f32) -> f32 {
self.old + partial * (self.amount - self.old)
}
}
#[cfg(test)]
mod elytra_tests {
use super::*;
+152
View File
@@ -276,6 +276,12 @@ pub struct Hum {
pub charge: (f32, f32),
/// `PiglinModel.setupAttackAnimation`: swing a held weapon down.
pub weapon_swing: bool,
/// `swimAmount` at this frame.
pub swim: f32,
/// `isUsingItem`: the swim stroke leaves the arms alone.
pub using_item: bool,
/// The arm the current swing moves (`Some(true)` for the right one).
pub swing_right_arm: Option<bool>,
}
impl Hum {
pub fn new(right: ArmPose, left: ArmPose) -> Self {
@@ -290,6 +296,9 @@ impl Hum {
holding: false,
charge: (0.0, 0.0),
weapon_swing: false,
swim: 0.0,
using_item: false,
swing_right_arm: None,
}
}
}
@@ -455,6 +464,86 @@ pub(super) fn humanoid(p: &mut Poses, s: &State, h: &Hum) {
}
bob(p, "right_arm", s.age, 1.0);
bob(p, "left_arm", s.age, -1.0);
if h.swim > 0.0 {
swim(p, s.pos, h);
}
}
/// `Mth.rotLerpRad`.
fn rot_lerp_rad(a: f32, from: f32, to: f32) -> f32 {
let mut diff = to - from;
while diff < -PI {
diff += PI * 2.0;
}
while diff >= PI {
diff -= PI * 2.0;
}
from + a * diff
}
/// `HumanoidModel.setupSwimAnimation`: the stroke of both arms over 26
/// walk-animation units, the head down and a slow flutter kick. The left arm
/// eases the short way round, the right one linearly, as in vanilla.
fn swim(p: &mut Poses, pos: f32, h: &Hum) {
let amount = h.swim;
if !h.fall_flying {
let x = p.get("head")[3];
p.xrot(
"head",
rot_lerp_rad(amount, x, -std::f32::consts::FRAC_PI_4),
);
}
let swim_pos = pos % 26.0;
let right_amount = if h.swing_right_arm == Some(true) {
0.0
} else {
amount
};
let left_amount = if h.swing_right_arm == Some(false) {
0.0
} else {
amount
};
let lerp = |a: f32, from: f32, to: f32| from + a * (to - from);
let quadratic = |x: f32| -65.0 * x + x * x;
if !h.using_item {
// Targets (x, y, z) for the left and right arm.
let targets = if swim_pos < 14.0 {
let stroke = 1.870_796_4 * quadratic(swim_pos) / quadratic(14.0);
Some(([0.0, PI, PI + stroke], [0.0, PI, PI - stroke]))
} else if swim_pos < 22.0 {
let t = (swim_pos - 14.0) / 8.0;
let x = PI / 2.0 * t;
Some((
[x, PI, 5.012_389 - 1.870_796_4 * t],
[x, PI, 1.270_796_3 + 1.870_796_4 * t],
))
} else if swim_pos < 26.0 {
let t = (swim_pos - 22.0) / 4.0;
let x = PI / 2.0 - PI / 2.0 * t;
Some(([x, PI, PI], [x, PI, PI]))
} else {
None
};
if let Some((left, right)) = targets {
for (i, target) in left.into_iter().enumerate() {
let angle = &mut p.get("left_arm")[3 + i];
*angle = rot_lerp_rad(left_amount, *angle, target);
}
for (i, target) in right.into_iter().enumerate() {
let angle = &mut p.get("right_arm")[3 + i];
*angle = lerp(right_amount, *angle, target);
}
}
}
let x = p.get("left_leg")[3];
p.xrot(
"left_leg",
lerp(amount, x, 0.3 * (pos * 0.333_333_34 + PI).mcos()),
);
let x = p.get("right_leg")[3];
p.xrot(
"right_leg",
lerp(amount, x, 0.3 * (pos * 0.333_333_34).mcos()),
);
}
/// Apply the mob's model animation to `p`.
pub fn setup(
@@ -580,6 +669,9 @@ pub fn setup(
}
h.crouching = m.extra.crouching;
h.passenger = m.extra.passenger;
h.swim = m.extra.swim.amount(s.partial);
h.using_item = m.extra.using_item > 0;
h.swing_right_arm = m.extra.swing_right_arm;
humanoid(p, s, &h);
if m.ai.aggressive && !bow {
// SkeletonModel melee pose.
@@ -710,4 +802,64 @@ mod flight_pose_tests {
assert_eq!(flight.get("head")[3], -std::f32::consts::FRAC_PI_4);
assert_eq!(flight.get("right_leg")[3], ground.get("right_leg")[3] / 8.0);
}
#[test]
fn swimming_strokes_the_arms_and_kicks() {
let state = State {
pos: 7.0,
speed: 1.0,
age: 0.0,
y_rot: 0.0,
x_rot: 30.0,
swing: 0.0,
baby: false,
partial: 0.0,
};
let make = || Poses {
map: ["head", "right_arm", "left_arm", "right_leg", "left_leg"]
.into_iter()
.map(|n| (n.to_string(), [0.0; 9]))
.collect(),
dummy: [0.0; 9],
skipped: Default::default(),
hidden: Default::default(),
};
let same_angle = |a: f32, b: f32| ((a - b + PI).rem_euclid(PI * 2.0) - PI).abs() < 1e-5;
let mut h = Hum::new(ArmPose::Empty, ArmPose::Empty);
h.swim = 1.0;
let mut p = make();
humanoid(&mut p, &state, &h);
// Mid-stroke: both arms sweep out from overhead by the quadratic.
let stroke = 1.870_796_4 * (-65.0 * 7.0 + 49.0) / (-65.0 * 14.0 + 196.0);
assert_eq!(p.get("right_arm")[5], PI - stroke);
assert!(same_angle(p.get("left_arm")[5], PI + stroke));
assert_eq!(p.get("right_arm")[4], PI);
assert!(same_angle(p.get("head")[3], -std::f32::consts::FRAC_PI_4));
assert!(same_angle(
p.get("right_leg")[3],
0.3 * (7.0f32 * 0.333_333_34).mcos()
));
// Using an item keeps the arms; a swing frees its own arm only.
let mut using = make();
h.using_item = true;
humanoid(&mut using, &state, &h);
assert_eq!(using.get("right_arm")[4], 0.0);
h.using_item = false;
h.swing_right_arm = Some(true);
let mut swinging = make();
humanoid(
&mut swinging,
&State {
swing: 0.5,
..state
},
&h,
);
assert!(swinging.get("right_arm")[4] < 1.0);
assert!(same_angle(swinging.get("left_arm")[4], PI));
// Out of the pose nothing changes.
let mut dry = make();
humanoid(&mut dry, &state, &Hum::new(ArmPose::Empty, ArmPose::Empty));
assert_eq!(dry.get("head")[3], 30.0f32.to_radians());
}
}
+25 -11
View File
@@ -765,6 +765,17 @@ pub fn base_transform_at(m: &Mob, alpha: f32, origin: glam::Mat4) -> glam::Mat4
.unwrap_or_else(|| glam::Mat4::from_rotation_y((180.0 - body).to_radians())),
};
let mut base = origin * rotation;
if m.death_time > 0 && !super::creaking::tearing_down(m) {
let f = ((m.death_time as f32 + alpha - 1.0) / 20.0 * 1.6)
.sqrt()
.min(1.0);
base *= glam::Mat4::from_rotation_z(f * flip_degrees(m).to_radians());
} else if matches!(m.custom_name.as_deref(), Some("Dinnerbone" | "Grumm")) {
// isEntityUpsideDown
base *= glam::Mat4::from_translation(glam::Vec3::new(0.0, m.height() + 0.1, 0.0))
* glam::Mat4::from_rotation_z(PI);
}
// AvatarRenderer.setupRotations, after LivingEntityRenderer's.
if m.extra.fall_flying {
let ticks = m.extra.fall_fly_ticks as f32 + alpha;
let scale = (ticks * ticks / 100.0).min(1.0);
@@ -785,17 +796,20 @@ pub fn base_transform_at(m: &Mob, alpha: f32, origin: glam::Mat4) -> glam::Mat4
(sign * horizon_core::jmath::acos(dot.abs().min(1.0))) as f32,
);
}
}
if m.death_time > 0 && !super::creaking::tearing_down(m) {
let f = ((m.death_time as f32 + alpha - 1.0) / 20.0 * 1.6)
.sqrt()
.min(1.0);
base *= glam::Mat4::from_rotation_z(f * flip_degrees(m).to_radians());
} else if matches!(m.custom_name.as_deref(), Some("Dinnerbone" | "Grumm")) {
// isEntityUpsideDown
base *= glam::Mat4::from_translation(glam::Vec3::new(0.0, m.height() + 0.1, 0.0))
* glam::Mat4::from_rotation_z(PI);
} else if m.extra.swim.amount(alpha) > 0.0 {
// AvatarRenderer.setupRotations: tip forward with the swim amount,
// following the pitch in water, then lie along the swimming box.
let amount = m.extra.swim.amount(alpha);
let pitch = m.previous_head_pitch + (m.head_pitch - m.previous_head_pitch) * alpha;
let target = if m.extra.swim.in_water {
-90.0 - pitch
} else {
-90.0
};
base *= glam::Mat4::from_rotation_x((amount * target).to_radians());
if m.extra.swim.visually {
base *= glam::Mat4::from_translation(glam::Vec3::new(0.0, -1.0, 0.3));
}
}
base *= species_rotations(m, alpha);
base *= glam::Mat4::from_scale(glam::Vec3::new(-1.0, -1.0, 1.0));