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

@@ -20,14 +20,17 @@ use horizon_cosmetics::follow::Follow;
 use horizon_cosmetics::prefs::{self, Others};
 use horizon_cosmetics::trail::{Budget, Emitter};
 use horizon_cosmetics::{Item, Slot};
-use horizon_hooks::players::{Frame, Kind, PlayerModel, PlayerModels};
+use horizon_hooks::players::{
+    Badge, Bone, CameraOverride, CameraView, Frame, Gear, Kind, Look, Mark, Mesh, NameDecoration,
+    PlayerDraw, PlayerModel, PlayerModels, Quad, SpriteStore, Sprites,
+};
 use std::cell::{Cell, RefCell};
 use std::sync::mpsc::{Receiver, channel};
 use std::sync::{Arc, Mutex, PoisonError};
 use std::time::{Duration, Instant};
 
 /// Horizon's mark before a Horizon player's name, over their name tag and in the player list.
-pub(super) const MARK: horizon_client::tab_list::NameMark = &horizon_cosmetics::mark::MARK;
+const MARK: Mark = &horizon_cosmetics::mark::MARK;
 
 /// An item as the renderer takes it.
 struct Baked {
@@ -63,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.
@@ -397,17 +400,13 @@ fn slot_image(item: &Item) -> Vec<u8> {
 
 /// Which slots an avatar's gear covers: a helmet or head item hides a hat, an elytra or a cape
 /// what is worn on the back. A name tag style is never drawn on the body.
-fn covered(m: &Mob, slot: Slot) -> bool {
+fn covered(gear: Gear, slot: Slot) -> bool {
     match slot {
-        Slot::Head => m.extra.head.is_some(),
-        Slot::Back => m.cape.is_some() || m.extra.chest.as_deref() == Some("minecraft:elytra"),
+        Slot::Head => gear.head,
+        Slot::Back => gear.back,
         Slot::Shoulder => false,
         // A chestplate, not an elytra.
-        Slot::Torso => m
-            .extra
-            .chest
-            .as_deref()
-            .is_some_and(|c| c != "minecraft:elytra"),
+        Slot::Torso => gear.chest,
         Slot::NameTag | Slot::Emote => true,
         // On no bone: drawn by a pass of their own, never on the body.
         Slot::Companion | Slot::Trail | Slot::Aura => true,
@@ -419,12 +418,12 @@ fn covered(m: &Mob, slot: Slot) -> bool {
 /// (`worn` is None), another player's at "name tags only" or hidden, or every item `covered` (a
 /// helmet over a hat). One max over at most five items, read when the item was parsed.
 fn body_top(
-    extras: &horizon_client::extras::Extras,
+    others: Others,
     own: bool,
     worn: Option<&horizon_cosmetics::Worn>,
     covered: impl Fn(Slot) -> bool,
 ) -> Option<f32> {
-    if !own && extras.effective_others() != Others::Shown {
+    if !own && others != Others::Shown {
         return None;
     }
     worn?
@@ -462,6 +461,45 @@ struct Seat {
     said: Said,
     /// Kept between ticks so a tick allocates nothing: the player models in view.
     models: Vec<PlayerModel>,
+    /// The world is the window's own single-player one (`Frame::solo`).
+    solo: bool,
+    /// The items the hooks show, by the item's address.
+    items: FxHashMap<usize, Kept>,
+    last_sprite: u64,
+    /// Sprites drawing missed, put in the atlas next frame.
+    wanted: Vec<u64>,
+}
+
+/// An item the hooks show: its sprite's id (never reused) and a mesh per bone it rides, held
+/// with the item so its address isn't reused while it is here.
+struct Kept {
+    sprite: u64,
+    item: Arc<Item>,
+    meshes: Vec<(Bone, Arc<Mesh>)>,
+}
+
+/// The hooks' model of an item's part.
+fn mesh(p: &horizon_cosmetics::Part) -> Mesh {
+    let quads = p.faces.iter().map(|f| Quad::new(f.normal, f.vertices));
+    Mesh::new(
+        p.name.clone(),
+        p.pose,
+        quads.collect(),
+        p.children.iter().map(mesh).collect(),
+    )
+}
+
+/// The hooks' name of a bone.
+fn bone(b: horizon_cosmetics::Bone) -> Bone {
+    use horizon_cosmetics::Bone as B;
+    match b {
+        B::Head => Bone::Head,
+        B::Body => Bone::Body,
+        B::LeftArm => Bone::LeftArm,
+        B::RightArm => Bone::RightArm,
+        B::LeftLeg => Bone::LeftLeg,
+        B::RightLeg => Bone::RightLeg,
+    }
 }
 
 /// What the game tells the hooks before each call, until the settings move here (spec #14091
@@ -472,6 +510,14 @@ struct Said {
     listed: bool,
     /// Other players' cosmetics are shown (not "name tags only", not hidden).
     others_shown: bool,
+    /// Other players' cosmetics are hidden (not even name tag styles).
+    others_hidden: bool,
+    /// Horizon's mark by Horizon players' names.
+    marks: bool,
+    /// Cosmetics in single player: the signed-in account's on the player's own model.
+    solo: bool,
+    /// My emote pulled the camera back: when it started (the own model's age).
+    pull: Option<f32>,
     /// My emote while it plays: its id and whether it loops.
     playing: Option<(String, bool)>,
     /// A folder's first emote, which mannequins play.
@@ -496,13 +542,43 @@ pub(super) struct Hooks;
 pub(super) static HOOKS: Hooks = Hooks;
 
 impl horizon_hooks::Hooks for Hooks {
-    fn frame(&self, _frame: &Frame) {
-        service(Seat::frame);
+    fn frame(&self, frame: &Frame, sprites: &mut dyn SpriteStore) {
+        service(|s| {
+            s.solo = frame.solo;
+            s.frame();
+            s.put_sprites(sprites);
+        });
     }
 
     fn tick(&self, models: &mut dyn PlayerModels) {
         service(|s| s.tick(models));
     }
+
+    fn name_decoration(
+        &self,
+        model: &PlayerModel,
+        sprites: &dyn Sprites,
+    ) -> Option<NameDecoration> {
+        service(|s| s.name_decoration(model, sprites))
+    }
+
+    fn player_mark(&self, uuid: u128) -> Option<Mark> {
+        service(|s| {
+            let client = s.client.as_ref().filter(|_| s.said.marks)?;
+            client.frame().horizon(uuid).then_some(MARK)
+        })
+    }
+
+    /// An emote pulls the camera back: it eases out over the emote's first quarter second.
+    fn player_layers(&self, model: &PlayerModel, draw: &mut dyn PlayerDraw) {
+        service(|s| s.player_layers(model, draw));
+    }
+
+    fn camera(&self, own: &CameraView) -> Option<CameraOverride> {
+        let start = service(|s| s.said.pull)?;
+        let t = ((own.age - start) / 5.0).clamp(0.0, 1.0);
+        Some(CameraOverride::new(0.35 + 0.65 * t * t * (3.0 - 2.0 * t)))
+    }
 }
 
 impl Seat {
@@ -609,6 +685,167 @@ impl Seat {
         }
     }
 
+    /// What goes by `m`'s name: Horizon's mark if they play Horizon (and the mark is on), the
+    /// name tag style they wear if cosmetics are shown for them (name tags only counts), and how
+    /// high what is drawn on their body gets (`body_top`). One look in the cache for all three.
+    fn name_decoration(
+        &mut self,
+        m: &PlayerModel,
+        sprites: &dyn Sprites,
+    ) -> Option<NameDecoration> {
+        let said = &self.said;
+        let own = m.kind == Kind::Own;
+        let styles = if own { said.mine } else { !said.others_hidden };
+        if !(styles || said.marks) {
+            return None;
+        }
+        let uuid = self.uuid_of(m)?;
+        let mut frame = self.client.as_ref()?.frame();
+        let mark = (said.marks && frame.horizon(uuid)).then_some(MARK);
+        let worn = if styles { frame.worn(uuid) } else { None };
+        drop(frame);
+        let others = if said.others_shown {
+            Others::Shown
+        } else {
+            Others::NameTags
+        };
+        let top = body_top(others, own, worn.as_ref(), |slot| covered(m.gear, slot))
+            .filter(|_| !m.invisible);
+        let badge = worn.and_then(|w| self.badge(&w, sprites));
+        Some(NameDecoration::new(mark, badge, top))
+    }
+
+    /// The UUID the service knows `m` by: a player's, or a mannequin's id with local items.
+    fn uuid_of(&self, m: &PlayerModel) -> Option<u128> {
+        match m.kind {
+            Kind::Own => own_uuid(m.uuid, self.solo, self.said.solo, || {
+                horizon_client::auth::current().map(|s| s.uuid)
+            }),
+            Kind::Mannequin if self.local => Some(u128::from(m.id)),
+            Kind::Player => m.uuid,
+            _ => None,
+        }
+    }
+
+    /// `item` as the hooks show it, kept from its first sight.
+    fn kept(&mut self, item: &Arc<Item>) -> &Kept {
+        let next = self.last_sprite + 1;
+        let kept = self
+            .items
+            .entry(Arc::as_ptr(item) as usize)
+            .or_insert_with(|| Kept {
+                sprite: next,
+                item: item.clone(),
+                meshes: item
+                    .roots()
+                    .map(|(b, root)| (bone(b), Arc::new(mesh(root))))
+                    .collect(),
+            });
+        self.last_sprite = self.last_sprite.max(kept.sprite);
+        kept
+    }
+
+    /// Where `item`'s texture is in the atlas (`get` reads the crate's sprites): the top left
+    /// corner of its slot. None until it is there (it is put there next frame).
+    fn uv(&mut self, item: &Arc<Item>, get: impl Fn(u64) -> Option<[f32; 4]>) -> Option<[f32; 4]> {
+        let id = self.kept(item).sprite;
+        let Some([u0, v0, u1, v1]) = get(id) else {
+            if !self.wanted.contains(&id) {
+                self.wanted.push(id);
+            }
+            return None;
+        };
+        let (w, h) = (
+            item.texture.width as f32 / 64.0,
+            item.texture.height as f32 / 64.0,
+        );
+        Some([u0, v0, u0 + (u1 - u0) * w, v0 + (v1 - v0) * h])
+    }
+
+    /// The name tag style in `worn`: its badge and its line's colour. None until the badge is in
+    /// the atlas.
+    fn badge(&mut self, worn: &horizon_cosmetics::Worn, sprites: &dyn Sprites) -> Option<Badge> {
+        let item = worn.iter().find(|i| i.slot == Slot::NameTag)?;
+        let [r, g, b] = item.tag?.line;
+        let uv = self.uv(item, |id| sprites.get(id))?;
+        Some(Badge::new(uv, u32::from_be_bytes([0, r, g, b])))
+    }
+
+    /// Puts the sprites drawing missed in the atlas; forgets the items no one wears.
+    fn put_sprites(&mut self, store: &mut dyn SpriteStore) {
+        for id in self.wanted.drain(..) {
+            let kept = self.items.values().find(|k| k.sprite == id);
+            if let Some(kept) = kept.filter(|_| !store.has(id)) {
+                store.put(id, slot_image(&kept.item));
+            }
+        }
+        self.items.retain(|_, k| Arc::strong_count(&k.item) > 1);
+    }
+
+    /// The cosmetics `m` wears, on its bones, and an emote's props (companions, trails and auras
+    /// are still the game's: `cosmetics_geometry`).
+    fn player_layers(&mut self, m: &PlayerModel, draw: &mut dyn PlayerDraw) {
+        if m.invisible {
+            return;
+        }
+        let said = &self.said;
+        let own = m.kind == Kind::Own;
+        let shown = if own { said.mine } else { !said.others_hidden };
+        // "Name tags only": other players' styles beside their names, nothing on their bodies.
+        let bodies = own || said.others_shown;
+        let ticks = draw.ticks();
+        // An emote's props: its time and weight while it plays.
+        let emote = emotes::pose_playing(draw.body_pose()).and_then(|p| {
+            let (t, w) = p.at(ticks)?;
+            (p.item.vertices > 0).then(|| (p.item.clone(), t, w))
+        });
+        let worn = match (&self.client, self.uuid_of(m)) {
+            (Some(client), Some(uuid)) if shown && bodies => client.frame().worn(uuid),
+            _ => 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<(Bone, [[f32; 4]; 4])>; 4] = [None; 4];
+        let worn_items = worn.iter().flat_map(|w| w.iter()).map(|i| (i, None));
+        let emote_items = emote.iter().map(|(i, t, w)| (i, Some((*t, *w))));
+        for (item, emoting) in worn_items.chain(emote_items) {
+            // Covered by gear, or drawn by no bone (a name tag style, companions, trails, auras).
+            if emoting.is_none() && covered(m.gear, item.slot) {
+                continue;
+            }
+            let Some(uv) = self.uv(item, |id| draw.sprite(id)) else {
+                continue;
+            };
+            for i in 0..self.kept(item).meshes.len() {
+                let (bone_of, mesh) = self.kept(item).meshes[i].clone();
+                let known = bones.iter().flatten().find(|(b, _)| *b == bone_of);
+                let matrix = match known {
+                    Some(&(_, matrix)) => matrix,
+                    None => {
+                        let Some(matrix) = draw.bone(bone_of) else {
+                            continue;
+                        };
+                        if let Some(free) = bones.iter_mut().find(|b| b.is_none()) {
+                            *free = Some((bone_of, matrix));
+                        }
+                        matrix
+                    }
+                };
+                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);
+                        // Props grow in and shrink out with the emote's blend.
+                        let root = p.pose(&mesh.name);
+                        for s in &mut root[6..9] {
+                            *s *= w;
+                        }
+                    }
+                });
+            }
+        }
+    }
+
     /// Once a tick: names the Horizon players in view to the emote feed and plays what it says
     /// they play on their models; one that moved ends theirs here at once. Others' emotes show
     /// with "Other players' cosmetics" on Shown only; otherwise nothing is asked.
@@ -705,11 +942,16 @@ impl Game<'_> {
         };
         let extras = &self.settings.extras;
         let playing = self.cosmetics.emotes.sending();
+        let pull = self.cosmetics.emotes.pull();
         service(|s| {
             let said = &mut s.said;
             said.mine = extras.cosmetics_mine;
             said.listed = extras.horizon_listed;
             said.others_shown = extras.effective_others() == Others::Shown;
+            said.others_hidden = extras.effective_others() == Others::Hidden;
+            said.marks = extras.horizon_marks;
+            said.solo = extras.cosmetics_solo;
+            said.pull = pull;
             if said.playing.as_ref().map(|(id, l)| (id.as_str(), *l)) != playing {
                 said.playing = playing.map(|(id, l)| (id.to_owned(), l));
             }
@@ -775,81 +1017,6 @@ impl Game<'_> {
             .ok();
     }
 
-    /// Items from a folder (`HORIZON_COSMETICS_LOCAL`): mannequins are dressed and marked too.
-    pub(super) fn cosmetics_local(&self) -> bool {
-        self.cosmetics.local
-    }
-
-    /// What goes by `m`'s name: Horizon's mark if they play Horizon (and the mark is on), the
-    /// name tag style they wear if cosmetics are shown for them (name tags only counts), and how
-    /// high what is drawn on their body gets (`body_top`). One look in the cache for all three.
-    pub(super) fn cosmetics_marks(&self, m: &Mob, own: bool) -> super::names::Marks {
-        let mut marks = super::names::Marks::default();
-        let extras = &self.settings.extras;
-        let styles = if own {
-            extras.cosmetics_mine
-        } else {
-            extras.effective_others() != Others::Hidden
-        };
-        if !(styles || extras.horizon_marks) {
-            return marks;
-        }
-        let (Some(client), Some(uuid)) = (&self.cosmetics.client, self.cosmetics_uuid(m, own))
-        else {
-            return marks;
-        };
-        let mut frame = client.frame();
-        marks.horizon = extras.horizon_marks && frame.horizon(uuid);
-        let worn = if styles { frame.worn(uuid) } else { None };
-        drop(frame);
-        if !horizon_client::mobs::trader::is_invisible(m) {
-            marks.top = body_top(extras, own, worn.as_ref(), |slot| covered(m, slot));
-        }
-        marks.style = worn.and_then(|w| self.cosmetics_tag(&w));
-        marks
-    }
-
-    /// Those of `uuids` who play Horizon, with the mark on (the player list): one look each.
-    pub(super) fn horizon_players(
-        &self,
-        uuids: impl Iterator<Item = u128>,
-    ) -> std::collections::HashSet<u128> {
-        match &self.cosmetics.client {
-            Some(c) if self.settings.extras.horizon_marks => {
-                let mut frame = c.frame();
-                uuids.filter(|u| frame.horizon(*u)).collect()
-            }
-            _ => Default::default(),
-        }
-    }
-
-    /// The name tag style in `worn`: its badge's place in the atlas and its line's colour. None
-    /// until the badge is in the atlas.
-    fn cosmetics_tag(&self, worn: &horizon_cosmetics::Worn) -> Option<super::names::TagStyle> {
-        let item = worn.iter().find(|i| i.slot == Slot::NameTag)?;
-        let [r, g, b] = item.tag?.line;
-        let frame = self.cosmetics.frame.get();
-        let mut baked = self.cosmetics.baked.borrow_mut();
-        let entry = baked
-            .entry(Arc::as_ptr(item) as usize)
-            .or_insert_with(|| Baked::new(item, frame));
-        let Some(slot) = self.gui.atlas.sprites.get(&entry.location) else {
-            self.cosmetics.uploads.borrow_mut().push(item.clone());
-            return None;
-        };
-        if entry.marked.replace(frame) != frame {
-            self.skin_downloads.borrow_mut().drawn(&entry.location);
-        }
-        // The mark sits in the slot's top left corner.
-        let mut mark = *slot;
-        mark.u1 = mark.u0 + (slot.u1 - slot.u0) * item.texture.width as f32 / 64.0;
-        mark.v1 = mark.v0 + (slot.v1 - slot.v0) * item.texture.height as f32 / 64.0;
-        Some(super::names::TagStyle {
-            mark,
-            line: u32::from_be_bytes([0, r, g, b]),
-        })
-    }
-
     /// What `m` wears, if cosmetics are shown for it: `own` for the player's own model.
     fn worn(&self, m: &Mob, own: bool) -> Option<horizon_cosmetics::Worn> {
         let client = self.cosmetics.client.as_ref()?;
@@ -876,104 +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;
-        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 emoting.is_none() && covered(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
@@ -1247,13 +1357,18 @@ mod tests {
         let (short, long) = (Duration::from_millis(300), Duration::from_secs(10));
         let top_of = |extras: &Extras, patience| {
             let (worn, _) = other_player_from(Service(Arc::default(), both), extras, patience);
-            body_top(extras, false, worn.as_ref(), |_| false)
+            body_top(extras.effective_others(), false, worn.as_ref(), |_| false)
         };
         // No cosmetics drawn on the body (a name tag style only): vanilla's height exactly.
         let (worn, _) = other_player(&shown, long);
         assert!(worn.is_some());
         assert_eq!(
-            tag(body_top(&shown, false, worn.as_ref(), |_| false)),
+            tag(body_top(
+                shown.effective_others(),
+                false,
+                worn.as_ref(),
+                |_| false
+            )),
             VANILLA
         );
         // A small hat under the tag: vanilla's height too.
@@ -1267,7 +1382,9 @@ mod tests {
         );
         // A helmet over it: vanilla's height.
         let (worn, _) = other_player_from(Service(Arc::default(), both), &shown, long);
-        let helmet = body_top(&shown, false, worn.as_ref(), |slot| slot == Slot::Head);
+        let helmet = body_top(shown.effective_others(), false, worn.as_ref(), |slot| {
+            slot == Slot::Head
+        });
         assert_eq!(tag(helmet), VANILLA);
         // Others' cosmetics on name tags only, or hidden: nothing on the body, vanilla's height.
         for others in [Others::NameTags, Others::Hidden] {
@@ -1345,4 +1462,124 @@ mod tests {
         service.tick(&mut view);
         assert!(view.0[3].1.is_none());
     }
+
+    /// A player model as `player_layers` draws on it: one bone, the sprites it is given; logs
+    /// each draw (mesh, matrix, uv, its root's scale once posed).
+    struct Canvas {
+        pose: Option<Arc<dyn BodyPose>>,
+        sprite: Option<[f32; 4]>,
+        drawn: Vec<(String, [[f32; 4]; 4], [f32; 4], [f32; 3])>,
+    }
+
+    const LEFT_ARM: [[f32; 4]; 4] = [[2.0, 0.0, 0.0, 0.0]; 4];
+
+    impl PlayerDraw for Canvas {
+        fn pass(&self) -> horizon_hooks::players::Pass {
+            horizon_hooks::players::Pass::World
+        }
+        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)
+        }
+        fn body_pose(&self) -> Option<&Arc<dyn BodyPose>> {
+            self.pose.as_ref()
+        }
+        fn sprite(&self, _: u64) -> Option<[f32; 4]> {
+            self.sprite
+        }
+        fn draw(
+            &mut self,
+            mesh: &Arc<Mesh>,
+            matrix: [[f32; 4]; 4],
+            look: Look,
+            pose: &mut dyn FnMut(&mut dyn horizon_hooks::players::PartPoses),
+        ) {
+            struct Rest(std::collections::HashMap<String, [f32; 9]>);
+            impl horizon_hooks::players::PartPoses for Rest {
+                fn pose(&mut self, name: &str) -> &mut [f32; 9] {
+                    self.0.entry(name.to_owned()).or_insert([0.0; 9])
+                }
+            }
+            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,
+                look.uv,
+                [root[6], root[7], root[8]],
+            ));
+        }
+    }
+
+    #[test]
+    fn an_emotes_prop_goes_on_its_bone_once_its_texture_is_in_scaled_by_the_blend() {
+        let pop = CROWN
+            .replace(
+                r#""slot": "head", "bone": "head""#,
+                r#""slot": "emote", "bone": "left_arm""#,
+            )
+            .replace(
+                r#""uv": [0, 0]}]}]}"#,
+                r#""uv": [0, 0]}]}],
+                "emote": {"length": 40, "blend": 4, "tracks": [
+                  {"part": "right_arm", "keys": [{"t": 0}, {"t": 40}]}]}}"#,
+            );
+        let item = Arc::new(Item::parse(pop.as_bytes()).unwrap());
+        let playing = horizon_cosmetics::Playing {
+            item: item.clone(),
+            start: 100.0,
+            stop: None,
+        };
+        let (_, weight) = playing.at(102.0).unwrap();
+        assert!(weight > 0.0 && weight < 1.0, "{weight}");
+        let player = PlayerModel::new(9, Kind::Player, Some(5), 102, false);
+        let mut view = View(vec![(player, None)]);
+        emotes::set_model_playing(&mut view, 9, Some(playing));
+        let mut canvas = Canvas {
+            pose: view.0[0].1.clone(),
+            sprite: None,
+            drawn: Vec::new(),
+        };
+        // Others' cosmetics hidden, no service: the player's own emote still shows.
+        let mut seat = Seat {
+            said: Said {
+                others_hidden: true,
+                ..Said::default()
+            },
+            ..Seat::default()
+        };
+        // Its texture not in the atlas yet: nothing drawn, the sprite asked for.
+        seat.player_layers(&player, &mut canvas);
+        assert!(canvas.drawn.is_empty());
+        assert_eq!(seat.wanted.len(), 1);
+        canvas.sprite = Some([0.0, 0.0, 0.5, 0.5]);
+        seat.player_layers(&player, &mut canvas);
+        // A 16×16 texture: the slot's top left quarter of it.
+        let quarter = 0.5 * 16.0 / 64.0;
+        assert_eq!(canvas.drawn.len(), 1);
+        let (_, matrix, uv, scale) = &canvas.drawn[0];
+        assert_eq!((matrix, uv), (&LEFT_ARM, &[0.0, 0.0, quarter, quarter]));
+        for s in scale {
+            assert!((s - weight).abs() < 1e-6, "{scale:?} by {weight}");
+        }
+    }
 }

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

@@ -43,6 +43,11 @@ impl Emotes {
         let looping = p.item.emote.as_ref().is_some_and(|e| e.looping);
         Some((&p.item.id, looping))
     }
+
+    /// When the emote that pulled the camera back started (the own model's age), while it plays.
+    pub(in crate::game) fn pull(&self) -> Option<f32> {
+        self.camera_from.and(self.playing.as_ref()).map(|p| p.start)
+    }
 }
 
 /// An emote on a player's model: the engine's pose hook (`Mob::emote`), which names no cosmetics
@@ -66,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(
@@ -277,19 +277,6 @@ impl Game<'_> {
         }
         self.tick_emote();
     }
-
-    /// How far the camera stands back while an emote pulls it (1: the usual distance): it eases
-    /// out over the emote's first quarter second.
-    pub(in crate::game) fn emote_camera_pull(&self, partial: f32) -> f32 {
-        let (Some(p), Some(m)) = (&self.cosmetics.emotes.playing, &self.player_model) else {
-            return 1.0;
-        };
-        if self.cosmetics.emotes.camera_from.is_none() {
-            return 1.0;
-        }
-        let t = ((m.age as f32 + partial - p.start) / 5.0).clamp(0.0, 1.0);
-        0.35 + 0.65 * t * t * (3.0 - 2.0 * t)
-    }
 }
 
 #[cfg(test)]

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/creatures/mob_geometry.rs

@@ -280,25 +280,18 @@ impl Game<'_> {
                 self.spin_attack_geometry(mob, camera, alpha as f32, packed, out);
                 self.stuck_in_body_geometry(mob, mob.id as i32, camera, alpha as f32, packed, out);
             }
