Merge branch 'split/cosmetics-names' into split/cosmetics-draw

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

crates/horizon-client-render/src/settings.rs

@@ -337,6 +337,13 @@ impl Settings {
             .and_then(|mode| self.video_modes.iter().position(|m| *m == mode))
             .map_or(-1, |i| i as i32)
     }
+    /// Loads only the crates' settings stores (`horizon_hooks::settings`) from the files next to
+    /// `path`, into the seat whose turn it is (`horizon_hooks::seat`): a splitscreen player whose
+    /// settings were made from P1's rather than loaded.
+    pub fn load_stores(path: &Path) {
+        let dir = path.parent();
+        horizon_hooks::settings::engine::load(&mut |file| fs::read_to_string(dir?.join(file)).ok());
+    }
     pub fn load(path: &Path) -> Self {
         let mut horizon = path
             .parent()

crates/horizon-client/src/entry.rs

@@ -23,8 +23,9 @@ pub fn main_with(mods: crate::mod_api::Mods) {
     horizon_client::telemetry::mark_start();
     // Opt-in telemetry keeps each crash report (docs/telemetry.md), whatever the mode.
     crash::on_report(horizon_client::telemetry::keep_crash);
-    // Crates above the engine registered their hooks before this (horizon-official's `main`);
-    // none registers after this point.
+    // Crates above the engine registered their hooks before this (horizon-official's `main`),
+    // then the Horizon parts still in this crate; none registers after this point.
+    game::player_hooks::register();
     horizon_hooks::engine::seal();
     horizon_client::spans::startup::init(std::time::Instant::now());
     horizon_client::spans::trace::start_from_env();

crates/horizon-client/src/game.rs

@@ -373,6 +373,7 @@ mod place_feature_tests;
 mod play_input;
 mod play_keys;
 mod player_equip;
+pub(crate) mod player_hooks;
 mod player_spawn;
 mod pointer_capture;
 #[cfg(test)]
@@ -7492,7 +7493,6 @@ impl Game<'_> {
         self.spawn_phantoms();
         self.tick_advancements();
         self.tick_player_model();
-        self.tick_emotes();
         Ok(())
     }
 

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

@@ -20,13 +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::{
+    Badge, CameraOverride, CameraView, Frame, Gear, Kind, Mark, NameDecoration, PlayerModel,
+    PlayerModels, SpriteStore, Sprites,
+};
 use std::cell::{Cell, RefCell};
-use std::sync::Arc;
 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 {
@@ -55,7 +59,8 @@ impl Baked {
 
 #[derive(Default)]
 pub(super) struct Cosmetics {
-    client: Option<horizon_cosmetics::Cosmetics>,
+    /// The hooks' client (`Seat`), taken once it started.
+    client: Option<Arc<horizon_cosmetics::Cosmetics>>,
     /// By the item's address; each entry holds its item, so the address isn't reused.
     baked: RefCell<FxHashMap<usize, Baked>>,
     /// Items drawn whose texture isn't in the atlas yet.
@@ -65,16 +70,6 @@ pub(super) struct Cosmetics {
     poses: RefCell<(Poses, Poses)>,
     /// Item files from a folder (`HORIZON_COSMETICS_LOCAL`): mannequins wear them too.
     local: bool,
-    /// Show my cosmetics on its way to the service.
-    mine: AccountSync,
-    /// Show me as a Horizon player: sent at start, on each change and every hour while on.
-    listed: AccountSync,
-    /// Whether the signed-in account owns a cosmetic.
-    owner: OwnerCheck,
-    /// Which other players play an emote (`horizon_cosmetics::Feed`), started with the client.
-    feed: Option<horizon_cosmetics::Feed>,
-    /// My emote on its way to the service.
-    emote_out: EmoteOut,
     /// Companions, trails and auras.
     fx: RefCell<Fx>,
     /// Emotes: those the wheel offers and the one playing (`cosmetics/emotes.rs`).
@@ -405,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,
@@ -427,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?
@@ -449,115 +440,424 @@ pub(super) fn enabled() -> bool {
     cfg!(feature = "horizon-extras") && horizon_cosmetics::enabled()
 }
 
+/// What the cosmetics' hooks keep for one splitscreen player (`horizon_hooks::seat`): the
+/// service's client, the emote feed and what the account tells the service.
+#[derive(Default)]
+struct Seat {
+    client: Option<Arc<horizon_cosmetics::Cosmetics>>,
+    /// Item files from a folder (`HORIZON_COSMETICS_LOCAL`).
+    local: bool,
+    /// Show my cosmetics on its way to the service.
+    mine: AccountSync,
+    /// Show me as a Horizon player: sent at start, on each change and every hour while on.
+    listed: AccountSync,
+    /// Whether the signed-in account owns a cosmetic.
+    owner: OwnerCheck,
+    /// Which other players play an emote (`horizon_cosmetics::Feed`), started with the client.
+    feed: Option<horizon_cosmetics::Feed>,
+    /// My emote on its way to the service.
+    emote_out: EmoteOut,
+    /// What the game's settings and the player's emote say (`Game::cosmetics_say`).
+    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,
+    /// Name tag badges' sprites, by the item's address: their id (never reused) and the item,
+    /// held so the address isn't reused while it is there.
+    sprites: FxHashMap<usize, (u64, Arc<Item>)>,
+    last_sprite: u64,
+    /// Sprites drawing missed, put in the atlas next frame.
+    wanted: Vec<u64>,
+}
+
+/// What the game tells the hooks before each call, until the settings move here (spec #14091
+/// step 5a) and the player's emote with them (step 4).
+#[derive(Default)]
+struct Said {
+    mine: bool,
+    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.
+    first: Option<Arc<Item>>,
+}
+
+/// One [`Seat`] per splitscreen player.
+static SERVICES: Mutex<Vec<Seat>> = Mutex::new(Vec::new());
+
+/// Runs `f` on this seat's [`Seat`]. Never called inside itself.
+fn service<R>(f: impl FnOnce(&mut Seat) -> R) -> R {
+    let seat = horizon_hooks::seat();
+    let mut all = SERVICES.lock().unwrap_or_else(PoisonError::into_inner);
+    if all.len() <= seat {
+        all.resize_with(seat + 1, Seat::default);
+    }
+    f(&mut all[seat])
+}
+
+/// The cosmetics' hooks, registered when [`enabled`].
+pub(super) struct Hooks;
+pub(super) static HOOKS: Hooks = Hooks;
+
+impl horizon_hooks::Hooks for Hooks {
+    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 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 {
+    /// Once a frame: starts the service's client on first use, asks whether the account owns a
+    /// cosmetic, and tells the service what the account shows.
+    fn frame(&mut self) {
+        if self.client.is_none() {
+            let (client, local) = Cosmetics::client();
+            self.client = Some(Arc::new(client));
+            self.local = local;
+            // Others' emotes come from the service only (a local folder has no one playing).
+            if !local {
+                self.feed = Some(horizon_cosmetics::Feed::new(http()));
+            }
+        }
+        // Item files from a folder (the art, the bench): shown as to an owner, nothing asked.
+        if self.local {
+            self.owner.owns = true;
+            return;
+        }
+        // Whether the account owns a cosmetic: what the last run learnt, then the service.
+        let o = &mut self.owner;
+        if !o.started {
+            o.started = true;
+            o.owns = account()
+                .is_some_and(|(_, uuid, home)| prefs::owned(&home, &uuid).unwrap_or(false));
+        }
+        if let Some(done) = o.asking.as_ref().and_then(|rx| rx.try_recv().ok()) {
+            o.asking = None;
+            match done {
+                Ok(owns) => (o.owns, o.known, o.retry) = (owns, true, None),
+                Err(_) => o.retry = backoff(o.retry),
+            }
+        }
+        // One sign-in at a time: Mojang keeps one joined server id per account.
+        let due = !o.known && o.retry.is_none_or(|(at, _)| Instant::now() >= at);
+        if due && o.asking.is_none() && self.mine.sending.is_none() && self.listed.sending.is_none()
+        {
+            let (tx, rx) = channel();
+            o.asking = Some(rx);
+            std::thread::Builder::new()
+                .name("Cosmetics account".into())
+                .spawn(move || {
+                    let _ = tx.send(check_owner());
+                })
+                .ok();
+        }
+        // Show my cosmetics: sent once per change of the wish, then retried until confirmed.
+        // Show me as a Horizon player: also said again every hour while on.
+        let every = horizon_cosmetics::account::PRESENCE_EVERY;
+        self.mine.settle(None);
+        self.listed.settle(Some(every));
+        // One sign-in at a time, as for the ownership check above.
+        let busy = self.owner.asking.is_some()
+            || self.mine.sending.is_some()
+            || self.listed.sending.is_some();
+        let said = &self.said;
+        if let Some(done) = self
+            .emote_out
+            .sending
+            .as_ref()
+            .and_then(|rx| rx.try_recv().ok())
+        {
+            self.emote_out.sending = None;
+            match done {
+                Ok(()) => self.emote_out.retry = None,
+                Err(_) => {
+                    self.emote_out.retry = backoff(self.emote_out.retry);
+                    self.emote_out.sent = None;
+                }
+            }
+        }
+        // My emote: only while I show myself as a Horizon player (playing one says so).
+        let playing = said.playing.as_ref();
+        let looping = playing.is_some_and(|(_, looping)| *looping);
+        let wish = playing.map(|(id, _)| id.as_str()).filter(|_| said.listed);
+        let o = &mut self.emote_out;
+        let changed = o.sent.as_ref().map(Option::as_deref) != Some(wish);
+        let again = looping && o.again.is_some_and(|at| Instant::now() >= at);
+        let waited = o.retry.is_none_or(|(at, _)| Instant::now() >= at);
+        // Nothing sent yet and nothing playing: nothing to say (a failed send forgets what
+        // was sent: the service ends a one-shot by itself, a loop within a minute).
+        let quiet = wish.is_none() && o.sent.is_none();
+        let emote_due = !quiet && waited && (changed || again);
+        // One sign-in at a time, the emote's included.
+        if busy || o.sending.is_some() {
+        } else if emote_due {
+            let wish = wish.map(str::to_owned);
+            o.sent = Some(wish.clone());
+            o.again = looping.then(|| Instant::now() + LOOP_AGAIN);
+            let (tx, rx) = channel();
+            o.sending = Some(rx);
+            let kept = o.kept.clone();
+            std::thread::Builder::new()
+                .name("Cosmetics emote".into())
+                .spawn(move || {
+                    let _ = tx.send(send_emote(&kept, wish.as_deref()));
+                })
+                .ok();
+        } else if self.mine.due(said.mine) {
+            self.mine.start(said.mine, send_mine);
+        } else if self.listed.due(said.listed) {
+            self.listed.start(said.listed, send_listed);
+        }
+    }
+
+    /// 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 = match m.kind {
+            Kind::Own => own_uuid(m.uuid, self.solo, 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,
+        }?;
+        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 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 (it is put there next frame).
+    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 next = self.last_sprite + 1;
+        let (id, _) = *self
+            .sprites
+            .entry(Arc::as_ptr(item) as usize)
+            .or_insert_with(|| (next, item.clone()));
+        self.last_sprite = self.last_sprite.max(id);
+        let Some([u0, v0, u1, v1]) = sprites.get(id) else {
+            if !self.wanted.contains(&id) {
+                self.wanted.push(id);
+            }
+            return None;
+        };
+        // The mark sits in the slot's top left corner.
+        let u1 = u0 + (u1 - u0) * item.texture.width as f32 / 64.0;
+        let v1 = v0 + (v1 - v0) * item.texture.height as f32 / 64.0;
+        Some(Badge::new(
+            [u0, v0, u1, v1],
+            u32::from_be_bytes([0, r, g, b]),
+        ))
+    }
+
+    /// Puts the sprites drawing missed in the atlas; forgets those of items no one wears.
+    fn put_sprites(&mut self, store: &mut dyn SpriteStore) {
+        for id in self.wanted.drain(..) {
+            let item = self.sprites.values().find(|(i, _)| *i == id);
+            if let Some((_, item)) = item.filter(|_| !store.has(id)) {
+                store.put(id, slot_image(item));
+            }
+        }
+        self.sprites
+            .retain(|_, (_, item)| Arc::strong_count(item) > 1);
+    }
+
+    /// 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.
+    fn tick(&mut self, models: &mut dyn PlayerModels) {
+        let mut seen = std::mem::take(&mut self.models);
+        seen.clear();
+        models.for_each(&mut |m| {
+            if m.kind != Kind::Own {
+                seen.push(m);
+            }
+        });
+        self.play_others(models, &mut seen);
+        self.models = seen;
+    }
+
+    fn play_others(&self, models: &mut dyn PlayerModels, view: &mut Vec<PlayerModel>) {
+        let shown = self.said.others_shown;
+        // Items from a folder (the art, the bench): every mannequin plays its first emote, again
+        // and again.
+        if self.local && shown {
+            let Some(first) = &self.said.first else {
+                return;
+            };
+            for m in view.iter().filter(|m| m.kind == Kind::Mannequin) {
+                let age = m.age as f32;
+                let now = emotes::pose_playing(models.body_pose(m.id));
+                if now.is_none_or(|p| p.at(age).is_none()) {
+                    let playing = horizon_cosmetics::Playing {
+                        item: first.clone(),
+                        // Out of step, so a crowd doesn't move as one.
+                        start: age - (m.id % 40) as f32,
+                        stop: None,
+                    };
+                    emotes::set_model_playing(models, m.id, Some(playing));
+                }
+            }
+            return;
+        }
+        let (Some(feed), Some(client)) = (&self.feed, &self.client) else {
+            return;
+        };
+        if !shown {
+            feed.ask([]);
+            for m in view.iter() {
+                emotes::set_model_playing(models, m.id, None);
+            }
+            return;
+        }
+        let mut frame = client.frame();
+        view.retain(|m| m.kind == Kind::Player && m.uuid.is_some_and(|u| frame.horizon(u)));
+        drop(frame);
+        feed.ask(view.iter().filter_map(|m| m.uuid));
+        let now = Instant::now();
+        for m in view.iter() {
+            let Some(uuid) = m.uuid else { continue };
+            let seen = feed.playing(uuid);
+            let age = m.age as f32;
+            let mut next = emotes::pose_playing(models.body_pose(m.id)).cloned();
+            match (seen, &mut next) {
+                (Some(seen), Some(p)) if Arc::ptr_eq(&p.item, &seen.item) => {
+                    if m.moved && p.stop.is_none() {
+                        p.stop = Some(age);
+                    }
+                }
+                (Some(seen), slot) if !m.moved => {
+                    let ticks = now.duration_since(seen.started).as_secs_f32() * 20.0;
+                    *slot = Some(horizon_cosmetics::Playing {
+                        item: seen.item,
+                        start: age - ticks,
+                        stop: None,
+                    });
+                }
+                (_, Some(p)) if p.stop.is_none() => p.stop = Some(age),
+                _ => {}
+            }
+            emotes::set_model_playing(models, m.id, next.filter(|p| p.at(age).is_some()));
+        }
+    }
+}
+
 impl Game<'_> {
-    /// Once a frame, before drawing: starts the service's client on first use and puts the
+    /// Hands the hooks what the game's settings and the player's emote say (allocating only when
+    /// the emote changes).
+    pub(super) fn cosmetics_say(&mut self) {
+        if !enabled() {
+            return;
+        }
+        let first = if self.cosmetics.local {
+            service(|s| s.said.first.is_none())
+                .then(|| self.owned_emotes().first().cloned())
+                .flatten()
+        } else {
+            None
+        };
+        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));
+            }
+            if first.is_some() {
+                said.first = first;
+            }
+        });
+    }
+
+    /// Once a frame, after the hooks: takes the service's client for drawing and puts the
     /// textures the last frame wanted into the atlas.
     pub(super) fn cosmetics_frame(&mut self) {
         if !enabled() {
             return;
         }
         let c = &mut self.cosmetics;
-        if c.client.is_none() {
-            let (client, local) = Cosmetics::client();
-            c.client = Some(client);
-            c.local = local;
-            // Others' emotes come from the service only (a local folder has no one playing).
-            if !local {
-                c.feed = Some(horizon_cosmetics::Feed::new(http()));
+        let owns = service(|s| {
+            if c.client.is_none() {
+                c.client = s.client.clone();
+                c.local = s.local;
             }
-        }
+            s.owner.owns
+        });
+        // Read every frame: the settings button shows it, and it is never saved.
+        self.settings.extras.cosmetics_owner = owns;
         c.frame.set(c.frame.get().wrapping_add(1));
         c.fx.get_mut().frame(c.frame.get());
-        // Item files from a folder (the art, the bench): shown as to an owner, nothing asked.
-        if c.local {
-            c.owner.owns = true;
-        } else {
-            // Whether the account owns a cosmetic: what the last run learnt, then the service.
-            let o = &mut c.owner;
-            if !o.started {
-                o.started = true;
-                o.owns = account()
-                    .is_some_and(|(_, uuid, home)| prefs::owned(&home, &uuid).unwrap_or(false));
-            }
-            if let Some(done) = o.asking.as_ref().and_then(|rx| rx.try_recv().ok()) {
-                o.asking = None;
-                match done {
-                    Ok(owns) => (o.owns, o.known, o.retry) = (owns, true, None),
-                    Err(_) => o.retry = backoff(o.retry),
-                }
-            }
-            // One sign-in at a time: Mojang keeps one joined server id per account.
-            let due = !o.known && o.retry.is_none_or(|(at, _)| Instant::now() >= at);
-            if due && o.asking.is_none() && c.mine.sending.is_none() && c.listed.sending.is_none() {
-                let (tx, rx) = channel();
-                o.asking = Some(rx);
-                std::thread::Builder::new()
-                    .name("Cosmetics account".into())
-                    .spawn(move || {
-                        let _ = tx.send(check_owner());
-                    })
-                    .ok();
-            }
-        }
-        // Read every frame: the settings button shows it, and it is never saved.
-        self.settings.extras.cosmetics_owner = c.owner.owns;
-        // Show my cosmetics: sent once per change of the wish, then retried until confirmed.
-        // Show me as a Horizon player: also said again every hour while on.
-        if !c.local {
-            let every = horizon_cosmetics::account::PRESENCE_EVERY;
-            c.mine.settle(None);
-            c.listed.settle(Some(every));
-            // One sign-in at a time, as for the ownership check above.
-            let busy =
-                c.owner.asking.is_some() || c.mine.sending.is_some() || c.listed.sending.is_some();
-            let extras = &self.settings.extras;
-            if let Some(done) = c
-                .emote_out
-                .sending
-                .as_ref()
-                .and_then(|rx| rx.try_recv().ok())
-            {
-                c.emote_out.sending = None;
-                match done {
-                    Ok(()) => c.emote_out.retry = None,
-                    Err(_) => {
-                        c.emote_out.retry = backoff(c.emote_out.retry);
-                        c.emote_out.sent = None;
-                    }
-                }
-            }
-            // My emote: only while I show myself as a Horizon player (playing one says so).
-            let playing = c.emotes.sending();
-            let looping = playing.as_ref().is_some_and(|(_, looping)| *looping);
-            let wish = playing.map(|(id, _)| id).filter(|_| extras.horizon_listed);
-            let o = &mut c.emote_out;
-            let changed = o.sent.as_ref() != Some(&wish);
-            let again = looping && o.again.is_some_and(|at| Instant::now() >= at);
-            let waited = o.retry.is_none_or(|(at, _)| Instant::now() >= at);
-            // Nothing sent yet and nothing playing: nothing to say (a failed send forgets what
-            // was sent: the service ends a one-shot by itself, a loop within a minute).
-            let quiet = wish.is_none() && o.sent.is_none();
-            let emote_due = !quiet && waited && (changed || again);
-            // One sign-in at a time, the emote's included.
-            if busy || o.sending.is_some() {
-            } else if emote_due {
-                o.sent = Some(wish.clone());
-                o.again = looping.then(|| Instant::now() + LOOP_AGAIN);
-                let (tx, rx) = channel();
-                o.sending = Some(rx);
-                let kept = o.kept.clone();
-                std::thread::Builder::new()
-                    .name("Cosmetics emote".into())
-                    .spawn(move || {
-                        let _ = tx.send(send_emote(&kept, wish.as_deref()));
-                    })
-                    .ok();
-            } else if c.mine.due(extras.cosmetics_mine) {
-                c.mine.start(extras.cosmetics_mine, send_mine);
-            } else if c.listed.due(extras.horizon_listed) {
-                c.listed.start(extras.horizon_listed, send_listed);
-            }
-        }
         let uploads = std::mem::take(&mut *c.uploads.borrow_mut());
         for item in uploads {
             let location = format!("cosmetics/{:x}", Arc::as_ptr(&item) as usize);
@@ -572,88 +872,6 @@ impl Game<'_> {
             .retain(|_, b| Arc::strong_count(&b.item) > 1);
     }
 
-    /// 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.
-    pub(super) fn tick_others_emotes(&mut self) {
-        let shown = self.settings.extras.effective_others() == Others::Shown;
-        // Items from a folder (the art, the bench): every mannequin plays its first emote, again
-        // and again.
-        if self.cosmetics.local && shown {
-            let Some(first) = self.owned_emotes().first().cloned() else {
-                return;
-            };
-            for m in self.mobs.iter_mut() {
-                let age = m.age as f32;
-                if &*m.kind.id == "minecraft:mannequin"
-                    && emotes::playing(m).is_none_or(|p| p.at(age).is_none())
-                {
-                    let playing = horizon_cosmetics::Playing {
-                        item: first.clone(),
-                        // Out of step, so a crowd doesn't move as one.
-                        start: age - (m.id % 40) as f32,
-                        stop: None,
-                    };
-                    emotes::set_playing(m, Some(playing));
-                }
-            }
-            return;
-        }
-        let (Some(feed), Some(client)) = (&self.cosmetics.feed, &self.cosmetics.client) else {
-            return;
-        };
-        if !shown {
-            feed.ask([]);
-            for m in self.mobs.iter_mut() {
-                emotes::set_playing(m, None);
-            }
-            return;
-        }
-        let mut frame = client.frame();
-        let mut horizon = Vec::new();
-        for m in self.mobs.iter() {
-            if &*m.kind.id == "minecraft:player"
-                && let Some(uuid) = self.remote_player_uuid(m.id)
-                && frame.horizon(uuid)
-            {
-                horizon.push((m.id, uuid));
-            }
-        }
-        drop(frame);
-        feed.ask(horizon.iter().map(|(_, u)| *u));
-        let now = Instant::now();
-        for (id, uuid) in horizon {
-            let seen = feed.playing(uuid);
-            let Some(m) = self.mobs.iter_mut().find(|m| m.id == id) else {
-                continue;
-            };
-            let age = m.age as f32;
-            let moved = {
-                let (dx, dz) = (m.position.x - m.previous.x, m.position.z - m.previous.z);
-                dx * dx + dz * dz > 1e-4
-            };
-            let mut next = emotes::playing(m).cloned();
-            match (seen, &mut next) {
-                (Some(seen), Some(p)) if Arc::ptr_eq(&p.item, &seen.item) => {
-                    if moved && p.stop.is_none() {
-                        p.stop = Some(age);
-                    }
-                }
-                (Some(seen), slot) if !moved => {
-                    let ticks = now.duration_since(seen.started).as_secs_f32() * 20.0;
-                    *slot = Some(horizon_cosmetics::Playing {
-                        item: seen.item,
-                        start: age - ticks,
-                        stop: None,
-                    });
-                }
-                (_, Some(p)) if p.stop.is_none() => p.stop = Some(age),
-                _ => {}
-            }
-            emotes::set_playing(m, next.filter(|p| p.at(age).is_some()));
-        }
-    }
-
     /// Asks the service which emotes the account owns, for the wheel: when it opens, at most
     /// every 10 minutes (a folder's emotes need no asking; an offline account has none).
     pub(super) fn refresh_owned_emotes(&mut self) {
@@ -669,7 +887,7 @@ impl Game<'_> {
         }
         let (tx, rx) = channel();
         e.loading = Some(rx);
-        let kept = self.cosmetics.emote_out.kept.clone();
+        let kept = service(|s| s.emote_out.kept.clone());
         std::thread::Builder::new()
             .name("Cosmetics emotes owned".into())
             .spawn(move || {
@@ -678,81 +896,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()?;
@@ -844,7 +987,7 @@ impl Game<'_> {
                 }
                 continue;
             }
-            if emoting.is_none() && covered(m, item.slot) {
+            if emoting.is_none() && covered(super::player_hooks::gear(m), item.slot) {
                 continue;
             }
             let Some((models, uv)) = self.cosmetics_baked(item) else {
@@ -962,7 +1105,7 @@ impl Game<'_> {
 mod tests {
     use super::*;
     use horizon_client::extras::Extras;
-    use std::sync::Mutex;
+    use horizon_client::mobs::anim::BodyPose;
 
     /// A name tag style with a 1×1 mark.
     const TAG: &str = r##"{"format": 1, "id": "tag", "slot": "name_tag", "parts": [],
@@ -1150,13 +1293,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.
@@ -1170,7 +1318,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] {
@@ -1186,4 +1336,66 @@ mod tests {
             assert_eq!(tag(top_of(&extras, patience)), VANILLA, "{others:?}");
         }
     }
+
+    /// Player models as the hooks see them, with the pose laid over each.
+    struct View(Vec<(PlayerModel, Option<Arc<dyn BodyPose>>)>);
+
+    impl PlayerModels for View {
+        fn connection(&self) -> u64 {
+            1
+        }
+        fn for_each(&self, f: &mut dyn FnMut(PlayerModel)) {
+            self.0.iter().for_each(|(m, _)| f(*m));
+        }
+        fn body_pose(&self, id: u32) -> Option<&Arc<dyn BodyPose>> {
+            self.0.iter().find(|(m, _)| m.id == id)?.1.as_ref()
+        }
+        fn set_body_pose(&mut self, id: u32, pose: Option<Arc<dyn BodyPose>>) {
+            if let Some((_, p)) = self.0.iter_mut().find(|(m, _)| m.id == id) {
+                *p = pose;
+            }
+        }
+    }
+
+    #[test]
+    fn with_a_folder_mannequins_play_its_first_emote_out_of_step_and_players_do_not() {
+        let item = Arc::new(
+            Item::parse(
+                br#"{"format": 1, "id": "up", "slot": "emote", "parts": [],
+                    "emote": {"length": 20, "blend": 0, "tracks": [
+                      {"part": "right_arm", "keys": [{"t": 10, "rotation": [0, 0, 90]}]}]}}"#,
+            )
+            .unwrap(),
+        );
+        let mut service = Seat {
+            local: true,
+            said: Said {
+                others_shown: true,
+                first: Some(item.clone()),
+                ..Said::default()
+            },
+            ..Seat::default()
+        };
+        let model = |id, kind, uuid| (PlayerModel::new(id, kind, uuid, 50, false), None);
+        let mut view = View(vec![
+            model(1, Kind::Own, None),
+            model(41, Kind::Mannequin, None),
+            model(2, Kind::Player, Some(7)),
+        ]);
+        service.tick(&mut view);
+        let playing = emotes::pose_playing(view.0[1].1.as_ref()).expect("the mannequin plays");
+        assert!(Arc::ptr_eq(&playing.item, &item));
+        // Out of step by its id: 50 - 41 % 40.
+        assert_eq!(playing.start, 49.0);
+        assert!(view.0[0].1.is_none() && view.0[2].1.is_none());
+        // Still playing: the same pose stays.
+        let first = view.0[1].1.clone().unwrap();
+        service.tick(&mut view);
+        assert!(Arc::ptr_eq(&first, view.0[1].1.as_ref().unwrap()));
+        // Others' cosmetics not shown: a new mannequin plays nothing.
+        service.said.others_shown = false;
+        view.0.push(model(3, Kind::Mannequin, None));
+        service.tick(&mut view);
+        assert!(view.0[3].1.is_none());
+    }
 }

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

@@ -10,6 +10,7 @@ use horizon_client::mobs::Mob;
 use horizon_client::mobs::anim::BodyPose;
 use horizon_cosmetics::account::OwnedEmote;
 use horizon_cosmetics::{Item, Playing, Slot};
+use horizon_hooks::players::PlayerModels;
 use std::sync::Arc;
 
 /// How far the player may drift (blocks) before the emote stops: a nudge, not a step.
@@ -37,10 +38,15 @@ pub(in crate::game) struct Emotes {
 
 impl Emotes {
     /// The emote to tell the service about, while it plays: its id and whether it loops.
-    pub(in crate::game) fn sending(&self) -> Option<(String, bool)> {
+    pub(in crate::game) fn sending(&self) -> Option<(&str, bool)> {
         let p = self.playing.as_ref().filter(|p| p.stop.is_none())?;
         let looping = p.item.emote.as_ref().is_some_and(|e| e.looping);
-        Some((p.item.id.clone(), 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)
     }
 }
 
@@ -59,23 +65,48 @@ impl BodyPose for EmotePose {
     }
 }
 
-/// The emote `m` plays, if any.
-pub(in crate::game) fn playing(m: &Mob) -> Option<&Playing> {
-    let any: &dyn std::any::Any = &**m.emote.as_ref()?;
+/// The emote a model's pose plays, if it is one.
+pub(in crate::game) fn pose_playing(pose: Option<&Arc<dyn BodyPose>>) -> Option<&Playing> {
+    let any: &dyn std::any::Any = &**pose?;
     any.downcast_ref::<EmotePose>().map(|e| &e.0)
 }
 
-/// Makes `m` play `next`, unless it plays that already (a new one allocates).
-pub(in crate::game) fn set_playing(m: &mut Mob, next: Option<Playing>) {
-    let same = match (playing(m), &next) {
+/// 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(
+    now: Option<&Arc<dyn BodyPose>>,
+    next: Option<Playing>,
+) -> Option<Option<Arc<dyn BodyPose>>> {
+    let same = match (pose_playing(now), &next) {
         (None, None) => true,
         (Some(a), Some(b)) => {
             Arc::ptr_eq(&a.item, &b.item) && a.start == b.start && a.stop == b.stop
         }
         _ => false,
     };
-    if !same {
-        m.emote = next.map(|p| Arc::new(EmotePose(p)) as Arc<dyn BodyPose>);
+    (!same).then(|| next.map(|p| Arc::new(EmotePose(p)) as Arc<dyn BodyPose>))
+}
+
+/// Makes `m` play `next`, unless it plays that already.
+pub(in crate::game) fn set_playing(m: &mut Mob, next: Option<Playing>) {
+    if let Some(pose) = replaced(m.emote.as_ref(), next) {
+        m.emote = pose;
+    }
+}
+
+/// Makes model `id` play `next`, unless it plays that already.
+pub(in crate::game) fn set_model_playing(
+    models: &mut dyn PlayerModels,
+    id: u32,
+    next: Option<Playing>,
+) {
+    if let Some(pose) = replaced(models.body_pose(id), next) {
+        models.set_body_pose(id, pose);
     }
 }
 
@@ -229,7 +260,7 @@ impl Game<'_> {
         }
     }
 
-    /// Once a tick: my emote, then the other players'.
+    /// Once a tick: my emote (the others' are `cosmetics::Seat::tick`'s, a hook's).
     pub(in crate::game) fn tick_emotes(&mut self) {
         if let Some(done) = self
             .cosmetics
@@ -250,20 +281,6 @@ impl Game<'_> {
             }
         }
         self.tick_emote();
-        self.tick_others_emotes();
-    }
-
-    /// 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)
     }
 }
 

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,

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

@@ -0,0 +1,448 @@
+//! 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::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::{
+    Bone, CameraView, Frame, Gear, Kind, Mesh, PartPoses, Pass, PlayerDraw, PlayerModel,
+    PlayerModels, SpriteStore, Sprites,
+};
+use std::sync::Arc;
+
+/// Registers the hooks of the Horizon parts still in this crate (cosmetics: spec #14091 step 5
+/// moves them out). Before the hooks are sealed.
+pub(crate) fn register() {
+    if super::cosmetics::enabled()
+        && let Err(e) = horizon_hooks::register(&super::cosmetics::HOOKS)
+    {
+        log::error!("Cosmetics: their hooks came too late: {e}");
+    }
+}
+
+/// The models of the world a window shows: its own first, then the other players and mannequins.
+struct Models<'a> {
+    own: Option<&'a mut Mob>,
+    mobs: &'a mut JoinList<Mob>,
+    remote: &'a super::remote::Remote,
+}
+
+impl Models<'_> {
+    fn find(&mut self, id: u32) -> Option<&mut Mob> {
+        match self.own.as_deref_mut() {
+            Some(m) if m.id == id => Some(m),
+            _ => self
+                .mobs
+                .iter_mut()
+                .find(|m| m.id == id && kind(m).is_some()),
+        }
+    }
+}
+
+/// What kind of player model `m` is, if it is one (the window's own model aside).
+fn kind(m: &Mob) -> Option<Kind> {
+    match &*m.kind.id {
+        "minecraft:player" => Some(Kind::Player),
+        "minecraft:mannequin" => Some(Kind::Mannequin),
+        _ => None,
+    }
+}
+
+/// 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<'_> {
+    fn connection(&self) -> u64 {
+        self.remote.session.serial()
+    }
+
+    fn for_each(&self, f: &mut dyn FnMut(PlayerModel)) {
+        if let Some(m) = self.own.as_deref() {
+            f(model(m, Kind::Own, Some(self.remote.profile())));
+        }
+        for m in self.mobs.iter() {
+            if let Some(kind) = kind(m) {
+                let uuid = (kind == Kind::Player)
+                    .then(|| self.remote.player_uuid(m.id))
+                    .flatten();
+                f(model(m, kind, uuid));
+            }
+        }
+    }
+
+    fn body_pose(&self, id: u32) -> Option<&Arc<dyn BodyPose>> {
+        match self.own.as_deref() {
+            Some(m) if m.id == id => m.emote.as_ref(),
+            _ => self
+                .mobs
+                .iter()
+                .find(|m| m.id == id && kind(m).is_some())?
+                .emote
+                .as_ref(),
+        }
+    }
+
+    fn set_body_pose(&mut self, id: u32, pose: Option<Arc<dyn BodyPose>>) {
+        if let Some(m) = self.find(id) {
+            m.emote = pose;
+        }
+    }
+}
+
+/// 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()
+    })
+}
+
+/// 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 in the world pass, 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,
+    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)
+    }
+}
+
+impl PlayerDraw for DrawPlayer<'_, '_> {
+    fn pass(&self) -> Pass {
+        self.pass
+    }
+
+    fn ticks(&self) -> f32 {
+        self.m.age as f32 + self.alpha
+    }
+
+    fn bone(&mut self, bone: Bone) -> Option<[[f32; 4]; 4]> {
+        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],
+        uv: [f32; 4],
+        pose: &mut dyn FnMut(&mut dyn PartPoses),
+    ) {
+        let model = part_of(mesh);
+        let matrix = glam::Mat4::from_cols_array_2d(&matrix);
+        self.poses.reset(&model);
+        pose(&mut PosesOf(&mut self.poses));
+        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: self.light,
+                overlay: 0,
+            };
+            if skin.draw(&model, matrix, &self.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,
+        );
+    }
+}
+
+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,
+                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_geometry(m, false, base, Some(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),
+        }
+    }
+
+    /// Once a frame, before drawing.
+    pub(super) fn client_hooks_frame(&mut self) {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        if !engine::any() {
+            return;
+        }
+        self.cosmetics_say();
+        let connection = self.remote.as_ref().map_or(0, |r| r.session.serial());
+        let frame = Frame::new(connection, self.integrated.is_some());
+        engine::frame(&frame, &mut HookStore(self));
+        forget_meshes();
+        self.cosmetics_frame();
+    }
+
+    /// Once a client tick in a world: the player's own emote, then the hooks.
+    pub(super) fn client_hooks_tick(&mut self) {
+        debug_assert!(
+            self.serving.is_none(),
+            "a server thread calls no client hook"
+        );
+        self.tick_emotes();
+        if !engine::any() {
+            return;
+        }
+        self.cosmetics_say();
+        let Some(remote) = self.remote.as_ref() else {
+            return;
+        };
+        engine::tick(&mut Models {
+            own: self.player_model.as_mut(),
+            mobs: &mut self.mobs,
+            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/remote.rs

@@ -6731,7 +6731,7 @@ impl Game<'_> {
         if self.studio_replay.is_none() {
             self.tick_player_model();
         }
-        self.tick_emotes();
+        self.client_hooks_tick();
         if !dead {
             self.remote_tick_using();
         }
@@ -10714,17 +10714,11 @@ impl Game<'_> {
     /// The profile name of another player the server sent, by entity id.
     /// The UUID of another player's entity in the level.
     pub(super) fn remote_player_uuid(&self, id: u32) -> Option<u128> {
-        let r = self.remote.as_ref()?;
-        let uuid = *r.level_players.get(&(id as i32))?;
-        (uuid != r.profile).then_some(uuid)
+        self.remote.as_ref()?.player_uuid(id)
     }
     pub(super) fn remote_player_name(&self, id: u32) -> Option<&str> {
         let r = self.remote.as_ref()?;
-        let uuid = r.level_players.get(&(id as i32))?;
-        if *uuid == r.profile {
-            return None;
-        }
-        r.level_player_name(id as i32, uuid)
+        r.level_player_name(id as i32, &r.player_uuid(id)?)
     }
     /// Status for `horizon-ctl status`.
     /// The other players' entities in the level and their names (their
@@ -11505,6 +11499,11 @@ impl Remote {
     pub(super) fn profile(&self) -> u128 {
         self.profile
     }
+    /// Another player's profile UUID, by their entity id (None for the local player).
+    pub(super) fn player_uuid(&self, id: u32) -> Option<u128> {
+        let uuid = *self.level_players.get(&(id as i32))?;
+        (uuid != self.profile).then_some(uuid)
+    }
     /// The entity id of a player in the level, by profile UUID.
     pub(super) fn player_entity(&self, uuid: u128) -> Option<u32> {
         self.level_players

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

@@ -823,7 +823,7 @@ impl Game<'_> {
         for (location, rgba) in ready {
             self.store_skin(location, rgba);
         }
-        self.cosmetics_frame();
+        self.client_hooks_frame();
     }
     /// `Hud.extractTabList`: the player list while the player-list key is
     /// held. A local world shows it with a joined LAN guest or a `list`
@@ -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-client/src/game/split.rs

@@ -261,6 +261,8 @@ impl<'a> Split<'a> {
                 .get(i.wrapping_sub(1))
                 .map(|g| g.options.clone()),
         );
+        let seat = self.guests.get(i.wrapping_sub(1)).map_or(1, |g| g.seat);
+        horizon_hooks::engine::set_seat(seat - 1);
         self.turn = i;
     }
 

crates/horizon-client/src/game/split/players.rs

@@ -126,6 +126,7 @@ impl Split<'_> {
         // Until it has a profile, a scratch options file: never P1's.
         let options = Self::folder()?.join(".joining/options.txt");
         OPTIONS.set(Some(options.clone()));
+        horizon_hooks::engine::set_seat(seat - 1);
         let mut settings = self.host.settings.clone();
         if pad.is_some() {
             // The Controller setting is P1's own: a player who pressed a pad to join plays
@@ -135,6 +136,7 @@ impl Split<'_> {
         }
         let game = self.start_guest(seat, &options, settings);
         OPTIONS.set(None);
+        horizon_hooks::engine::set_seat(0);
         let mut game = game?;
         if let Some(pad) = pad {
             // The press that joined it doesn't act in its game.
@@ -299,16 +301,31 @@ impl Split<'_> {
         }
         let profile = profiles.join(&name);
         let options = profile.join("options.txt");
-        let mut settings = if options.exists() {
-            horizon_client::settings::Settings::load(&options)
+        let made = if options.exists() {
+            None
         } else {
             std::fs::create_dir_all(&profile)?;
             let mut new = self.host.settings.clone();
             // The Controller setting is P1's, as on the profile page (`join`).
             new.controller.enabled |= self.guests[i].pad.is_some();
+            // On P1's seat, so the crates' settings stores write P1's values too.
+            let turn = horizon_hooks::seat();
+            horizon_hooks::engine::set_seat(0);
             new.save(&options);
-            new
+            horizon_hooks::engine::set_seat(turn);
+            Some(new)
         };
+        // The crates' stores load into the guest's seat, before its turn starts below.
+        let turn = horizon_hooks::seat();
+        horizon_hooks::engine::set_seat(self.guests[i].seat - 1);
+        let mut settings = match made {
+            Some(new) => {
+                horizon_client::settings::Settings::load_stores(&options);
+                new
+            }
+            None => horizon_client::settings::Settings::load(&options),
+        };
+        horizon_hooks::engine::set_seat(turn);
         // A profile an earlier join saved with P1's off, or the player's pad would be dead.
         settings.controller.enabled |= self.guests[i].pad.is_some();
         // P1's own world through memory (`Ok`), else P1's server over the network (`Err`).

crates/horizon-client/src/mobs/anim.rs

@@ -771,26 +771,9 @@ fn swim(p: &mut Poses, pos: f32, h: &Hum) {
         lerp(amount, x, 0.3 * (pos * 0.333_333_34).mcos()),
     );
 }
-/// The player model's parts a [`BodyPose`] poses, in its order.
-pub const BODY_PARTS: [&str; 6] = [
-    "head",
-    "body",
-    "right_arm",
-    "left_arm",
-    "right_leg",
-    "left_leg",
-];
-
-/// A pose a higher layer lays over the player model's body after its vanilla animation (Horizon's
-/// emotes, docs/cosmetics.md), handed to the model through [`Mob::emote`]. The engine names no
-/// type of that layer (docs/layers.md); it downcasts its own back through [`std::any::Any`].
-pub trait BodyPose: std::any::Any + std::fmt::Debug + Send + Sync {
-    /// Poses the [`BODY_PARTS`] at `age` (the mob's ticks): `at_rest` holds each part before the
-    /// animation, `poses` as the animation left it; a part the model lacks holds the identity in
-    /// both and is not written back. False when it poses nothing at `age` (`poses` is then
-    /// ignored).
-    fn pose(&self, age: f32, at_rest: &[[f32; 9]; 6], poses: &mut [[f32; 9]; 6]) -> bool;
-}
+/// A pose laid over the player model's body after its vanilla animation, and the parts it poses:
+/// the hook's own types (`horizon_hooks::players`), kept here under their old path.
+pub use horizon_hooks::players::{BODY_PARTS, BodyPose};
 
 /// Apply the mob's model animation to `p` (at rest), then the pose laid over it, if any.
 pub fn setup(

crates/horizon-client/src/net.rs

@@ -149,8 +149,20 @@ pub struct Session {
     far: Arc<crate::lod_net::Inbox>,
     /// The recording running, if any.
     recorder: RecorderSlot,
+    /// This connection's number, new for each one ([`Session::serial`]).
+    serial: u64,
+}
+/// The next [`Session::serial`].
+static NEXT_SERIAL: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
+fn next_serial() -> u64 {
+    NEXT_SERIAL.fetch_add(1, Ordering::Relaxed)
 }
 impl Session {
+    /// A number of its own for each connection, never 0: entity ids are per connection, so what
+    /// is kept by id goes when it changes (`horizon_hooks::players::PlayerModels::connection`).
+    pub fn serial(&self) -> u64 {
+        self.serial
+    }
     /// The negotiated wire release, once the connection has been established.
     pub fn server_version(&self) -> horizon_protocol::adapter::ServerVersion {
         self.writer.lock().unwrap().as_ref().map_or(
@@ -256,6 +268,7 @@ impl Session {
             debug: false,
             far: Arc::new(crate::lod_net::Inbox::default()),
             recorder: Arc::new(Mutex::new(None)),
+            serial: next_serial(),
         }
     }
     fn start(
@@ -333,6 +346,7 @@ impl Session {
             debug,
             far,
             recorder,
+            serial: next_serial(),
         }
     }
     /// Everything received since the last poll.
@@ -1829,6 +1843,7 @@ mod tests {
                 debug: false,
                 far: Arc::default(),
                 recorder: Arc::new(Mutex::new(None)),
+                serial: next_serial(),
             };
             let started = std::time::Instant::now();
             if explicit_disconnect {
@@ -1932,6 +1947,7 @@ mod tests {
             debug: false,
             far: Arc::default(),
             recorder: Arc::new(Mutex::new(None)),
+            serial: next_serial(),
         };
         let (thread_writer, thread_configuring, thread_recorder) = (
             session.writer.clone(),
@@ -2215,6 +2231,7 @@ mod tests {
             debug: false,
             far: Arc::default(),
             recorder: Arc::new(Mutex::new(None)),
+            serial: next_serial(),
         };
         let recorder = TestRecorder::default();
         session.start_recording(recorder.clone(), |_| {});

crates/horizon-cosmetics/src/fetch.rs

@@ -70,7 +70,8 @@ struct Shared {
 /// The game's handle. Dropping it stops the thread.
 pub struct Cosmetics {
     shared: Arc<Shared>,
-    worker: Option<Box<dyn FnMut() + Send>>,
+    /// Behind a lock so one client can be shared (`Arc<Cosmetics>` is `Send + Sync`).
+    worker: Mutex<Option<Box<dyn FnMut() + Send>>>,
 }
 
 impl Cosmetics {
@@ -78,7 +79,12 @@ impl Cosmetics {
     /// `cache` when given.
     pub fn new(transport: impl Transport, cache: Option<PathBuf>) -> Self {
         let mut c = Self::manual(transport, cache, Arc::new(Instant::now));
-        let mut work = c.worker.take().expect("worker");
+        let mut work = c
+            .worker
+            .get_mut()
+            .unwrap_or_else(PoisonError::into_inner)
+            .take()
+            .expect("worker");
         let shared = c.shared.clone();
         let _ = std::thread::Builder::new()
             .name("Cosmetics".into())
@@ -125,7 +131,7 @@ impl Cosmetics {
         });
         Self {
             shared,
-            worker: Some(worker),
+            worker: Mutex::new(Some(worker)),
         }
     }
 

crates/horizon-cosmetics/src/fetch_tests.rs

@@ -87,7 +87,7 @@ fn clock() -> (Clock, Arc<AtomicU64>) {
 }
 
 fn run(c: &mut Cosmetics) {
-    (c.worker.as_mut().unwrap())();
+    (c.worker.get_mut().unwrap().as_mut().unwrap())();
 }
 
 fn ids(worn: Option<Worn>) -> Vec<String> {

crates/horizon-hooks/src/lib.rs

@@ -19,11 +19,13 @@
 
 pub mod hud;
 pub mod pages;
+pub mod players;
 mod registry;
 pub mod settings;
 pub mod tunnel;
 
 use registry::Registry;
+use std::cell::Cell;
 use std::sync::atomic::{AtomicBool, Ordering};
 
 /// What a crate above the engine hears from the game. Every method has an empty default:
@@ -42,6 +44,39 @@ 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: `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.
+    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) {}
+
     /// 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.
@@ -89,10 +124,27 @@ fn all() -> &'static [&'static dyn Hooks] {
     HOOKS.all()
 }
 
+thread_local! {
+    static SEAT: Cell<usize> = const { Cell::new(0) };
+}
+
+/// The splitscreen player whose turn it is: 0 for P1 (and without splitscreen), 1 for P2...
+/// Splitscreen players are one process, each `Game` in turn on the game's thread, so a crate's
+/// statics are shared by them: a crate that keeps per-player state (settings, pages, HUD) indexes
+/// it by this. A player keeps its seat while it plays. Other threads always see 0.
+pub fn seat() -> usize {
+    SEAT.get()
+}
+
 /// The engine's side: where it calls the hooks. Only the engine calls these.
 pub mod engine {
     use super::*;
 
+    /// The player whose turn starts on this thread ([`seat`]).
+    pub fn set_seat(seat: usize) {
+        SEAT.set(seat);
+    }
+
     /// Seals every list (hooks and the registries); their first use does it anyway. Call where
     /// registration ends.
     pub fn seal() {
@@ -130,6 +182,50 @@ pub mod engine {
         }
     }
 
+    /// Whether any hook is registered: without one the engine builds no view to hand them.
+    pub fn any() -> bool {
+        !all().is_empty()
+    }
+
+    /// [`Hooks::frame`].
+    pub fn frame(frame: &players::Frame, sprites: &mut dyn players::SpriteStore) {
+        for hooks in all() {
+            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::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() {
+            hooks.tick(models);
+        }
+    }
+
     /// [`Hooks::tunnel`]: the first registered hook's resolver.
     pub fn tunnel() -> Option<&'static dyn tunnel::Resolver> {
         all().iter().find_map(|hooks| hooks.tunnel())
@@ -139,6 +235,7 @@ pub mod engine {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use players::PlayerModels as _;
     use std::sync::Mutex as StdMutex;
 
     /// Records what it heard. One process-wide list, as the game has: this test is the only
@@ -155,6 +252,149 @@ mod tests {
         fn published(&self, open: bool) {
             self.0.lock().unwrap().push(format!("published {open}"));
         }
+        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;
+            draw.draw(&HAT, head, uv, &mut |p| p.pose("brim")[4] = turn);
+        }
+        fn tick(&self, models: &mut dyn players::PlayerModels) {
+            let mut ids = Vec::new();
+            models.for_each(&mut |m| ids.push(m.id));
+            for id in ids {
+                models.set_body_pose(id, Some(std::sync::Arc::new(Still)));
+            }
+        }
+    }
+
+    #[derive(Debug)]
+    struct Still;
+    impl players::BodyPose for Still {
+        fn pose(&self, _: f32, _: &[[f32; 9]; 6], _: &mut [[f32; 9]; 6]) -> bool {
+            false
+        }
+    }
+
+    /// Two models, poses by id.
+    struct Two(std::collections::BTreeMap<u32, std::sync::Arc<dyn players::BodyPose>>);
+    impl players::PlayerModels for Two {
+        fn connection(&self) -> u64 {
+            1
+        }
+        fn for_each(&self, f: &mut dyn FnMut(players::PlayerModel)) {
+            for id in [3, 7] {
+                f(players::PlayerModel::new(
+                    id,
+                    players::Kind::Player,
+                    None,
+                    0,
+                    false,
+                ));
+            }
+        }
+        fn body_pose(&self, id: u32) -> Option<&std::sync::Arc<dyn players::BodyPose>> {
+            self.0.get(&id)
+        }
+        fn set_body_pose(&mut self, id: u32, pose: Option<std::sync::Arc<dyn players::BodyPose>>) {
+            match pose {
+                Some(p) => self.0.insert(id, p),
+                None => self.0.remove(&id),
+            };
+        }
+    }
+
+    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; logs each draw.
+    #[derive(Default)]
+    struct Canvas(Vec<(String, [[f32; 4]; 4], [f32; 4], f32)>);
+    impl players::PlayerDraw for Canvas {
+        fn pass(&self) -> players::Pass {
+            players::Pass::World
+        }
+        fn ticks(&self) -> f32 {
+            50.0
+        }
+        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],
+            uv: [f32; 4],
+            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, uv, brim.0[4]));
+        }
     }
 
     /// Implements nothing: the defaults do nothing.
@@ -173,9 +413,46 @@ mod tests {
             engine::published(open);
         }
         engine::shutdown();
+        assert!(engine::any());
+        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
+            )]
+        );
+        let mut models = Two(Default::default());
+        engine::tick(&mut models);
+        assert!(models.body_pose(3).is_some() && models.body_pose(7).is_some());
         assert_eq!(
             *RECORDER.0.lock().unwrap(),
-            ["started 0.2.31", "published true", "published false"]
+            [
+                "started 0.2.31",
+                "published true",
+                "published false",
+                "frame 4"
+            ]
         );
         assert_eq!(register(&Silent), Err(TooLate));
     }

crates/horizon-hooks/src/players.rs

@@ -0,0 +1,309 @@
+//! 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`],
+//! [`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.
+pub const BODY_PARTS: [&str; 6] = [
+    "head",
+    "body",
+    "right_arm",
+    "left_arm",
+    "right_leg",
+    "left_leg",
+];
+
+/// A pose a crate lays over a player model's body after its vanilla animation (Horizon's emotes,
+/// docs/cosmetics.md), handed to the model with [`PlayerModels::set_body_pose`]. The crate
+/// downcasts its own back through [`std::any::Any`].
+pub trait BodyPose: std::any::Any + std::fmt::Debug + Send + Sync {
+    /// Poses the [`BODY_PARTS`] at `age` (the model's ticks): `at_rest` holds each part before the
+    /// animation, `poses` as the animation left it (x, y, z, x/y/z rotation, x/y/z scale); a part
+    /// the model lacks holds the identity in both and is not written back. False when it poses
+    /// nothing at `age` (`poses` is then ignored).
+    fn pose(&self, age: f32, at_rest: &[[f32; 9]; 6], poses: &mut [[f32; 9]; 6]) -> bool;
+}
+
+/// What a player model is.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Kind {
+    /// The player of this window, seen from outside (third person, the inventory picture).
+    Own,
+    /// Another player.
+    Player,
+    /// A mannequin: a player model with no player.
+    Mannequin,
+}
+
+/// One player model, as [`PlayerModels::for_each`] shows it.
+#[derive(Clone, Copy, Debug)]
+#[non_exhaustive]
+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 (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 {
+    pub fn new(id: u32, kind: Kind, uuid: Option<u128>, age: u32, moved: bool) -> Self {
+        Self {
+            id,
+            kind,
+            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`]).
+pub trait PlayerModels {
+    /// Changes on every join: entity ids are per connection, so what a crate keeps by id goes
+    /// when this changes.
+    fn connection(&self) -> u64;
+    /// Each player model in view (other players and mannequins; the window's own model first).
+    fn for_each(&self, f: &mut dyn FnMut(PlayerModel));
+    /// The pose laid over model `id`, if any.
+    fn body_pose(&self, id: u32) -> Option<&Arc<dyn BodyPose>>;
+    /// Lays `pose` over model `id` (None: its vanilla animation alone). Unknown ids are ignored.
+    fn set_body_pose(&mut self, id: u32, pose: Option<Arc<dyn BodyPose>>);
+}
+
+/// What [`crate::Hooks::frame`] gets, once a frame before drawing.
+#[derive(Clone, Copy, Debug)]
+#[non_exhaustive]
+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, 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.
+    World,
+}
+
+/// 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;
+    /// Where `bone` is as the body is drawn this frame; None if the model has no such part.
+    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.
+    fn draw(
+        &mut self,
+        mesh: &Arc<Mesh>,
+        matrix: [[f32; 4]; 4],
+        uv: [f32; 4],
+        pose: &mut dyn FnMut(&mut dyn PartPoses),
+    );
+}

crates/horizon-platform/src/lib.rs

@@ -46,7 +46,15 @@ pub use horizon_server_files as server_files;
 /// [`hooks::register`] it before the game starts (docs/layers.md, "How a Horizon crate plugs
 /// in"). The engine's dispatch side is not part of the API.
 pub mod hooks {
-    pub use horizon_hooks::{Hooks, Started, TooLate, register, tunnel};
+    /// The players the game shows (`horizon_hooks::players`): the views [`Hooks::frame`] and
+    /// [`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,
+    };
+    pub use horizon_hooks::{Hooks, Started, TooLate, register, seat, tunnel};
 }
 
 /// The settings store (`horizon_hooks::settings`): a crate's own `key:value` lines in the game