Merge pull request #1579 from ludovic111/fix/builtin-pack-icons
This commit is contained in:
@@ -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
|
||||
|
||||
@@ -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<PackInfo> {
|
||||
.iter()
|
||||
.map(info)
|
||||
.collect();
|
||||
infos.push(vanilla_info());
|
||||
infos.push(vanilla_info(vanilla));
|
||||
infos
|
||||
}
|
||||
impl Game<'_> {
|
||||
|
||||
@@ -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<PackedImage>, 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(),
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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<Arc<[u8]>>,
|
||||
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<Arc<[u8]>> {
|
||||
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<Confirm>,
|
||||
/// The selection changed since the screen opened.
|
||||
pub changed: bool,
|
||||
/// The packs' icons by their [`icon_texture`].
|
||||
icons: HashMap<String, Arc<[u8]>>,
|
||||
}
|
||||
|
||||
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<String> {
|
||||
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<Patch>) {
|
||||
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<u8> {
|
||||
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<Arc<[u8]>>) -> 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::*;
|
||||
|
||||
@@ -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<String>,
|
||||
/// `filter.block` entries (namespace and path patterns) hiding resources
|
||||
@@ -260,6 +258,15 @@ fn filter_of(meta: &serde_json::Value) -> Vec<Filter> {
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
impl Pack {
|
||||
/// The pack's `pack.png` (`PackResources.getRootResource`), for its icon.
|
||||
pub fn icon_png(&self) -> Option<Vec<u8>> {
|
||||
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<serde_json::Value> {
|
||||
let bytes = match source {
|
||||
Source::Dir(d) => fs::read(d.join("pack.mcmeta")).ok()?,
|
||||
@@ -270,10 +277,6 @@ fn read_meta(source: &Source) -> Option<serde_json::Value> {
|
||||
fn pack(id: String, title: Text, source: Source) -> Option<Pack> {
|
||||
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<Pack> {
|
||||
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::<serde_json::Value>(s).unwrap();
|
||||
let meta = v(r#"{"overlays":{"entries":[
|
||||
|
||||
@@ -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")?;
|
||||
|
||||
Reference in New Issue
Block a user