-            // Cosmetics (game/cosmetics.rs), posed on the GPU with the mob's own jobs: culled
-            // with it.
+            // What crates draw on players and mannequins (`game/player_hooks.rs`: cosmetics),
+            // posed on the GPU with the mob's own jobs: culled with it.
             if !layers_only
-                && super::super::cosmetics::enabled()
+                && horizon_hooks::engine::any()
                 && (is_player || &*mob.kind.id == "minecraft:mannequin")
             {
                 let mark = self.skin_frame.borrow().mark();
                 let base = horizon_client::mobs::render::base_transform(mob, alpha as f32, camera);
                 let gpu = skinning;
-                if let Some((lo, hi)) = self.cosmetics_geometry(
-                    mob,
-                    false,
-                    base,
-                    Some(camera),
-                    alpha as f32,
-                    packed,
-                    gpu,
-                    out,
-                ) {
+                if let Some((lo, hi)) =
+                    self.player_layers_geometry(mob, base, camera, alpha as f32, packed, gpu, out)
+                {
                     skinned = Some(match skinned {
                         Some((first, Some((l, h)))) => (first, Some((l.min(lo), h.max(hi)))),
                         Some((first, None)) => (first, Some((lo, hi))),

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

@@ -300,11 +300,7 @@ impl Game<'_> {
             ) {
                 continue;
             }
-            let marks = if player || self.cosmetics_local() {
-                self.cosmetics_marks(m, Some(m.id) == own)
-            } else {
-                Marks::default()
-            };
+            let marks = self.hooks_name_marks(m, Some(m.id) == own);
             let at = match marks.top {
                 Some(top) => p + glam::DVec3::Y * cosmetic_lift(top, m.model_scale()),
                 None => p,
@@ -770,10 +766,10 @@ impl Game<'_> {
                     if background { BACKGROUND } else { 0 },
                 ),
             };
-            if n == last && marks.horizon {
+            if let Some(mark) = marks.mark.filter(|_| n == last) {
                 let x = -self.gui.atlas.font.width_text(text) / 2.0 - 10.0;
                 // 8 text pixels square, a pixel left of the background.
-                for &(mx, my, w, h, argb) in super::cosmetics::MARK {
+                for &(mx, my, w, h, argb) in mark {
                     let a = text_alpha * (argb >> 24) / 255;
                     batch.fill(
                         &self.gui.atlas,
@@ -937,10 +933,11 @@ struct NameTag {
     marks: Marks,
 }
 
-/// What Horizon draws by a player's name: its mark (they play Horizon) and their name tag style.
+/// What a hook draws by a player's name (`horizon_hooks::players::NameDecoration`): a mark
+/// before it (Horizon's: they play Horizon) and a name tag style.
 #[derive(Clone, Copy, Default)]
 pub(super) struct Marks {
-    pub horizon: bool,
+    pub mark: Option<horizon_hooks::players::Mark>,
     pub style: Option<TagStyle>,
     /// How high the cosmetics drawn on their body get above the neck, in model pixels: the tag
     /// goes up over a tall one (`cosmetic_lift`).

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

@@ -311,8 +311,8 @@ impl Game<'_> {
             }
         };
         let mut view = self.view;
-        // An emote pulls the camera back from the player's face (`game/cosmetics/emotes.rs`).
-        let pull = self.emote_camera_pull(partial);
+        // A hook may pull the camera back (an emote, from the player's face).
+        let pull = self.hooks_camera_distance(partial);
         let kind = match self.camera_type {
             CameraType::FirstPerson => horizon_client::camera::CameraType::FirstPerson,
             CameraType::ThirdPersonBack => horizon_client::camera::CameraType::ThirdPersonBack,
@@ -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

@@ -1,14 +1,19 @@
-//! Where the game hands the player models to crates above the engine
-//! (`horizon_hooks::Hooks::frame` and `tick`, spec #14091): only a window's game calls them,
-//! never the integrated server's thread or a dedicated server. With no hook registered nothing is
-//! built.
+//! Where the game hands the player models to crates above the engine (`horizon_hooks::Hooks`'s
+//! `frame`, `tick`, `name_decoration`, `player_mark`, `camera`; spec #14091): only a window's
+//! game calls them, never the integrated server's thread or a dedicated server. With no hook
+//! registered nothing is built.
 
 use super::Game;
+use horizon_client::fast_hash::FxHashMap;
 use horizon_client::join_seq::JoinList;
-use horizon_client::mobs::Mob;
-use horizon_client::mobs::anim::BodyPose;
+use horizon_client::mesher::Vertex;
+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::{Frame, Kind, PlayerModel, PlayerModels};
+use horizon_hooks::players::{
+    Bone, CameraView, Frame, Gear, Kind, Light, Look, Mesh, Motion, PartPoses, Particle, Pass,
+    PlayerDraw, PlayerModel, PlayerModels, SpriteStore, Sprites, View,
+};
 use std::sync::Arc;
 
 /// Registers the hooks of the Horizon parts still in this crate (cosmetics: spec #14091 step 5
@@ -49,9 +54,20 @@ fn kind(m: &Mob) -> Option<Kind> {
     }
 }
 
+/// What `m` wears where a crate may draw: a helmet or head item, a chestplate, a cape or elytra.
+pub(super) fn gear(m: &Mob) -> Gear {
+    let elytra = m.extra.chest.as_deref() == Some("minecraft:elytra");
+    Gear::new(
+        m.extra.head.is_some(),
+        m.extra.chest.is_some() && !elytra,
+        m.cape.is_some() || elytra,
+    )
+}
+
 fn model(m: &Mob, kind: Kind, uuid: Option<u128>) -> PlayerModel {
     let (dx, dz) = (m.position.x - m.previous.x, m.position.z - m.previous.z);
     PlayerModel::new(m.id, kind, uuid, m.age, dx * dx + dz * dz > 1e-4)
+        .looks(gear(m), horizon_client::mobs::trader::is_invisible(m))
 }
 
 impl PlayerModels for Models<'_> {
@@ -61,7 +77,7 @@ impl PlayerModels for Models<'_> {
 
     fn for_each(&self, f: &mut dyn FnMut(PlayerModel)) {
         if let Some(m) = self.own.as_deref() {
-            f(model(m, Kind::Own, None));
+            f(model(m, Kind::Own, Some(self.remote.profile())));
         }
         for m in self.mobs.iter() {
             if let Some(kind) = kind(m) {
@@ -92,7 +108,427 @@ impl PlayerModels for Models<'_> {
     }
 }
 
+/// Sprite `id`'s place in the atlas's names (`hooks/<hex>`), written into `buf`: no allocation.
+fn location(id: u64, buf: &mut [u8; 22]) -> &str {
+    use std::io::Write;
+    let mut out = std::io::Cursor::new(&mut buf[..]);
+    let _ = write!(out, "hooks/{id:x}");
+    let len = out.position() as usize;
+    std::str::from_utf8(&buf[..len]).unwrap_or_default()
+}
+
+/// The crates' sprites in the GUI atlas, in the skin slots: read while drawing.
+struct HookSprites<'a, 'g>(&'a Game<'g>);
+
+impl Sprites for HookSprites<'_, '_> {
+    fn get(&self, id: u64) -> Option<[f32; 4]> {
+        let mut buf = [0; 22];
+        let at = location(id, &mut buf);
+        let r = self.0.gui.atlas.sprites.get(at)?;
+        // Kept this frame (`skin_slots.next_frame`).
+        self.0.skin_downloads.borrow_mut().drawn(at);
+        Some([r.u0, r.v0, r.u1, r.v1])
+    }
+}
+
+/// Where a crate's frame hook puts its sprites.
+struct HookStore<'a, 'g>(&'a mut Game<'g>);
+
+impl SpriteStore for HookStore<'_, '_> {
+    fn has(&self, id: u64) -> bool {
+        self.0
+            .gui
+            .atlas
+            .sprites
+            .contains_key(location(id, &mut [0; 22]))
+    }
+
+    fn put(&mut self, id: u64, rgba: Vec<u8>) {
+        let at = location(id, &mut [0; 22]).to_owned();
+        self.0.store_skin(at, rgba);
+    }
+}
+
+thread_local! {
+    /// The crates' meshes as the renderer takes them, by the mesh's address (each entry holds its
+    /// mesh, so the address isn't reused); render thread only.
+    static MESHES: std::cell::RefCell<FxHashMap<usize, (Arc<Mesh>, Arc<Part>)>> =
+        Default::default();
+}
+
+/// The game's model of `mesh`, made once.
+fn part_of(mesh: &Arc<Mesh>) -> Arc<Part> {
+    fn part(m: &Mesh) -> Part {
+        Part {
+            name: m.name.clone(),
+            pose: m.pose,
+            polygons: m
+                .quads
+                .iter()
+                .map(|q| Polygon {
+                    normal: q.normal,
+                    vertices: q.vertices,
+                    cull_back: false,
+                })
+                .collect(),
+            children: m.children.iter().map(part).collect(),
+        }
+    }
+    MESHES.with_borrow_mut(|meshes| {
+        let (_, part_of) = meshes
+            .entry(Arc::as_ptr(mesh) as usize)
+            .or_insert_with(|| (mesh.clone(), Arc::new(part(mesh))));
+        part_of.clone()
+    })
+}
+
+/// 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| {
+        m.borrow_mut()
+            .retain(|_, (mesh, _)| Arc::strong_count(mesh) > 1)
+    });
+}
+
+/// `Poses` as a crate poses a mesh's parts.
+struct PosesOf<'a>(&'a mut Poses);
+
+impl PartPoses for PosesOf<'_> {
+    fn pose(&mut self, name: &str) -> &mut [f32; 9] {
+        self.0.get(name)
+    }
+}
+
+/// 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> {
+    game: &'a Game<'g>,
+    m: &'a Mob,
+    pass: Pass,
+    /// The model's matrix (`render::base_transform`).
+    base: glam::Mat4,
+    camera: glam::DVec3,
+    alpha: f32,
+    light: u32,
+    gpu: bool,
+    out: &'a mut Vec<Vertex>,
+    bounds: Option<(glam::Vec3, glam::Vec3)>,
+    /// The body as it is drawn, posed on the first `bone`.
+    body: Option<PooledPoses>,
+    poses: PooledPoses,
+}
+
+impl DrawPlayer<'_, '_> {
+    fn body(&self) -> &Part {
+        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<'_, '_> {
+    fn pass(&self) -> Pass {
+        self.pass
+    }
+
+    fn ticks(&self) -> f32 {
+        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());
+            let data = self.game.res.mob_data();
+            let state = anim::state(self.m, self.alpha);
+            anim::setup(self.m, &state, &mut poses, &data.animations);
+            self.body = Some(poses);
+        }
+        let poses = self.body.as_ref()?;
+        let at = render::part_matrix(self.body(), self.base, poses, bone.part(), 0.0)?;
+        Some(at.to_cols_array_2d())
+    }
+
+    fn body_pose(&self) -> Option<&Arc<dyn BodyPose>> {
+        self.m.emote.as_ref()
+    }
+
+    fn sprite(&self, id: u64) -> Option<[f32; 4]> {
+        HookSprites(self.game).get(id)
+    }
+
+    fn draw(
+        &mut self,
+        mesh: &Arc<Mesh>,
+        matrix: [[f32; 4]; 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();
+            let mut skin = horizon_client::mobs::skin::Skin::new(&mut models, &mut frame);
+            skin.bounds = self.bounds;
+            let paint = horizon_client::mobs::skin::Paint {
+                uv,
+                scroll: 0.0,
+                color: 0xFFFF_FFFF,
+                light,
+                overlay: 0,
+            };
+            if skin.draw(&model, matrix, poses, paint) {
+                self.bounds = skin.bounds;
+                return;
+            }
+        }
+        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],
+                    });
+                }
+            }
+        });
+    }
+}
+
 impl Game<'_> {
