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:
@@ -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.
|
||||
|
||||
@@ -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::*;
|
||||
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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));
|
||||
|
||||
Reference in New Issue
Block a user