Merge branch 'split/cosmetics-own' into split/cosmetics-fx-api

# Conflicts:
#	crates/horizon-hooks/src/lib.rs

crates/horizon-client/src/game.rs

@@ -6773,8 +6773,8 @@ impl Game<'_> {
                 .extend(out.drain(player_start..));
         }
         self.mark_motion(out.len(), 0);
-        // Companions in first person, trails and auras (game/cosmetics/fx.rs).
-        self.cosmetics_fx_geometry(camera, alpha, &mut out);
+        // What crates draw around players: first person, see-through (game/player_hooks.rs).
+        self.players_after_geometry(camera, alpha, &mut out);
         self.mark_entity(out.len(), "minecraft:evoker_fangs");
         self.fangs_geometry(camera, alpha, &mut out);
         self.block_item_display_geometry(camera, alpha, &mut out);

crates/horizon-client/src/game/cosmetics.rs

@@ -21,7 +21,7 @@ use horizon_cosmetics::prefs::{self, Others};
 use horizon_cosmetics::trail::{Budget, Emitter};
 use horizon_cosmetics::{Item, Slot};
 use horizon_hooks::players::{
-    Badge, Bone, CameraOverride, CameraView, Frame, Gear, Kind, Mark, Mesh, NameDecoration,
+    Badge, Bone, CameraOverride, CameraView, Frame, Gear, Kind, Look, Mark, Mesh, NameDecoration,
     PlayerDraw, PlayerModel, PlayerModels, Quad, SpriteStore, Sprites,
 };
 use std::cell::{Cell, RefCell};
@@ -66,8 +66,8 @@ pub(super) struct Cosmetics {
     /// Items drawn whose texture isn't in the atlas yet.
     uploads: RefCell<Vec<Arc<Item>>>,
     frame: Cell<u32>,
-    /// Kept between players so a frame of avatars allocates none: the wearer's body, an item.
-    poses: RefCell<(Poses, Poses)>,
+    /// Kept between players so a frame of avatars allocates none: a companion or an aura.
+    poses: RefCell<Poses>,
     /// Item files from a folder (`HORIZON_COSMETICS_LOCAL`): mannequins wear them too.
     local: bool,
     /// Companions, trails and auras.
@@ -831,7 +831,7 @@ impl Seat {
                         matrix
                     }
                 };