+    /// What crates draw on player model `m` in the world pass (`creatures.rs`), then the
+    /// cosmetics still drawn here: see [`DrawPlayer`]. The bounds of what went to the GPU.
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn player_layers_geometry(
+        &self,
+        m: &Mob,
+        base: glam::Mat4,
+        camera: glam::DVec3,
+        alpha: f32,
+        light: u32,
+        gpu: bool,
+        out: &mut Vec<Vertex>,
+    ) -> Option<(glam::Vec3, glam::Vec3)> {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        let kind = kind(m)?;
+        let mut bounds = None;
+        if engine::any() {
+            let model = model(m, kind, self.remote_player_uuid(m.id));
+            let mut draw = DrawPlayer {
+                game: self,
+                m,
+                pass: Pass::World,
+                base,
+                camera,
+                alpha,
+                light,
+                gpu,
+                out: &mut *out,
+                bounds: None,
+                body: None,
+                poses: Poses::pooled(),
+            };
+            engine::player_layers(&model, &mut draw);
+            bounds = draw.bounds;
+        }
+        let worn = super::cosmetics::enabled()
+            .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))),
+            (b, w) => b.or(w),
+        }
+    }
+
+    /// 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!(
@@ -104,7 +540,10 @@ impl Game<'_> {
         }
         self.cosmetics_say();
         let connection = self.remote.as_ref().map_or(0, |r| r.session.serial());
