From 1dffadeea30a4d60e035bac16d0fd510c59f70f2 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 24 Oct 2026 19:19:34 +0200 Subject: [PATCH] Pack screen: draw each pack's own pack.png instead of unknown_pack PackSelectionScreen.loadPackIcon registers every pack's pack.png as a texture; Horizon never loaded them, so every pack (Default, Programmer Art, High Contrast and the player's own) fell back to unknown_pack, the cobblestone. The icons now load from each pack when the screen opens and are written into 64 new 128x128 HUD atlas slots, one per icon on screen. The vanilla pack's icon is the client JAR's pack.png, which horizon-prepare now copies into the prepared resources. Co-Authored-By: Claude Opus 5.5 --- .../examples/probe/pack_screen_fixture.rs | 8 +- crates/horizon-client/src/game/packs.rs | 16 +- crates/horizon-client/src/hud.rs | 17 +- crates/horizon-client/src/options_ui.rs | 4 +- crates/horizon-client/src/pack_screen.rs | 166 +++++++++++++++++- crates/horizon-client/src/packs.rs | 55 +++++- crates/horizon-prepare/src/lib.rs | 6 +- 7 files changed, 249 insertions(+), 23 deletions(-) diff --git a/crates/horizon-client/examples/probe/pack_screen_fixture.rs b/crates/horizon-client/examples/probe/pack_screen_fixture.rs index 881570990..5d84ce0a6 100644 --- a/crates/horizon-client/examples/probe/pack_screen_fixture.rs +++ b/crates/horizon-client/examples/probe/pack_screen_fixture.rs @@ -5,7 +5,7 @@ //! //! usage: pack_screen_fixture RESOURCES CASES OUTPUT use horizon_client::{ - hud::HudAtlas, + hud::{HudAtlas, PACK_ICON_SIZE}, lang, pack_screen::{Compat, PackInfo, PackScreen, Source}, packs::{self, Position}, @@ -13,7 +13,7 @@ use horizon_client::{ text::Text, }; use serde_json::{Value, json}; -use std::{fmt::Write as _, fs, path::PathBuf}; +use std::{fmt::Write as _, fs, path::PathBuf, sync::Arc}; /// Styled runs: [text, rgb or null, bold, italic, underlined, strikethrough, obfuscated]. pub fn runs(t: &Text) -> Value { @@ -105,7 +105,9 @@ pub fn main() -> horizon_client::Result<()> { Some("unknown") => Compat::Unknown, _ => Compat::Compatible, }, - icon: p["icon"].as_bool().unwrap_or(false), + icon: p["icon"].as_bool().unwrap_or(false).then(|| { + Arc::from(vec![0; (PACK_ICON_SIZE * PACK_ICON_SIZE * 4) as usize]) + }), required: p["required"].as_bool().unwrap_or(false), position: if p["position"] == "top" { Position::Top diff --git a/crates/horizon-client/src/game/packs.rs b/crates/horizon-client/src/game/packs.rs index ae2de00e6..82ba69e9d 100644 --- a/crates/horizon-client/src/game/packs.rs +++ b/crates/horizon-client/src/game/packs.rs @@ -4,7 +4,7 @@ use super::Game; use horizon_client::{ hud::HudAtlas, lang, - pack_screen::{Compat, PackInfo, Source as PackSource}, + pack_screen::{self, Compat, PackInfo, Source as PackSource}, packs::{self, Pack, Position}, text::{Style, Text}, }; @@ -53,14 +53,15 @@ fn info(p: &Pack) -> PackInfo { PackSource::Default }, compat: p.compatibility, - icon: p.icon, + icon: p.icon_png().as_deref().and_then(pack_screen::load_icon), required: false, position: Position::Top, fixed: false, } } -/// The vanilla pack: required, at the bottom (`BuiltInPackSource`). -fn vanilla_info() -> PackInfo { +/// The vanilla pack: required, at the bottom (`BuiltInPackSource`), with the +/// client JAR's `pack.png` that the prepared resources hold. +fn vanilla_info(vanilla: &Path) -> PackInfo { PackInfo { id: "vanilla".into(), title: Text::translate("resourcePack.vanilla.name", &[]), @@ -68,7 +69,10 @@ fn vanilla_info() -> PackInfo { description_style: Style::default(), source: PackSource::BuiltIn, compat: Compat::Compatible, - icon: true, + icon: std::fs::read(vanilla.join("pack.png")) + .ok() + .as_deref() + .and_then(pack_screen::load_icon), required: true, position: Position::Bottom, fixed: false, @@ -80,7 +84,7 @@ pub(super) fn pack_infos(vanilla: &Path) -> Vec { .iter() .map(info) .collect(); - infos.push(vanilla_info()); + infos.push(vanilla_info(vanilla)); infos } impl Game<'_> { diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index cc922752e..89d1b1c3c 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -81,6 +81,12 @@ pub const MINIMAP_SPRITE: &str = "horizon/minimap"; pub const SKIN_SLOTS: usize = 32; /// Reused by the visible rows of the classic world selector. pub const WORLD_ICON_SLOTS: usize = 32; +/// Atlas slots for the pack icons on the pack screen, one per icon drawn +/// (`PackSelectionScreen.loadPackIcon` registers a texture per pack): two lists +/// of 36-pixel rows at GUI scale 2 on a 4K screen still fit. +pub const PACK_ICON_SLOTS: usize = 64; +/// A pack icon slot's side: vanilla's own icons are 128x128. +pub const PACK_ICON_SIZE: u32 = 128; /// Atlas slots for armour trim textures made at run time (`trims`), each the /// size of the largest trim texture. pub const TRIM_SLOTS: usize = 32; @@ -252,7 +258,7 @@ impl HudAtlas { ) } /// Empty slots written at run time: map textures (game/maps.rs), the - /// minimap, downloaded skins, world icons and the on-screen keyboard's text. + /// minimap, downloaded skins, world and pack icons and the on-screen keyboard's text. fn slots(images: &mut Vec, trim: (u32, u32)) { for i in 0..MAP_SLOTS { images.push((format!("horizon/map{i}"), 128, 128, vec![0; 128 * 128 * 4])); @@ -284,6 +290,15 @@ impl HudAtlas { vec![0; 64 * 64 * 4], )); } + let side = PACK_ICON_SIZE as usize; + for i in 0..PACK_ICON_SLOTS { + images.push(( + format!("horizon/pack-icon{i}"), + PACK_ICON_SIZE, + PACK_ICON_SIZE, + vec![0; side * side * 4], + )); + } // The on-screen keyboard's text and corner masks (ui_theme), rasterized at run time. images.push(( "horizon/ui-text".into(), diff --git a/crates/horizon-client/src/options_ui.rs b/crates/horizon-client/src/options_ui.rs index 352ebf26e..99a83072f 100644 --- a/crates/horizon-client/src/options_ui.rs +++ b/crates/horizon-client/src/options_ui.rs @@ -2079,7 +2079,9 @@ impl OptionsUi { let blink = self.pack_focus.elapsed().as_millis() as u64; let m = crate::screen_draw::Measure(&atlas.font); let mouse = (cursor.0.floor() as i32, cursor.1.floor() as i32); - let draws = self.packs(atlas, (w, h)).draw(&m, mouse, blink); + let packs = self.packs(atlas, (w, h)); + let mut draws = packs.draw(&m, mouse, blink); + packs.bind_icons(&mut draws, atlas, &mut batch.patches); crate::screen_draw::paint(batch, atlas, &draws); return; } diff --git a/crates/horizon-client/src/pack_screen.rs b/crates/horizon-client/src/pack_screen.rs index 934ecaf95..2929fd663 100644 --- a/crates/horizon-client/src/pack_screen.rs +++ b/crates/horizon-client/src/pack_screen.rs @@ -6,10 +6,13 @@ //! [`PackScreen::draw`] gives the screen's GUI calls. The game shows it; //! tools/test_pack_screen_parity.py compares it with vanilla. use crate::{ + font::Patch, + hud::{HudAtlas, PACK_ICON_SIZE, PACK_ICON_SLOTS}, packs::{Position, Selectable, SelectionModel}, screen_draw::{self as d, Draw, Measure, TextField}, text::{Style, Text}, }; +use std::{collections::HashMap, sync::Arc}; /// `PackCompatibility`. #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -50,8 +53,8 @@ pub struct PackInfo { pub description_style: Style, pub source: Source, pub compat: Compat, - /// Whether the pack has a `pack.png`. - pub icon: bool, + /// The pack's `pack.png` ([`load_icon`]); none draws `unknown_pack`. + pub icon: Option>, pub required: bool, pub position: Position, pub fixed: bool, @@ -90,6 +93,27 @@ impl PackInfo { (t, Style::color(d::GRAY)) } } +/// A `pack.png` as the pack screen draws it: RGBA, stretched to a +/// `PACK_ICON_SIZE` square by nearest texels, as vanilla's icon texture is +/// sampled into its 32x32 square. None when it does not decode, where +/// `loadPackIcon` falls back to `unknown_pack`. +pub fn load_icon(png: &[u8]) -> Option> { + let (w, h, rgba) = crate::hud::decode_bytes(png).ok()?; + if w == 0 || h == 0 { + return None; + } + let size = u64::from(PACK_ICON_SIZE); + let mut out = Vec::with_capacity((size * size * 4) as usize); + for y in 0..size { + let sy = ((2 * y + 1) * u64::from(h) / (2 * size)) as usize; + for x in 0..size { + let sx = ((2 * x + 1) * u64::from(w) / (2 * size)) as usize; + let at = (sy * w as usize + sx) * 4; + out.extend_from_slice(&rgba[at..at + 4]); + } + } + Some(out.into()) +} /// `PackSelectionScreen.loadPackIcon`'s texture for a pack with an icon. pub fn icon_texture(id: &str) -> String { let sanitized: String = id @@ -306,6 +330,8 @@ pub struct PackScreen { confirm: Option, /// The selection changed since the screen opened. pub changed: bool, + /// The packs' icons by their [`icon_texture`]. + icons: HashMap>, } fn tr(key: &str) -> Text { @@ -329,11 +355,16 @@ impl PackScreen { italic: Some(true), ..Style::default() })); + let icons = packs + .iter() + .filter_map(|p| Some((icon_texture(&p.id), p.icon.clone()?))) + .collect(); let mut s = Self { width, height, in_world, packs, + icons, model, search, focus: Focus::None, @@ -760,6 +791,35 @@ impl PackScreen { pub fn commit(&self) -> Vec { self.model.commit() } + /// Points the icon blits of `draws` at the atlas's pack icon slots and + /// writes the icons into them, one slot per icon drawn (vanilla registers a + /// texture per pack). Icons past the last slot keep `unknown_pack`. + pub fn bind_icons(&self, draws: &mut [Draw], atlas: &HudAtlas, patches: &mut Vec) { + let mut slots = 0..PACK_ICON_SLOTS; + for draw in draws { + let Draw::Blit { texture, .. } = draw else { + continue; + }; + let Some(icon) = self.icons.get(texture.as_str()) else { + continue; + }; + let Some(slot) = slots.next() else { + return; + }; + let sprite = format!("horizon/pack-icon{slot}"); + let Some(rect) = atlas.sprites.get(&sprite) else { + return; + }; + patches.push(Patch { + x: (rect.u0 * atlas.width as f32).round() as u32, + y: (rect.v0 * atlas.height as f32).round() as u32, + width: PACK_ICON_SIZE, + height: PACK_ICON_SIZE, + rgba: icon.to_vec(), + }); + *texture = sprite; + } + } /// The shown screen's calls (`Screen.extractRenderState`); `blink_ms` /// is the time since the search box took the focus. @@ -891,7 +951,7 @@ impl PackScreen { -8978432, ); } - let icon = if p.icon { + let icon = if p.icon.is_some() { icon_texture(id) } else { "textures/misc/unknown_pack.png".into() @@ -979,6 +1039,106 @@ impl PackScreen { } } +#[cfg(test)] +mod icon_tests { + use super::*; + + fn png(w: u32, h: u32, rgba: &[u8]) -> Vec { + let mut out = Vec::new(); + let mut encoder = png::Encoder::new(&mut out, w, h); + encoder.set_color(png::ColorType::Rgba); + encoder.set_depth(png::BitDepth::Eight); + encoder + .write_header() + .unwrap() + .write_image_data(rgba) + .unwrap(); + out + } + fn pack(id: &str, icon: Option>) -> PackInfo { + PackInfo { + id: id.into(), + title: Text::literal(id), + description: Text::literal(""), + description_style: Style::default(), + source: Source::BuiltIn, + compat: Compat::Compatible, + icon, + required: false, + position: Position::Top, + fixed: false, + } + } + + /// Any size stretches over the whole square, nearest texels, as the + /// icon texture is sampled into its 32x32 blit. + #[test] + fn icons_stretch_to_the_slot_by_nearest_texels() { + let (red, blue) = ([255, 0, 0, 255], [0, 0, 255, 128]); + let icon = load_icon(&png(2, 1, &[red, blue].concat())).unwrap(); + let side = PACK_ICON_SIZE as usize; + assert_eq!(icon.len(), side * side * 4); + let at = |x: usize, y: usize| &icon[(y * side + x) * 4..][..4]; + assert_eq!((at(0, 0), at(side / 2 - 1, side - 1)), (&red[..], &red[..])); + assert_eq!( + (at(side / 2, 0), at(side - 1, side - 1)), + (&blue[..], &blue[..]) + ); + assert!(load_icon(b"not a png").is_none()); + } + + /// Programmer Art and High Contrast draw their own `pack.png`; a pack + /// without one keeps `unknown_pack`. + #[test] + fn drawn_icons_take_atlas_slots() { + let atlas = + crate::hud::HudAtlas::build(std::path::Path::new("/nonexistent/horizon-test-assets")) + .unwrap(); + let m = Measure(&atlas.font); + let dirt = load_icon(&png(1, 1, &[134, 96, 67, 255])).unwrap(); + let contrast = load_icon(&png(1, 1, &[0, 0, 0, 255])).unwrap(); + let packs = vec![ + pack("programmer_art", Some(dirt.clone())), + pack("high_contrast", Some(contrast.clone())), + pack("file/Iconless", None), + ]; + let screen = PackScreen::new(&m, 480, 320, false, packs, &[]); + let mut draws = screen.draw(&m, (0, 0), 0); + let mut patches = Vec::new(); + screen.bind_icons(&mut draws, &atlas, &mut patches); + let icons: Vec<&str> = draws + .iter() + .filter_map(|d| match d { + Draw::Blit { texture, .. } if texture.contains("pack") => Some(texture.as_str()), + _ => None, + }) + .collect(); + // The list shows them sorted by id. + assert_eq!( + icons, + [ + "textures/misc/unknown_pack.png", + "horizon/pack-icon0", + "horizon/pack-icon1" + ] + ); + assert_eq!(patches.len(), 2); + for (i, (patch, icon)) in patches.iter().zip([&contrast, &dirt]).enumerate() { + let rect = atlas.sprites[&format!("horizon/pack-icon{i}")]; + assert_eq!( + (patch.x, patch.y, patch.width, patch.height), + ( + (rect.u0 * atlas.width as f32).round() as u32, + (rect.v0 * atlas.height as f32).round() as u32, + PACK_ICON_SIZE, + PACK_ICON_SIZE + ) + ); + assert_eq!(&patch.rgba[..], &icon[..]); + } + } +} + #[cfg(test)] mod click_sound_tests { use super::*; diff --git a/crates/horizon-client/src/packs.rs b/crates/horizon-client/src/packs.rs index 5daaaacad..0ba1dc1f5 100644 --- a/crates/horizon-client/src/packs.rs +++ b/crates/horizon-client/src/packs.rs @@ -34,8 +34,6 @@ pub struct Pack { pub description_style: Style, pub compatible: bool, pub compatibility: crate::pack_screen::Compat, - /// The pack has a `pack.png`. - pub icon: bool, /// Overlay directories active for this game version, in `pack.mcmeta` order. pub overlays: Vec, /// `filter.block` entries (namespace and path patterns) hiding resources @@ -260,6 +258,15 @@ fn filter_of(meta: &serde_json::Value) -> Vec { }) .collect() } +impl Pack { + /// The pack's `pack.png` (`PackResources.getRootResource`), for its icon. + pub fn icon_png(&self) -> Option> { + match &self.source { + Source::Dir(d) => fs::read(d.join("pack.png")).ok(), + Source::Zip(z) => Zip::open(z).ok()?.read("pack.png").ok(), + } + } +} fn read_meta(source: &Source) -> Option { let bytes = match source { Source::Dir(d) => fs::read(d.join("pack.mcmeta")).ok()?, @@ -270,10 +277,6 @@ fn read_meta(source: &Source) -> Option { fn pack(id: String, title: Text, source: Source) -> Option { let meta = read_meta(&source)?; let (raw_description, description_style) = component_root(&meta["pack"]["description"]); - let icon = match &source { - Source::Dir(d) => d.join("pack.png").is_file(), - Source::Zip(z) => Zip::open(z).is_ok_and(|z| z.read("pack.png").is_ok()), - }; Some(Pack { id, title, @@ -282,7 +285,6 @@ fn pack(id: String, title: Text, source: Source) -> Option { description_style, compatible: compatible(&meta), compatibility: compatibility(&meta), - icon, overlays: overlays_of(&meta), filter: filter_of(&meta), source, @@ -983,6 +985,45 @@ mod tests { let _ = fs::remove_dir_all(base); } #[test] + fn built_in_and_folder_packs_give_their_pack_png() { + use std::io::Write as _; + let base = std::env::temp_dir().join(format!("horizon-pack-icons-{}", std::process::id())); + let _ = fs::remove_dir_all(&base); + let meta = br#"{"pack":{"description":"d","pack_format":97}}"#; + let built_in = base.join("vanilla/assets/minecraft/resourcepacks"); + fs::create_dir_all(&built_in).unwrap(); + let mut zip = + zip::ZipWriter::new(fs::File::create(built_in.join("programmer_art.zip")).unwrap()); + for (name, data) in [("pack.mcmeta", &meta[..]), ("pack.png", b"dirt")] { + zip.start_file(name, zip::write::SimpleFileOptions::default()) + .unwrap(); + zip.write_all(data).unwrap(); + } + zip.finish().unwrap(); + for (name, icon) in [("Iconless", None), ("Mine", Some(&b"mine"[..]))] { + let dir = base.join("packs").join(name); + fs::create_dir_all(&dir).unwrap(); + fs::write(dir.join("pack.mcmeta"), meta).unwrap(); + if let Some(icon) = icon { + fs::write(dir.join("pack.png"), icon).unwrap(); + } + } + let packs = discover(&base.join("vanilla"), &base.join("packs")); + let icons: Vec<_> = packs + .iter() + .map(|p| (p.id.as_str(), p.icon_png())) + .collect(); + assert_eq!( + icons, + [ + ("programmer_art", Some(b"dirt".to_vec())), + ("file/Iconless", None), + ("file/Mine", Some(b"mine".to_vec())), + ] + ); + let _ = fs::remove_dir_all(base); + } + #[test] fn overlays_and_filters() { let v = |s: &str| serde_json::from_str::(s).unwrap(); let meta = v(r#"{"overlays":{"entries":[ diff --git a/crates/horizon-prepare/src/lib.rs b/crates/horizon-prepare/src/lib.rs index 24f163a9b..30b2f1cff 100644 --- a/crates/horizon-prepare/src/lib.rs +++ b/crates/horizon-prepare/src/lib.rs @@ -676,13 +676,15 @@ fn steps( } // The playable client needs every client asset (textures, models, fonts, GUI) - // and every data-pack resource (worldgen, recipes, loot tables, tags). + // and every data-pack resource (worldgen, recipes, loot tables, tags), and + // the vanilla pack's icon (`pack.png`) for the pack screen. (run.log)("Copying the client's assets and data"); let mut count = 0usize; let mut client = open_zip(&run.client)?; let version = pyjson::loads(&zip_text(&mut client, "version.json")?)?; for name in zip_names(&client) { - if !(name.starts_with("assets/") || name.starts_with("data/")) || name.ends_with('/') { + let wanted = name.starts_with("assets/") || name.starts_with("data/") || name == "pack.png"; + if !wanted || name.ends_with('/') { continue; } let relative = member_path(&name, "Invalid resource path")?;