-                draw.draw(&mesh, matrix, uv, &mut |p| {
+                draw.draw(&mesh, matrix, Look::new(uv), &mut |p| {
                     item.animate(ticks, |name, pose| *p.pose(name) = pose);
                     if let (Some((t, w)), Some(e)) = (emoting, &item.emote) {
                         e.pose_props(t, |n| item.rest(n), |n, pose| *p.pose(n) = pose);
@@ -1043,111 +1043,47 @@ impl Game<'_> {
         }
     }
 
-    /// The cosmetics `m` wears, on its bones. `gpu`: posed on the GPU (the mob pass's skin
-    /// frame, begun); the bounds of what went there come back, for culling. Else the vertices
-    /// go to `out`. `camera`: where the world view's camera is; None in a picture of the player
-    /// (the inventory), which shows no companion, trail or aura.
+    /// The companion, trail and aura `m` wears, in the world (`camera`: where the view's camera
+    /// is); the items on its bones are the hook's (`Seat::player_layers`). `gpu`: a companion
+    /// goes on the GPU's skin path (the mob pass's skin frame, begun) and the bounds of what went
+    /// there come back, for culling; else its vertices go to `out`.
     #[allow(clippy::too_many_arguments)]
-    pub(super) fn cosmetics_geometry(
+    pub(super) fn cosmetics_fx_of(
         &self,
         m: &Mob,
         own: bool,
         base: glam::Mat4,
-        camera: Option<glam::DVec3>,
+        camera: glam::DVec3,
         alpha: f32,
         light: u32,
         gpu: bool,
         out: &mut Vec<horizon_client::mesher::Vertex>,
     ) -> Option<(glam::Vec3, glam::Vec3)> {
-        use horizon_client::mobs::{anim, render};
-        let worn = self.worn(m, own);
-        // An emote's props: its time and weight while it plays.
-        let ticks = m.age as f32 + alpha;
-        let emote = emotes::playing(m).and_then(|p| {
-            let (t, w) = p.at(ticks)?;
-            (p.item.vertices > 0).then_some((&p.item, t, w))
-        });
-        if worn.is_none() && emote.is_none() || horizon_client::mobs::trader::is_invisible(m) {
+        // "Name tags only": other players' styles beside their names, nothing around them.
+        let bodies = own || self.settings.extras.effective_others() == Others::Shown;
+        // The player's own in first person: only its companion, drawn after the drain of the
+        // first-person model (`cosmetics_fx_geometry`).
+        if !bodies || own && !self.own_body_in_view() {
             return None;
         }
-        // The avatar's body, posed as it is drawn.
-        let (key, _) = render::body(m);
-        let body = m.kind.layer(&key).unwrap_or(&m.kind.model);
-        let mut scratch = self.cosmetics.poses.borrow_mut();
-        let (body_poses, poses) = &mut *scratch;
-        // Others' items on the body are the hook's (`Seat::player_layers`): their companions,
-        // trails and auras alone are drawn here, on no bone.
-        if own {
-            body_poses.reset(body);
-            let data = self.res.mob_data();
-            anim::setup(m, &anim::state(m, alpha), body_poses, &data.animations);
+        let worn = self.worn(m, own)?;
+        if horizon_client::mobs::trader::is_invisible(m) {
+            return None;
         }
+        let mut poses = self.cosmetics.poses.borrow_mut();
         let mut bounds = None;
-        // Items on one bone (a back item, a shoulder pet and a shirt ride the body) share its
-        // matrix: the head, the body and the two arms at most.
-        let mut bones: [Option<(horizon_cosmetics::Bone, glam::Mat4)>; 4] = [None; 4];
-        // "Name tags only": other players' styles beside their names, nothing on their bodies.
-        let bodies = own || self.settings.extras.effective_others() == Others::Shown;
-        let worn_items = worn.iter().flat_map(|w| w.iter()).map(|i| (i, None));
-        let emote_items = emote.map(|(i, t, w)| (i, Some((t, w))));
-        for (item, emoting) in worn_items.chain(emote_items) {
-            if emoting.is_none() && !bodies {
-                continue;
-            }
-            if let (Some(camera), Slot::Companion | Slot::Trail | Slot::Aura) = (camera, item.slot)
-            {
-                // The player's own in first person: only its companion, drawn after the drain
-                // of the first-person model (`cosmetics_fx_geometry`).
-                if !(own && !self.own_body_in_view()) {
-                    let at = fx::Wearer {
-                        m,
-                        own,
-                        key: if own { OWN } else { m.id },
-                        base,
-                        camera,
-                        alpha,
-                        light,
-                    };
-                    bounds = self.cosmetics_fx(&at, item, gpu, bounds, poses, out);
-                }
-                continue;
-            }
-            if !own {
-                continue;
-            }
-            if emoting.is_none() && covered(super::player_hooks::gear(m), item.slot) {
-                continue;
-            }
-            let Some((models, uv)) = self.cosmetics_baked(item) else {
-                continue;
-            };
-            for (bone_of, model) in &models {
-                let known = bones.iter().flatten().find(|(b, _)| b == bone_of);
-                let bone = match known {
-                    Some(&(_, matrix)) => matrix,
-                    None => {
-                        let Some(matrix) =
-                            render::part_matrix(body, base, body_poses, bone_of.part(), 0.0)
-                        else {
-                            continue;
-                        };
-                        if let Some(free) = bones.iter_mut().find(|b| b.is_none()) {
-                            *free = Some((*bone_of, matrix));
-                        }
-                        matrix
-                    }
+        for item in worn.iter() {
+            if let Slot::Companion | Slot::Trail | Slot::Aura = item.slot {
+                let at = fx::Wearer {
+                    m,
+                    own,
+                    key: if own { OWN } else { m.id },
+                    base,
+                    camera,
+                    alpha,
+                    light,
                 };
-                poses.reset(model);
-                item.animate(ticks, |name, pose| *poses.get(name) = pose);
-                if let (Some((t, w)), Some(e)) = (emoting, &item.emote) {
-                    e.pose_props(t, |n| item.rest(n), |n, pose| *poses.get(n) = pose);
-                    // Props grow in and shrink out with the emote's blend.
-                    let root = poses.get(&model.name);
-                    for s in &mut root[6..9] {
-                        *s *= w;
-                    }
-                }
-                bounds = self.cosmetics_model(model, bone, poses, uv, light, gpu, bounds, out);
+                bounds = self.cosmetics_fx(&at, item, gpu, bounds, &mut poses, out);
             }
         }
         bounds
@@ -1544,6 +1480,22 @@ mod tests {
         fn ticks(&self) -> f32 {
             102.0
         }
+        fn base(&self) -> [[f32; 4]; 4] {
+            LEFT_ARM
+        }
+        fn motion(&self) -> horizon_hooks::players::Motion {
+            Default::default()
+        }
+        fn view(&self) -> horizon_hooks::players::View {
+            Default::default()
+        }
+        fn particles(
+            &mut self,
+            _: [f32; 4],
+            _: &[horizon_hooks::players::Particle],
+            _: horizon_hooks::players::Light,
+        ) {
+        }
         fn bone(&mut self, bone: Bone) -> Option<[[f32; 4]; 4]> {
             (bone == Bone::LeftArm).then_some(LEFT_ARM)
         }
@@ -1557,7 +1509,7 @@ mod tests {
             &mut self,
             mesh: &Arc<Mesh>,
             matrix: [[f32; 4]; 4],
-            uv: [f32; 4],
+            look: Look,
             pose: &mut dyn FnMut(&mut dyn horizon_hooks::players::PartPoses),
         ) {
             struct Rest(std::collections::HashMap<String, [f32; 9]>);
@@ -1569,8 +1521,12 @@ mod tests {
             let mut rest = Rest([(mesh.name.clone(), mesh.pose)].into());
             pose(&mut rest);
             let root = rest.0[&mesh.name];
-            self.drawn
-                .push((mesh.name.clone(), matrix, uv, [root[6], root[7], root[8]]));
+            self.drawn.push((
+                mesh.name.clone(),
+                matrix,
+                look.uv,
+                [root[6], root[7], root[8]],
+            ));
         }
     }
 

crates/horizon-client/src/game/cosmetics/emotes.rs

@@ -71,11 +71,6 @@ pub(in crate::game) fn pose_playing(pose: Option<&Arc<dyn BodyPose>>) -> Option<
     any.downcast_ref::<EmotePose>().map(|e| &e.0)
 }
 
-/// The emote `m` plays, if any.
-pub(in crate::game) fn playing(m: &Mob) -> Option<&Playing> {
-    pose_playing(m.emote.as_ref())
-}
-
 /// The pose that plays `next` where `now` is laid, unless it plays that already (None: keep
 /// it; a new one allocates).
 fn replaced(

crates/horizon-client/src/game/cosmetics/fx.rs

@@ -314,8 +314,7 @@ impl Game<'_> {
             light = FULL_LIGHT;
         }
         let mut poses = self.cosmetics.poses.borrow_mut();
-        let poses = &mut poses.1;
-        self.pose_companion(item, m, alpha, poses, &model);
-        self.cosmetics_model(&model, matrix, poses, uv, light, false, None, out);
+        self.pose_companion(item, m, alpha, &mut poses, &model);
+        self.cosmetics_model(&model, matrix, &poses, uv, light, false, None, out);
     }
 }

crates/horizon-client/src/game/perspective.rs

@@ -800,19 +800,8 @@ impl Game<'_> {
                 packed,
                 out,
             );
-            if super::cosmetics::enabled() {
-                let base = horizon_client::mobs::render::base_transform(m, alpha as f32, camera);
-                self.cosmetics_geometry(
-                    m,
-                    true,
-                    base,
-                    Some(camera),
-                    alpha as f32,
-                    packed,
-                    false,
-                    out,
-                );
-            }
+            let world = horizon_hooks::players::Pass::World;
+            self.own_layers_geometry(m, world, camera, alpha as f32, packed, out);
             self.player_elytra_geometry(m, chest, camera, alpha as f32, packed, out);
             self.spin_attack_geometry(m, camera, alpha as f32, packed, out);
             self.shoulder_parrots_geometry(m, camera, alpha as f32, packed, out);
@@ -926,10 +915,8 @@ impl Game<'_> {
             240 | 240 << 8,
             &mut verts,
         );
-        if super::cosmetics::enabled() {
-            let base = horizon_client::mobs::render::base_transform(&m, 1.0, camera);
-            self.cosmetics_geometry(&m, true, base, None, 1.0, 240 | 240 << 8, false, &mut verts);
-        }
+        let picture = horizon_hooks::players::Pass::Picture;
+        self.own_layers_geometry(&m, picture, camera, 1.0, 240 | 240 << 8, &mut verts);
         // `WingsLayer` draws through `RenderTypes.armorCutoutNoCull`: the
         // wings' faces show from both sides (the elytra texture is empty on
         // the face that looks at the body).

crates/horizon-client/src/game/player_hooks.rs

@@ -11,8 +11,8 @@ use horizon_client::mobs::anim::{self, BodyPose, PooledPoses, Poses};
 use horizon_client::mobs::{Mob, Part, Polygon, render};
 use horizon_hooks::engine;
 use horizon_hooks::players::{
-    Bone, CameraView, Frame, Gear, Kind, Mesh, PartPoses, Pass, PlayerDraw, PlayerModel,
-    PlayerModels, SpriteStore, Sprites,
+    Bone, CameraView, Frame, Gear, Kind, Light, Look, Mesh, Motion, PartPoses, Particle, Pass,
+    PlayerDraw, PlayerModel, PlayerModels, SpriteStore, Sprites, View,
 };
 use std::sync::Arc;
 
@@ -182,6 +182,14 @@ fn part_of(mesh: &Arc<Mesh>) -> Arc<Part> {
     })
 }
 
+/// Full light, packed as the vertices carry it.
+const FULL: u32 = 240 | 240 << 8;
+
+thread_local! {
+    /// What crates draw see-through this frame, added after every player.
+    static SEE_THROUGH: std::cell::RefCell<Vec<Vertex>> = const { std::cell::RefCell::new(Vec::new()) };
+}
+
 /// Forgets the meshes no crate holds any more (once a frame).
 fn forget_meshes() {
     let _ = MESHES.try_with(|m| {
@@ -199,7 +207,7 @@ impl PartPoses for PosesOf<'_> {
     }
 }
 
-/// A player model drawn in the world pass, as a crate draws on it: posed on the GPU's skin path
+/// A player model drawn, as a crate draws on it: posed on the GPU's skin path
 /// when `gpu` (the mob pass's skin frame, begun; the bounds of what went there grow, for
 /// culling), else its vertices go to `out`.
 struct DrawPlayer<'a, 'g> {
@@ -208,6 +216,7 @@ struct DrawPlayer<'a, 'g> {
     pass: Pass,
     /// The model's matrix (`render::base_transform`).
     base: glam::Mat4,
+    camera: glam::DVec3,
     alpha: f32,
     light: u32,
     gpu: bool,
@@ -223,6 +232,19 @@ impl DrawPlayer<'_, '_> {
         let (key, _) = render::body(self.m);
         self.m.kind.layer(&key).unwrap_or(&self.m.kind.model)
     }
+
+    /// `light` packed; `at`: the place `Light::AtPlace` reads, relative to the camera.
+    fn packed(&self, light: Light, at: glam::Vec3) -> u32 {
+        match light {
+            Light::Full => FULL,
+            Light::AtPlace => {
+                let p = (self.camera + at.as_dvec3()).floor();
+                let l = self.game.world.light(p.x as i32, p.y as i32, p.z as i32);
+                (u32::from(l >> 4) * 16) | ((u32::from(l & 15) * 16) << 8)
+            }
+            _ => self.light,
+        }
+    }
 }
 
 impl PlayerDraw for DrawPlayer<'_, '_> {
@@ -234,7 +256,52 @@ impl PlayerDraw for DrawPlayer<'_, '_> {
         self.m.age as f32 + self.alpha
     }
 
+    fn base(&self) -> [[f32; 4]; 4] {
+        self.base.to_cols_array_2d()
+    }
+
+    fn motion(&self) -> Motion {
+        let (m, a) = (self.m, self.alpha);
+        let t = f64::from(a);
+        let (p, n) = (m.previous, m.position);
+        let feet = [
+            p.x + (n.x - p.x) * t,
+            p.y + (n.y - p.y) * t,
+            p.z + (n.z - p.z) * t,
+        ];
+        let turn = horizon_client::mobs::living::wrap(m.head_yaw - m.previous_head_yaw);
+        let yaw = m.previous_head_yaw + turn * a;
+        let pitch = m.previous_head_pitch + (m.head_pitch - m.previous_head_pitch) * a;
+        let asleep = m.extra.avatar_pose == horizon_client::pose::Pose::Sleeping;
+        let swimming = m.extra.swim.amount(a) > 0.0;
+        Motion::new(feet, yaw, pitch).poses(
+            m.extra.crouching,
+            asleep,
+            m.extra.fall_flying,
+            swimming,
+        )
+    }
+
+    fn view(&self) -> View {
+        let q = self.game.camera_orientation();
+        let (right, up) = (
+            (q * glam::Vec3::X).to_array(),
+            (q * glam::Vec3::Y).to_array(),
+        );
+        let (yaw, pitch) = (self.game.yaw.to_radians(), self.game.pitch.to_radians());
+        let forward = [
+            -yaw.sin() * pitch.cos(),
+            -pitch.sin(),
+            yaw.cos() * pitch.cos(),
+        ];
+        let left = [yaw.cos(), 0.0, yaw.sin()];
+        View::new(self.camera.to_array(), right, up).looking(forward, left)
+    }
+
     fn bone(&mut self, bone: Bone) -> Option<[[f32; 4]; 4]> {
+        if self.pass == Pass::FirstPerson {
+            return None;
+        }
         if self.body.is_none() {
             let mut poses = Poses::pooled();
             poses.reset(self.body());
@@ -260,13 +327,30 @@ impl PlayerDraw for DrawPlayer<'_, '_> {
         &mut self,
         mesh: &Arc<Mesh>,
         matrix: [[f32; 4]; 4],
-        uv: [f32; 4],
+        look: Look,
         pose: &mut dyn FnMut(&mut dyn PartPoses),
     ) {
         let model = part_of(mesh);
         let matrix = glam::Mat4::from_cols_array_2d(&matrix);
+        let (uv, light) = (look.uv, self.packed(look.light, matrix.w_axis.truncate()));
         self.poses.reset(&model);
         pose(&mut PosesOf(&mut self.poses));
+        let poses = &self.poses;
+        if let Some(alpha) = look.see_through {
+            let color = ((alpha.clamp(0.0, 1.0) * 255.0) as u32) << 24 | 0x00FF_FFFF;
+            let pose_of = |p: &Part| poses.pose(p);
+            SEE_THROUGH.with_borrow_mut(|out| {
+                let start = out.len();
+                horizon_client::mobs::render_model(&model, matrix, &pose_of, uv, light, 0, out);
+                for v in &mut out[start..] {
+                    v.color = color;
+                    // Seen through, a face turned away would add to the near one: `entity.wgsl`
+                    // drops back faces, so it is `alpha` at most.
+                    v.normal[3] = horizon_client::mesher::SHADED_CULL_W;
+                }
+            });
+            return;
+        }
         if self.gpu {
             let mut models = self.game.skin_models.borrow_mut();
             let mut frame = self.game.skin_frame.borrow_mut();
@@ -276,24 +360,37 @@ impl PlayerDraw for DrawPlayer<'_, '_> {
                 uv,
                 scroll: 0.0,
                 color: 0xFFFF_FFFF,
-                light: self.light,
+                light,
                 overlay: 0,
             };
-            if skin.draw(&model, matrix, &self.poses, paint) {
+            if skin.draw(&model, matrix, poses, paint) {
                 self.bounds = skin.bounds;
                 return;
             }
         }
-        let poses = &self.poses;
-        horizon_client::mobs::render_model(
-            &model,
-            matrix,
-            &|p: &Part| poses.pose(p),
-            uv,
-            self.light,
-            0,
-            self.out,
-        );
+        let pose_of = |p: &Part| poses.pose(p);
+        horizon_client::mobs::render_model(&model, matrix, &pose_of, uv, light, 0, self.out);
+    }
+
+    fn particles(&mut self, uv: [f32; 4], particles: &[Particle], light: Light) {
+        let light = self.packed(light, glam::Vec3::ZERO);
+        SEE_THROUGH.with_borrow_mut(|out| {
+            for q in particles {
+                let color = ((q.alpha.clamp(0.0, 1.0) * 255.0) as u32) << 24 | 0x00FF_FFFF;
+                for (corner, [u, v]) in q.corners.iter().zip(q.uv) {
+                    out.push(Vertex {
+                        pos: *corner,
+                        uv: [uv[0] + (uv[2] - uv[0]) * u, uv[1] + (uv[3] - uv[1]) * v],
+                        layer: 0,
+                        color,
+                        light,
+                        // Unlit: a particle keeps its colour whichever way it faces.
+                        normal: [0, 0, 0, 0],
+                        glint_uv: [0.0, 0.0],
+                    });
+                }
+            }
+        });
     }
 }
 
@@ -324,6 +421,7 @@ impl Game<'_> {
                 m,
                 pass: Pass::World,
                 base,
+                camera,
                 alpha,
                 light,
                 gpu,
@@ -336,7 +434,7 @@ impl Game<'_> {
             bounds = draw.bounds;
         }
         let worn = super::cosmetics::enabled()
-            .then(|| self.cosmetics_geometry(m, false, base, Some(camera), alpha, light, gpu, out))
+            .then(|| self.cosmetics_fx_of(m, false, base, camera, alpha, light, gpu, out))
             .flatten();
         match (bounds, worn) {
             (Some((l, h)), Some((lo, hi))) => Some((l.min(lo), h.max(hi))),
@@ -344,6 +442,93 @@ impl Game<'_> {
         }
     }
 
+    /// What crates draw on the window's own model `m` (its vertices to `out`): in the world in
+    /// third person (`Pass::World`, then the cosmetics' companion, trail and aura still drawn
+    /// here), or in the inventory's picture of it (`Pass::Picture`). `camera`: the world view's
+    /// camera, or the picture's.
+    pub(super) fn own_layers_geometry(
+        &self,
+        m: &Mob,
+        pass: Pass,
+        camera: glam::DVec3,
+        alpha: f32,
+        light: u32,
+        out: &mut Vec<Vertex>,
+    ) {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        let fx = pass == Pass::World && super::cosmetics::enabled();
+        if !engine::any() && !fx {
+            return;
+        }
+        let base = render::base_transform(m, alpha, camera);
+        if engine::any() {
+            let model = model(m, Kind::Own, self.remote.as_ref().map(|r| r.profile()));
+            let mut draw = DrawPlayer {
+                game: self,
+                m,
+                pass,
+                base,
+                camera,
+                alpha,
+                light,
+                gpu: false,
+                out: &mut *out,
+                bounds: None,
+                body: None,
+                poses: Poses::pooled(),
+            };
+            engine::player_layers(&model, &mut draw);
+        }
+        if fx {
+            self.cosmetics_fx_of(m, true, base, camera, alpha, light, false, out);
+        }
+    }
+
+    /// After every player (`game.rs`): what crates draw around the window's own model in first
+    /// person, the cosmetics' fx still drawn here, then what was drawn see-through, in one span.
+    pub(super) fn players_after_geometry(
+        &self,
+        camera: glam::DVec3,
+        alpha: f64,
+        out: &mut Vec<Vertex>,
+    ) {
+        if engine::any()
+            && !self.own_body_in_view()
+            && let Some(m) = self.player_model.as_ref()
+        {
+            let own = model(m, Kind::Own, self.remote.as_ref().map(|r| r.profile()));
+            let own = own.looks(own.gear, own.invisible || self.own_invisible());
+            self.mark_entity(out.len(), "minecraft:player");
+            let mut draw = DrawPlayer {
+                game: self,
+                m,
+                pass: Pass::FirstPerson,
+                base: render::base_transform(m, alpha as f32, camera),
+                camera,
+                alpha: alpha as f32,
+                light: FULL,
+                gpu: false,
+                out: &mut *out,
+                bounds: None,
+                body: None,
+                poses: Poses::pooled(),
+            };
+            engine::first_person(&own, &mut draw);
+        }
+        self.cosmetics_fx_geometry(camera, alpha, out);
+        let _ = SEE_THROUGH.try_with(|v| {
+            let mut v = v.borrow_mut();
+            if !v.is_empty() {
+                self.mark_translucent_entity(out.len(), "minecraft:player");
+                out.extend_from_slice(&v);
+                v.clear();
+            }
+        });
+    }
+
     /// Once a frame, before drawing.
     pub(super) fn client_hooks_frame(&mut self) {
         debug_assert!(
@@ -358,6 +543,7 @@ impl Game<'_> {
         let frame = Frame::new(connection, self.integrated.is_some());
         engine::frame(&frame, &mut HookStore(self));
         forget_meshes();
+        let _ = SEE_THROUGH.try_with(|v| v.borrow_mut().clear());
         self.cosmetics_frame();
     }
 

crates/horizon-hooks/src/lib.rs

@@ -77,6 +77,10 @@ pub trait Hooks: Sync {
     /// Draws on a player model, after its vanilla layers, each time it is drawn.
     fn player_layers(&self, _model: &players::PlayerModel, _draw: &mut dyn players::PlayerDraw) {}
 
+    /// Draws around the window's own model while its body is out of view (first person), once a
+    /// frame after the first-person model: [`players::Pass::FirstPerson`].
+    fn first_person(&self, _own: &players::PlayerModel, _draw: &mut dyn players::PlayerDraw) {}
+
     /// The resolver of `friend:` addresses this crate offers ([`tunnel`]); the first hook that
     /// offers one is used. Asked on the network thread when joining and on the game thread when
     /// an address is shown, never per frame.
@@ -214,6 +218,13 @@ pub mod engine {
         }
     }
 
+    /// [`Hooks::first_person`].
+    pub fn first_person(own: &players::PlayerModel, draw: &mut dyn players::PlayerDraw) {
+        for hooks in all() {
+            hooks.first_person(own, draw);
+        }
+    }
+
     /// [`Hooks::camera`].
     pub fn camera(own: &players::CameraView) -> Option<players::CameraOverride> {
         all().iter().find_map(|h| h.camera(own))
@@ -282,7 +293,14 @@ mod tests {
                 return;
             };
             let turn = draw.ticks() / 100.0;
-            draw.draw(&HAT, head, uv, &mut |p| p.pose("brim")[4] = turn);
+            let look = players::Look::new(uv);
+            draw.draw(&HAT, head, look, &mut |p| p.pose("brim")[4] = turn);
+        }
+        /// A spark at the eyes, as bright as the head turns.
+        fn first_person(&self, _: &players::PlayerModel, draw: &mut dyn players::PlayerDraw) {
+            let alpha = draw.motion().head_yaw / 90.0;
+            let spark = players::Particle::new([[0.0; 3]; 4], [[0.0; 2]; 4], alpha);
+            draw.particles([0.0; 4], &[spark], players::Light::Full);
         }
         fn tick(&self, models: &mut dyn players::PlayerModels) {
             let mut ids = Vec::new();
@@ -359,9 +377,10 @@ mod tests {
             ))
         });
 
-    /// A player drawn at age 50, its head where the camera is; logs each draw.
+    /// A player drawn at age 50, its head where the camera is, turned 45 degrees; logs each draw
+    /// and its particles' alphas.
     #[derive(Default)]
-    struct Canvas(Vec<(String, [[f32; 4]; 4], [f32; 4], f32)>);
+    struct Canvas(Vec<(String, [[f32; 4]; 4], [f32; 4], f32)>, Vec<f32>);
     impl players::PlayerDraw for Canvas {
         fn pass(&self) -> players::Pass {
             players::Pass::World
@@ -369,6 +388,15 @@ mod tests {
         fn ticks(&self) -> f32 {
             50.0
         }
+        fn base(&self) -> [[f32; 4]; 4] {
+            [[1.0, 0.0, 0.0, 0.0]; 4]
+        }
+        fn motion(&self) -> players::Motion {
+            players::Motion::new([0.0; 3], 45.0, 0.0)
+        }
+        fn view(&self) -> players::View {
+            players::View::default()
+        }
         fn bone(&mut self, bone: players::Bone) -> Option<[[f32; 4]; 4]> {
             (bone == players::Bone::Head).then_some([[1.0, 0.0, 0.0, 0.0]; 4])
         }
@@ -382,7 +410,7 @@ mod tests {
             &mut self,
             mesh: &std::sync::Arc<players::Mesh>,
             matrix: [[f32; 4]; 4],
-            uv: [f32; 4],
+            look: players::Look,
             pose: &mut dyn FnMut(&mut dyn players::PartPoses),
         ) {
             struct Rest([f32; 9]);
@@ -393,7 +421,10 @@ mod tests {
             }
             let mut brim = Rest(mesh.children[0].pose);
             pose(&mut brim);
-            self.0.push((mesh.name.clone(), matrix, uv, brim.0[4]));
+            self.0.push((mesh.name.clone(), matrix, look.uv, brim.0[4]));
+        }
+        fn particles(&mut self, _: [f32; 4], particles: &[players::Particle], _: players::Light) {
+            self.1.extend(particles.iter().map(|p| p.alpha));
         }
     }
 
@@ -442,6 +473,8 @@ mod tests {
                 0.5
             )]
         );
+        engine::first_person(&model(players::Kind::Own), &mut canvas);
+        assert_eq!(canvas.1, [0.5]);
         let mut models = Two(Default::default());
         engine::tick(&mut models);
         assert!(models.body_pose(3).is_some() && models.body_pose(7).is_some());

crates/horizon-hooks/src/players.rs

@@ -274,8 +274,149 @@ impl Bone {
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum Pass {
-    /// In the world, seen by the camera.
+    /// In the world, seen by the camera (the window's own model too, in third person).
     World,
+    /// The inventory's picture of the window's own model.
+    Picture,
+    /// The window's own model while its body is out of view (first person): no bone, only what
+    /// floats around it ([`crate::Hooks::first_person`]).
+    FirstPerson,
+}
+
+/// How a player model moves this frame ([`PlayerDraw::motion`]), with the frame's part of a tick.
+#[derive(Clone, Copy, Debug, Default)]
+#[non_exhaustive]
+pub struct Motion {
+    /// Where its feet are, in the world.
+    pub feet: [f64; 3],
+    /// Where its head turns (degrees, the game's yaw and pitch).
+    pub head_yaw: f32,
+    pub head_pitch: f32,
+    pub crouching: bool,
+    /// Lies in a bed.
+    pub asleep: bool,
+    /// Flies with an elytra.
+    pub flying: bool,
+    /// Swims (any part of the swimming pose).
+    pub swimming: bool,
+}
+
+impl Motion {
+    pub fn new(feet: [f64; 3], head_yaw: f32, head_pitch: f32) -> Self {
+        Self {
+            feet,
+            head_yaw,
+            head_pitch,
+            ..Self::default()
+        }
+    }
+
+    /// With its poses: crouching, asleep, flying, swimming.
+    pub fn poses(self, crouching: bool, asleep: bool, flying: bool, swimming: bool) -> Self {
+        Self {
+            crouching,
+            asleep,
+            flying,
+            swimming,
+            ..self
+        }
+    }
+}
+
+/// The camera a player model is drawn for ([`PlayerDraw::view`]).
+#[derive(Clone, Copy, Debug, Default)]
+#[non_exhaustive]
+pub struct View {
+    /// Where it is, in the world: matrices and [`Particle`] corners are relative to it.
+    pub camera: [f64; 3],
+    /// Its right and up, for what faces it.
+    pub right: [f32; 3],
+    pub up: [f32; 3],
+    /// Where the window's player looks, and their level left (first person).
+    pub forward: [f32; 3],
+    pub left: [f32; 3],
+}
+
+impl View {
+    pub fn new(camera: [f64; 3], right: [f32; 3], up: [f32; 3]) -> Self {
+        Self {
+            camera,
+            right,
+            up,
+            ..Self::default()
+        }
+    }
+
+    /// With where the window's player looks and their level left.
+    pub fn looking(self, forward: [f32; 3], left: [f32; 3]) -> Self {
+        Self {
+            forward,
+            left,
+            ..self
+        }
+    }
+}
+
+/// How a mesh or particles are lit.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Light {
+    /// As the player model is.
+    Model,
+    /// Fully lit: it glows.
+    Full,
+    /// By the world where the mesh's origin is (as particles: like [`Light::Model`]).
+    AtPlace,
+}
+
+/// How [`PlayerDraw::draw`] draws a mesh.
+#[derive(Clone, Copy, Debug)]
+#[non_exhaustive]
+pub struct Look {
+    /// The sprite part it is textured by (u0, v0, u1, v1).
+    pub uv: [f32; 4],
+    pub light: Light,
+    /// Drawn see-through at this alpha, after every player, its back faces dropped.
+    pub see_through: Option<f32>,
+}
+
+impl Look {
+    /// Opaque, lit as the model.
+    pub fn new(uv: [f32; 4]) -> Self {
+        Self {
+            uv,
+            light: Light::Model,
+            see_through: None,
+        }
+    }
+
+    pub fn lit(self, light: Light) -> Self {
+        Self { light, ..self }
+    }
+
+    pub fn see_through(self, alpha: f32) -> Self {
+        Self {
+            see_through: Some(alpha),
+            ..self
+        }
+    }
+}
+
+/// A quad that faces the camera ([`PlayerDraw::particles`]).
+#[derive(Clone, Copy, Debug)]
+#[non_exhaustive]
+pub struct Particle {
+    /// Its corners, relative to the camera.
+    pub corners: [[f32; 3]; 4],
+    /// Each corner's place across the sprite part (0 to 1).
+    pub uv: [[f32; 2]; 4],
+    pub alpha: f32,
+}
+
+impl Particle {
+    pub fn new(corners: [[f32; 3]; 4], uv: [[f32; 2]; 4], alpha: f32) -> Self {
+        Self { corners, uv, alpha }
+    }
 }
 
 /// The poses of a [`Mesh`]'s parts for one [`PlayerDraw::draw`], each at rest to begin with.
@@ -291,19 +432,25 @@ pub trait PlayerDraw {
     fn pass(&self) -> Pass;
     /// The model's age in ticks, with the frame's part of a tick.
     fn ticks(&self) -> f32;
-    /// Where `bone` is as the body is drawn this frame; None if the model has no such part.
+    /// The model's own matrix, its origin at the neck (y down, 16 units a block).
+    fn base(&self) -> [[f32; 4]; 4];
+    fn motion(&self) -> Motion;
+    fn view(&self) -> View;
+    /// Where `bone` is as the body is drawn this frame; None if the model has no such part (or
+    /// no body is drawn: [`Pass::FirstPerson`]).
     fn bone(&mut self, bone: Bone) -> Option<[[f32; 4]; 4]>;
     /// The pose laid over the model's body ([`PlayerModels::set_body_pose`]), if any.
     fn body_pose(&self) -> Option<&Arc<dyn BodyPose>>;
     /// As [`Sprites::get`].
     fn sprite(&self, id: u64) -> Option<[f32; 4]>;
-    /// Draws `mesh` at `matrix`, textured by the sprite part `uv` (u0, v0, u1, v1) and lit as the
-    /// model is; `pose` poses its parts first.
+    /// Draws `mesh` at `matrix` as `look` says; `pose` poses its parts first.
     fn draw(
         &mut self,
         mesh: &Arc<Mesh>,
         matrix: [[f32; 4]; 4],
-        uv: [f32; 4],
+        look: Look,
         pose: &mut dyn FnMut(&mut dyn PartPoses),
     );
+    /// Draws `particles`, textured by the sprite part `uv`, see-through after every player.
+    fn particles(&mut self, uv: [f32; 4], particles: &[Particle], light: Light);
 }

crates/horizon-platform/src/lib.rs

@@ -50,9 +50,9 @@ pub mod hooks {
     /// [`Hooks::tick`] get, the pose a crate lays over a player's body, what goes by their names,
     /// the crate's sprites, the camera, and what a crate draws on them.
     pub use horizon_hooks::players::{
-        BODY_PARTS, Badge, BodyPose, Bone, CameraOverride, CameraView, Frame, Gear, Kind, Mark,
-        Mesh, NameDecoration, PartPoses, Pass, PlayerDraw, PlayerModel, PlayerModels, Quad,
-        SpriteStore, Sprites,
+        BODY_PARTS, Badge, BodyPose, Bone, CameraOverride, CameraView, Frame, Gear, Kind, Light,
+        Look, Mark, Mesh, Motion, NameDecoration, PartPoses, Particle, Pass, PlayerDraw,
+        PlayerModel, PlayerModels, Quad, SpriteStore, Sprites, View,
     };
     pub use horizon_hooks::{Hooks, Started, TooLate, register, seat, tunnel};
 }