-        engine::frame(&Frame::new(connection));
+        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();
     }
 
@@ -128,4 +567,68 @@ impl Game<'_> {
             remote,
         });
     }
+
+    /// What goes by `m`'s name (`own`: the window's own player), from the hooks.
+    pub(super) fn hooks_name_marks(&self, m: &Mob, own: bool) -> super::names::Marks {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        let mut marks = super::names::Marks::default();
+        if !engine::any() {
+            return marks;
+        }
+        let model = match (own, kind(m)) {
+            (true, _) => model(m, Kind::Own, self.remote.as_ref().map(|r| r.profile())),
+            (false, Some(kind)) => model(m, kind, self.remote_player_uuid(m.id)),
+            (false, None) => return marks,
+        };
+        if let Some(d) = engine::name_decoration(&model, &HookSprites(self)) {
+            marks.mark = d.mark;
+            marks.top = d.top;
+            marks.style = d.badge.map(|b| {
+                let [u0, v0, u1, v1] = b.uv;
+                super::names::TagStyle {
+                    mark: horizon_client::hud::Rect {
+                        u0,
+                        v0,
+                        u1,
+                        v1,
+                        w: 8,
+                        h: 8,
+                    },
+                    line: b.line,
+                }
+            });
+        }
+        marks
+    }
+
+    /// How far the third-person camera stands back, as a share of the usual distance: a hook's
+    /// (an emote pulls it back), else 1.
+    pub(super) fn hooks_camera_distance(&self, partial: f32) -> f32 {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        match &self.player_model {
+            Some(m) if engine::any() => {
+                engine::camera(&CameraView::new(m.age as f32 + partial)).map_or(1.0, |c| c.distance)
+            }
+            _ => 1.0,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sprite_locations_fit_the_buffer_and_differ_by_id() {
+        let mut a = [0; 22];
+        let mut b = [0; 22];
+        assert_eq!(location(u64::MAX, &mut a), "hooks/ffffffffffffffff");
+        assert_eq!(location(10, &mut b), "hooks/a");
+    }
 }

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

@@ -900,10 +900,12 @@ impl Game<'_> {
         let board = &self.score.board;
         let objective = board.display_objective(sb::SLOT_LIST);
         let up = |id: u128| upside_down.contains(&id);
-        // Horizon's mark before the names of Horizon players (the cosmetics service's cache).
-        let horizon = self.horizon_players(players.iter().map(|p| p.uuid));
-        let horizon_mark = super::cosmetics::MARK;
-        let marked = |id: u128| horizon.contains(&id).then_some(horizon_mark);
+        // A hook's mark before a name (Horizon's: they play Horizon).
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        let marked = horizon_hooks::engine::player_mark;
         let inputs = TabInputs {
             players: &players,
             board,

crates/horizon-hooks/src/lib.rs

@@ -44,14 +44,43 @@ pub trait Hooks: Sync {
     /// The game is ending normally: its window closed and the world is saved. Not after a crash.
     fn shutdown(&self) {}
 
-    /// Once a frame, before drawing. Only a window's game calls it (each splitscreen player in
-    /// turn, [`seat`]), never the integrated server's thread or a dedicated server.
-    fn frame(&self, _frame: &players::Frame) {}
+    /// Once a frame, before drawing: `sprites` takes the pictures the crate's
+    /// [`players::Sprites`] lacked. Only a window's game calls it (each splitscreen player in
+    /// turn, [`seat`]), never the integrated server's thread or a dedicated server; so are the
+    /// player methods below (not [`Hooks::tunnel`]).
+    fn frame(&self, _frame: &players::Frame, _sprites: &mut dyn players::SpriteStore) {}
 
-    /// Once a client tick while a world is shown: the player models in view. Called as
-    /// [`Hooks::frame`] is.
+    /// Once a client tick while a world is shown: the player models in view.
     fn tick(&self, _models: &mut dyn players::PlayerModels) {}
 
+    /// What goes by a player model's name over its head, each frame its name tag is drawn. The
+    /// first hook that answers is used.
+    fn name_decoration(
+        &self,
+        _model: &players::PlayerModel,
+        _sprites: &dyn players::Sprites,
+    ) -> Option<players::NameDecoration> {
+        None
+    }
+
+    /// The mark before the name of the player `uuid` in the player list, each frame it shows.
+    /// The first hook that answers is used.
+    fn player_mark(&self, _uuid: u128) -> Option<players::Mark> {
+        None
+    }
+
+    /// How the camera stands in third person, each frame. The first hook that answers is used.
+    fn camera(&self, _own: &players::CameraView) -> Option<players::CameraOverride> {
+        None
+    }
+
+    /// 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.
@@ -163,12 +192,44 @@ pub mod engine {
     }
 
     /// [`Hooks::frame`].
-    pub fn frame(frame: &players::Frame) {
+    pub fn frame(frame: &players::Frame, sprites: &mut dyn players::SpriteStore) {
         for hooks in all() {
-            hooks.frame(frame);
+            hooks.frame(frame, sprites);
         }
     }
 
+    /// [`Hooks::name_decoration`].
+    pub fn name_decoration(
+        model: &players::PlayerModel,
+        sprites: &dyn players::Sprites,
+    ) -> Option<players::NameDecoration> {
+        all().iter().find_map(|h| h.name_decoration(model, sprites))
+    }
+
+    /// [`Hooks::player_mark`].
+    pub fn player_mark(uuid: u128) -> Option<players::Mark> {
+        all().iter().find_map(|h| h.player_mark(uuid))
+    }
+
+    /// [`Hooks::player_layers`].
+    pub fn player_layers(model: &players::PlayerModel, draw: &mut dyn players::PlayerDraw) {
+        for hooks in all() {
+            hooks.player_layers(model, draw);
+        }
+    }
+
+    /// [`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))
+    }
+
     /// [`Hooks::tick`].
     pub fn tick(models: &mut dyn players::PlayerModels) {
         for hooks in all() {
@@ -202,11 +263,44 @@ mod tests {
         fn published(&self, open: bool) {
             self.0.lock().unwrap().push(format!("published {open}"));
         }
-        fn frame(&self, frame: &players::Frame) {
+        fn frame(&self, frame: &players::Frame, sprites: &mut dyn players::SpriteStore) {
             self.0
                 .lock()
                 .unwrap()
                 .push(format!("frame {}", frame.connection));
+            if !sprites.has(1) {
+                sprites.put(1, vec![0; 64 * 64 * 4]);
+            }
+        }
+        fn name_decoration(
+            &self,
+            model: &players::PlayerModel,
+            sprites: &dyn players::Sprites,
+        ) -> Option<players::NameDecoration> {
+            let badge = sprites.get(1).map(|uv| players::Badge::new(uv, 0xFF0000));
+            (model.kind == players::Kind::Player)
+                .then(|| players::NameDecoration::new(Some(MARK), badge, Some(2.0)))
+        }
+        fn player_mark(&self, uuid: u128) -> Option<players::Mark> {
+            (uuid == 9).then_some(MARK)
+        }
+        fn camera(&self, own: &players::CameraView) -> Option<players::CameraOverride> {
+            Some(players::CameraOverride::new(own.age / 10.0))
+        }
+        /// A hat on the head, its brim turned by the model's age.
+        fn player_layers(&self, _: &players::PlayerModel, draw: &mut dyn players::PlayerDraw) {
+            let (Some(head), Some(uv)) = (draw.bone(players::Bone::Head), draw.sprite(1)) else {
+                return;
+            };
+            let turn = draw.ticks() / 100.0;
+            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();
@@ -253,6 +347,87 @@ mod tests {
         }
     }
 
+    const MARK: players::Mark = &[(0, 0, 8, 8, 0xFF00_00FF)];
+
+    /// One sprite slot, as the game's atlas has many.
+    #[derive(Default)]
+    struct Atlas(Option<(u64, usize)>);
+    impl players::SpriteStore for Atlas {
+        fn has(&self, id: u64) -> bool {
+            self.0.is_some_and(|(i, _)| i == id)
+        }
+        fn put(&mut self, id: u64, rgba: Vec<u8>) {
+            self.0 = Some((id, rgba.len()));
+        }
+    }
+    impl players::Sprites for Atlas {
+        fn get(&self, id: u64) -> Option<[f32; 4]> {
+            players::SpriteStore::has(self, id).then_some([0.0, 0.0, 0.5, 0.5])
+        }
+    }
+
+    static HAT: std::sync::LazyLock<std::sync::Arc<players::Mesh>> =
+        std::sync::LazyLock::new(|| {
+            let brim = players::Mesh::new("brim".into(), [0.0; 9], Vec::new(), Vec::new());
+            std::sync::Arc::new(players::Mesh::new(
+                "hat".into(),
+                [0.0; 9],
+                Vec::new(),
+                vec![brim],
+            ))
+        });
+
+    /// 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)>, Vec<f32>);
+    impl players::PlayerDraw for Canvas {
+        fn pass(&self) -> players::Pass {
+            players::Pass::World
+        }
+        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])
+        }
+        fn body_pose(&self) -> Option<&std::sync::Arc<dyn players::BodyPose>> {
+            None
+        }
+        fn sprite(&self, id: u64) -> Option<[f32; 4]> {
+            (id == 1).then_some([0.0, 0.0, 0.5, 0.5])
+        }
+        fn draw(
+            &mut self,
+            mesh: &std::sync::Arc<players::Mesh>,
+            matrix: [[f32; 4]; 4],
+            look: players::Look,
+            pose: &mut dyn FnMut(&mut dyn players::PartPoses),
+        ) {
+            struct Rest([f32; 9]);
+            impl players::PartPoses for Rest {
+                fn pose(&mut self, _: &str) -> &mut [f32; 9] {
+                    &mut self.0
+                }
+            }
+            let mut brim = Rest(mesh.children[0].pose);
+            pose(&mut brim);
+            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));
+        }
+    }
+
     /// Implements nothing: the defaults do nothing.
     struct Silent;
     impl Hooks for Silent {}
@@ -270,7 +445,36 @@ mod tests {
         }
         engine::shutdown();
         assert!(engine::any());
-        engine::frame(&players::Frame::new(4));
+        let mut atlas = Atlas::default();
+        let model = |kind| players::PlayerModel::new(5, kind, Some(9), 0, false);
+        // Before the frame put the sprite in: the decoration without its badge.
+        let before = engine::name_decoration(&model(players::Kind::Player), &atlas).unwrap();
+        assert!(before.badge.is_none() && before.top == Some(2.0));
+        engine::frame(&players::Frame::new(4, false), &mut atlas);
+        assert_eq!(atlas.0, Some((1, 64 * 64 * 4)));
+        let after = engine::name_decoration(&model(players::Kind::Player), &atlas).unwrap();
+        assert_eq!(
+            after.badge.map(|b| (b.uv, b.line)),
+            Some(([0.0, 0.0, 0.5, 0.5], 0xFF0000))
+        );
+        assert!(engine::name_decoration(&model(players::Kind::Mannequin), &atlas).is_none());
+        assert_eq!(engine::player_mark(9), Some(MARK));
+        assert_eq!(engine::player_mark(8), None);
+        let camera = engine::camera(&players::CameraView::new(5.0));
+        assert_eq!(camera.map(|c| c.distance), Some(0.5));
+        let mut canvas = Canvas::default();
+        engine::player_layers(&model(players::Kind::Player), &mut canvas);
+        assert_eq!(
+            canvas.0,
+            [(
+                "hat".to_owned(),
+                [[1.0, 0.0, 0.0, 0.0]; 4],
+                [0.0, 0.0, 0.5, 0.5],
+                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

@@ -1,7 +1,7 @@
 //! The players the game shows, as a crate above the engine sees them (Horizon's emotes, spec
-//! #14091): [`PlayerModels`] in [`crate::Hooks::tick`], [`Frame`] in [`crate::Hooks::frame`], and
-//! [`BodyPose`], a pose laid over a player's body after its vanilla animation. Plain types only:
-//! no engine type crosses this line.
+//! #14091): [`PlayerModels`] in [`crate::Hooks::tick`], [`Frame`] in [`crate::Hooks::frame`],
+//! [`BodyPose`], a pose laid over a player's body after its vanilla animation, what goes by their
+//! names, and the crate's [`Sprites`]. Plain types only: no engine type crosses this line.
 use std::sync::Arc;
 
 /// The player model's parts a [`BodyPose`] poses, in its order.
@@ -44,12 +44,17 @@ pub struct PlayerModel {
     /// Its entity id on this connection ([`PlayerModels::connection`]).
     pub id: u32,
     pub kind: Kind,
-    /// The player's UUID as the server gave it; None for the window's own model and mannequins.
+    /// The player's UUID as the server gave it (the window's own: its profile); None for
+    /// mannequins.
     pub uuid: Option<u128>,
     /// Its age in ticks, the clock a [`BodyPose`] is timed on.
     pub age: u32,
     /// It moved sideways since the last tick (more than 0.01 blocks).
     pub moved: bool,
+    /// What it wears that covers a crate's drawing.
+    pub gear: Gear,
+    /// It is drawn invisible (the effect, or a trader's disguise).
+    pub invisible: bool,
 }
 
 impl PlayerModel {
@@ -60,8 +65,37 @@ impl PlayerModel {
             uuid,
             age,
             moved,
+            gear: Gear::default(),
+            invisible: false,
         }
     }
+
+    /// With what it wears and whether it is invisible.
+    pub fn looks(self, gear: Gear, invisible: bool) -> Self {
+        Self {
+            gear,
+            invisible,
+            ..self
+        }
+    }
+}
+
+/// What a player model wears where a crate may draw.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct Gear {
+    /// A helmet or a head item.
+    pub head: bool,
+    /// A chestplate (an elytra is on the back).
+    pub chest: bool,
+    /// A cape or an elytra.
+    pub back: bool,
+}
+
+impl Gear {
+    pub fn new(head: bool, chest: bool, back: bool) -> Self {
+        Self { head, chest, back }
+    }
 }
 
 /// The player models of the world this window shows, once a tick ([`crate::Hooks::tick`]).
@@ -83,10 +117,340 @@ pub trait PlayerModels {
 pub struct Frame {
     /// As [`PlayerModels::connection`]; 0 with no world.
     pub connection: u64,
+    /// The world is the window's own single-player one: its server names the player by an
+    /// offline profile.
+    pub solo: bool,
 }
 
 impl Frame {
-    pub fn new(connection: u64) -> Self {
-        Self { connection }
+    pub fn new(connection: u64, solo: bool) -> Self {
+        Self { connection, solo }
     }
 }
+
+/// Rectangles drawn before a name: x, y, width, height in text pixels from the name line's top
+/// left corner (a pixel left of its background), and `0xAARRGGBB`.
+pub type Mark = &'static [(u8, u8, u8, u8, u32)];
+
+/// What a crate draws by a player's name over their head ([`crate::Hooks::name_decoration`]).
+#[derive(Clone, Copy, Debug, Default)]
+#[non_exhaustive]
+pub struct NameDecoration {
+    /// Before the name.
+    pub mark: Option<Mark>,
+    /// After the name, and a line under it.
+    pub badge: Option<Badge>,
+    /// How high the crate's drawing on the body gets above the neck, in model pixels: the tag
+    /// goes up over it.
+    pub top: Option<f32>,
+}
+
+impl NameDecoration {
+    pub fn new(mark: Option<Mark>, badge: Option<Badge>, top: Option<f32>) -> Self {
+        Self { mark, badge, top }
+    }
+}
+
+/// A badge after a name: 8 text pixels square, a pixel right of the background.
+#[derive(Clone, Copy, Debug)]
+#[non_exhaustive]
+pub struct Badge {
+    /// Its picture: a part of a [`Sprites`] sprite, in atlas coordinates (u0, v0, u1, v1).
+    pub uv: [f32; 4],
+    /// The line under the name, `0xRRGGBB`.
+    pub line: u32,
+}
+
+impl Badge {
+    pub fn new(uv: [f32; 4], line: u32) -> Self {
+        Self { uv, line }
+    }
+}
+
+/// A crate's pictures in the game's atlas, by ids of its own: 64×64 RGBA each, in the slots skins
+/// use (one no frame drew for a while may go). Read while drawing.
+pub trait Sprites {
+    /// Where sprite `id` is (u0, v0, u1, v1), and it is kept this frame. None until
+    /// [`SpriteStore::put`] put it there.
+    fn get(&self, id: u64) -> Option<[f32; 4]>;
+}
+
+/// Where a crate puts its [`Sprites`], in [`crate::Hooks::frame`].
+pub trait SpriteStore {
+    /// Sprite `id` is in the atlas.
+    fn has(&self, id: u64) -> bool;
+    /// Puts sprite `id` in the atlas (64×64 RGBA), if a slot is free.
+    fn put(&mut self, id: u64, rgba: Vec<u8>);
+}
+
+/// The window's own model, as [`crate::Hooks::camera`] sees it.
+#[derive(Clone, Copy, Debug)]
+#[non_exhaustive]
+pub struct CameraView {
+    /// Its age in ticks, with the frame's part of a tick.
+    pub age: f32,
+}
+
+impl CameraView {
+    pub fn new(age: f32) -> Self {
+        Self { age }
+    }
+}
+
+/// How a crate moves the camera in third person.
+#[derive(Clone, Copy, Debug)]
+#[non_exhaustive]
+pub struct CameraOverride {
+    /// How far it stands back, as a share of the usual distance.
+    pub distance: f32,
+}
+
+impl CameraOverride {
+    pub fn new(distance: f32) -> Self {
+        Self { distance }
+    }
+}
+
+/// A model a crate draws on players, as the game's own models are: a tree of parts, 16 units a
+/// block, y down. Build it once and keep the `Arc`: the engine prepares it for the GPU once, by
+/// the `Arc`'s address, while the crate holds it.
+#[derive(Clone, Debug, Default)]
+#[non_exhaustive]
+pub struct Mesh {
+    /// What [`PartPoses::pose`] names it by.
+    pub name: String,
+    /// At rest: x, y, z, x/y/z rotation (radians), x/y/z scale.
+    pub pose: [f32; 9],
+    pub quads: Vec<Quad>,
+    pub children: Vec<Mesh>,
+}
+
+impl Mesh {
+    pub fn new(name: String, pose: [f32; 9], quads: Vec<Quad>, children: Vec<Mesh>) -> Self {
+        Self {
+            name,
+            pose,
+            quads,
+            children,
+        }
+    }
+}
+
+/// One face of a [`Mesh`].
+#[derive(Clone, Copy, Debug)]
+#[non_exhaustive]
+pub struct Quad {
+    pub normal: [f32; 3],
+    /// Its corners: x, y, z, then u, v across the sprite (0 to 1).
+    pub vertices: [[f32; 5]; 4],
+}
+
+impl Quad {
+    pub fn new(normal: [f32; 3], vertices: [[f32; 5]; 4]) -> Self {
+        Self { normal, vertices }
+    }
+}
+
+/// A part of the player's body a crate draws on.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Bone {
+    Head,
+    Body,
+    RightArm,
+    LeftArm,
+    RightLeg,
+    LeftLeg,
+}
+
+impl Bone {
+    /// Its name among [`BODY_PARTS`].
+    pub fn part(self) -> &'static str {
+        BODY_PARTS[self as usize]
+    }
+}
+
+/// Which picture of a player is drawn.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Pass {
+    /// 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.
+pub trait PartPoses {
+    /// Part `name`'s pose, to change (see [`Mesh::pose`]); a name the mesh lacks gets a pose that
+    /// is not used.
+    fn pose(&mut self, name: &str) -> &mut [f32; 9];
+}
+
+/// Where a crate draws on a player model ([`crate::Hooks::player_layers`]). Matrices are
+/// column-major, relative to the camera, in blocks.
+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;
+    /// 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` as `look` says; `pose` poses its parts first.
+    fn draw(
+        &mut self,
+        mesh: &Arc<Mesh>,
+        matrix: [[f32; 4]; 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

@@ -47,9 +47,12 @@ pub use horizon_server_files as server_files;
 /// in"). The engine's dispatch side is not part of the API.
 pub mod hooks {
     /// The players the game shows (`horizon_hooks::players`): the views [`Hooks::frame`] and
-    /// [`Hooks::tick`] get, and the pose a crate lays over a player's body.
+    /// [`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, BodyPose, Frame, Kind, PlayerModel, PlayerModels,
+        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};
 }