Merge pull request #1194 from ludovic111/feat/armour-trims-worn

🤖 Agent: merged after verify passed and the wave-3 integration on the desktop by integ-w3: main + 17 PRs, fmt, clippy 0, 1929 workspace tests, parity --changed (only known flakes failed, and those passed on rerun), lan_e2e in both modes, and the perf numbers back to back against main posted on each PR.
This commit is contained in:
Ludovic Marie
2026-10-23 05:19:59 +02:00
committed by GitHub
7 changed files with 553 additions and 10 deletions
+4
View File
@@ -1397,6 +1397,8 @@ struct Game<'a> {
/// (least recently shown first).
skin_downloads: RefCell<horizon_client::skins::Downloader>,
skin_slots: Vec<(String, usize)>,
/// Atlas trim slots in use: (sprite name, slot), least recently drawn first.
trim_slots: Vec<(String, usize)>,
cart_models: minecarts::CartModels,
/// The boat the player rides.
riding: Option<u32>,
@@ -6476,6 +6478,7 @@ impl Game<'_> {
mut out: Vec<Vertex>,
) -> Vec<Vertex> {
self.prepare_entity_culling(camera);
self.prepare_trims();
let fire_yaw = if self.camera_type == perspective::CameraType::ThirdPersonFront {
self.yaw + 180.0
} else {
@@ -11648,6 +11651,7 @@ impl<'a> Game<'a> {
.join("assets/skins"),
)),
skin_slots: Vec::new(),
trim_slots: Vec::new(),
cart_models: prepared.cart_models,
riding: None,
ender_items: vec![None; 27],
+175 -6
View File
@@ -8,12 +8,13 @@ use horizon_client::{
items::ItemStack,
mesher::Vertex,
mobs::{Mob, Part, anim::Poses},
trims::{TrimOverride, TrimRegistry, TrimTexture},
};
use horizon_core::{
geometry::{Aabb, Vec3},
random::RandomSource,
};
use std::{collections::HashMap, sync::Arc};
use std::{collections::HashMap, path::PathBuf, sync::Arc};
/// Armor stand models and the humanoid layers of every equipment asset.
pub(super) struct ArmorStandAssets {
@@ -25,6 +26,11 @@ pub(super) struct ArmorStandAssets {
pub player: HashMap<&'static str, Part>,
/// asset id -> layer kind (humanoid / humanoid_leggings) -> (texture, undyed colour).
pub equipment: HashMap<String, HashMap<String, (String, Option<u32>)>>,
/// asset id -> `trim_overrides`.
pub trim_overrides: HashMap<String, Vec<TrimOverride>>,
pub trims: TrimRegistry,
/// The resources the trim textures are made from.
pub root: PathBuf,
}
impl ArmorStandAssets {
pub fn load(
@@ -48,6 +54,7 @@ impl ArmorStandAssets {
player.insert("elytra", part);
}
let mut equipment = HashMap::new();
let mut trim_overrides = HashMap::new();
if let Ok(entries) = std::fs::read_dir(root.join("assets/minecraft/equipment")) {
for e in entries.flatten() {
let path = e.path();
@@ -76,6 +83,7 @@ impl ArmorStandAssets {
);
}
}
trim_overrides.insert(format!("minecraft:{name}"), TrimOverride::list(&v));
equipment.insert(format!("minecraft:{name}"), kinds);
}
}
@@ -85,30 +93,67 @@ impl ArmorStandAssets {
layers,
player,
equipment,
trim_overrides,
trims: TrimRegistry::load(root),
root: root.to_owned(),
}
}
/// Trim data of reloaded resources (the models stay).
pub fn reload_trims(&mut self, root: &std::path::Path) {
let fresh = Self::load(root, None);
self.trim_overrides = fresh.trim_overrides;
self.trims = fresh.trims;
self.root = fresh.root;
}
/// `TrimTextureKey`: the trim texture of `stack` on its humanoid
/// layer (`humanoid` or `humanoid_leggings`), if it has a trim.
fn trim_texture(&self, asset: &str, kind: &str, stack: &ItemStack) -> Option<TrimTexture> {
let (material, pattern) = stack.extra.as_ref()?.trim.as_ref()?;
let overrides = self
.trim_overrides
.get(asset)
.map_or(&[][..], Vec::as_slice);
TrimTexture::resolve(&self.trims, overrides, material, pattern, kind)
}
}
impl Game<'_> {
/// `HumanoidArmorLayer` for the player: (model, texture rect, colour) of
/// each worn piece, head to feet.
pub(super) fn player_armor_layers(&self) -> Vec<(&Part, [f32; 4], u32)> {
self.armor_layers(self.armor.each_ref().map(|s| s.as_ref().map(|s| &*s.item)))
self.stack_armor_layers(&self.armor)
}
/// `HumanoidArmorLayer` for worn stacks (head to feet), trims included.
pub(super) fn stack_armor_layers(
&self,
armor: &[Option<ItemStack>; 4],
) -> Vec<(&Part, [f32; 4], u32)> {
self.armor_layers(
armor
.each_ref()
.map(|s| s.as_ref().map(|s| (&*s.item, Some(s)))),
)
}
/// `HumanoidArmorLayer` for another player's model: the armour it wears
/// (`extra.head` .. `extra.feet`).
pub(super) fn worn_armor_layers(&self, m: &Mob) -> Vec<(&Part, [f32; 4], u32)> {
let e = &m.extra;
self.armor_layers([&e.head, &e.chest, &e.legs, &e.feet].map(|s| s.as_deref()))
self.armor_layers(
[&e.head, &e.chest, &e.legs, &e.feet].map(|s| s.as_deref().map(|i| (i, None))),
)
}
/// The layers of the armour items `worn`, head to feet.
fn armor_layers(&self, worn: [Option<&str>; 4]) -> Vec<(&Part, [f32; 4], u32)> {
/// The layers of the armour items `worn` (with their stacks when known,
/// for trims), head to feet.
fn armor_layers(
&self,
worn: [Option<(&str, Option<&ItemStack>)>; 4],
) -> Vec<(&Part, [f32; 4], u32)> {
let assets = &self.armor_stand_assets;
let mut out = Vec::new();
for (item, layer) in worn
.into_iter()
.zip(["helmet", "chestplate", "leggings", "boots"])
{
let Some(item) = item else {
let Some((item, stack)) = item else {
continue;
};
let Some(asset) = self
@@ -138,9 +183,117 @@ impl Game<'_> {
0xFF00_0000 | (c & 0xFF) << 16 | (c & 0xFF00) | (c >> 16) & 0xFF
});
out.push((part, [r.u0, r.v0, r.u1, r.v1], color));
// EquipmentLayerRenderer: the trim layer over the armour.
if let Some(r) = stack
.and_then(|s| assets.trim_texture(&asset, kind, s))
.and_then(|t| self.gui.atlas.sprites.get(&t.sprite()))
{
out.push((part, [r.u0, r.v0, r.u1, r.v1], 0xFFFF_FFFF));
}
}
out
}
/// `PalettedTextureManager.getOrPrepare` for the trims drawn this frame
/// (the player's armour and the armour stands'): each generated texture
/// goes into an atlas trim slot, a free one, else the least recently
/// drawn.
pub(super) fn prepare_trims(&mut self) {
use horizon_client::hud::TRIM_SLOTS;
let assets = &self.armor_stand_assets;
let items = self.res.items();
let mut wanted: Vec<TrimTexture> = Vec::new();
let guests = self.lan.iter().flat_map(|host| host.hub.guests.iter());
let stacks = self
.armor
.iter()
.chain(guests.flat_map(|g| g.armor.iter()))
.zip(
["helmet", "chestplate", "leggings", "boots"]
.into_iter()
.cycle(),
)
.chain(self.armor_stands.iter().flat_map(|a| {
[5usize, 4, 3, 2]
.map(|slot| &a.equipment[slot])
.into_iter()
.zip(["helmet", "chestplate", "leggings", "boots"])
}));
for (stack, layer) in stacks {
let Some(stack) = stack.as_ref().filter(|s| s.extra.is_some()) else {
continue;
};
let Some(asset) = items
.get(&stack.item)
.and_then(|i| i.equip_asset.as_deref())
else {
continue;
};
let kind = if layer == "leggings" {
"humanoid_leggings"
} else {
"humanoid"
};
if let Some(t) = assets.trim_texture(asset, kind, stack)
&& !wanted.contains(&t)
{
wanted.push(t);
}
}
for t in wanted {
let name = t.sprite();
// Entries the atlas no longer has (rebuilt by a resource reload) are free.
let sprites = &self.gui.atlas.sprites;
self.trim_slots.retain(|(n, _)| sprites.contains_key(n));
if let Some(i) = self.trim_slots.iter().position(|e| e.0 == name) {
let e = self.trim_slots.remove(i);
self.trim_slots.push(e);
continue;
}
let Some((w, h, rgba)) = t.generate(&self.armor_stand_assets.root) else {
continue;
};
let used: Vec<usize> = self.trim_slots.iter().map(|e| e.1).collect();
let slot = match (0..TRIM_SLOTS).find(|i| !used.contains(i)) {
Some(free) => free,
None => {
let (old, slot) = self.trim_slots.remove(0);
self.gui.atlas.sprites.remove(&old);
slot
}
};
let Some(area) = self
.gui
.atlas
.sprites
.get(&format!("horizon/trim{slot}"))
.copied()
else {
continue;
};
if w > area.w || h > area.h {
continue;
}
let (aw, ah) = (self.gui.atlas.width as f32, self.gui.atlas.height as f32);
let (x, y) = ((area.u0 * aw).round(), (area.v0 * ah).round());
self.map_patches.push(horizon_client::font::Patch {
x: x as u32,
y: y as u32,
width: w,
height: h,
rgba,
});
let rect = horizon_client::hud::Rect {
u0: area.u0,
v0: area.v0,
u1: (x + w as f32) / aw,
v1: (y + h as f32) / ah,
w,
h,
};
self.gui.atlas.sprites.insert(name.clone(), rect);
self.trim_slots.push((name, slot));
}
}
/// `ArmorStandItem.useOn`.
pub(super) fn place_armor_stand(&mut self, hit: &super::Hit, stack: &ItemStack) -> bool {
if &*stack.item != "minecraft:armor_stand" || hit.face == [0, -1, 0] {
@@ -564,6 +717,22 @@ impl Game<'_> {
0,
out,
);
// EquipmentLayerRenderer: the trim layer over the armour.
if let Some(trim) = assets
.trim_texture(&asset, kind, stack)
.and_then(|t| uv_of(&t.sprite()))
{
horizon_client::mobs::render::draw(
part,
base,
&layer_poses,
trim,
0xFFFF_FFFF,
packed,
0,
out,
);
}
}
self.cull_entity_vertices(out, entity_start);
}
+5 -2
View File
@@ -1243,7 +1243,7 @@ impl Game<'_> {
};
let atlas = &self.gui.atlas;
let lookup = |name: &str| atlas.sprites.get(name).map(|r| [r.u0, r.v0, r.u1, r.v1]);
for m in host.models.values() {
for (conn, m) in &host.models {
let entity_start = out.len();
let light = self.world.light(
m.position.x.floor() as i32,
@@ -1258,7 +1258,10 @@ impl Game<'_> {
&lookup,
packed,
self.res.mob_data(),
&self.worn_armor_layers(m),
&host.hub.guest(*conn).map_or_else(
|| self.worn_armor_layers(m),
|g| self.stack_armor_layers(&g.armor),
),
out,
);
self.held_item_geometry(m, camera, alpha, packed, true, out);
+1
View File
@@ -171,6 +171,7 @@ impl Game<'_> {
}
};
// Everything loaded: switch over.
self.armor_stand_assets.reload_trims(root);
self.random_tick_sections.clear();
self.portals.sections.clear();
self.options.resources = root.to_path_buf();
+13 -2
View File
@@ -40,6 +40,9 @@ 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 armour trim textures made at run time (`trims`), each the
/// size of the largest trim texture.
pub const TRIM_SLOTS: usize = 32;
pub fn decode(path: &Path) -> Result<(u32, u32, Vec<u8>)> {
decode_bytes(&fs::read(path)?)
}
@@ -180,7 +183,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.
fn slots(images: &mut Vec<PackedImage>) {
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]));
}
@@ -195,6 +198,14 @@ impl HudAtlas {
for i in 0..SKIN_SLOTS {
images.push((format!("horizon/skin{i}"), 64, 64, vec![0; 64 * 64 * 4]));
}
for i in 0..TRIM_SLOTS {
images.push((
format!("horizon/trim{i}"),
trim.0,
trim.1,
vec![0; (trim.0 * trim.1 * 4) as usize],
));
}
for i in 0..WORLD_ICON_SLOTS {
images.push((
format!("horizon/world-icon{i}"),
@@ -277,7 +288,7 @@ impl HudAtlas {
}
images.push(("horizon/white".into(), 4, 4, vec![255; 64]));
if full {
Self::slots(&mut images);
Self::slots(&mut images, crate::trims::slot_size(root));
}
images.sort_by(|a, b| b.2.cmp(&a.2).then(b.1.cmp(&a.1)));
let width = 4096u32;
+1
View File
@@ -180,6 +180,7 @@ pub mod ticket_levels;
pub mod title;
pub mod title_edition;
pub mod toasts;
pub mod trims;
pub mod ui;
pub mod ui_theme;
pub mod vanillagen;
+354
View File
@@ -0,0 +1,354 @@
//! Armour trims on worn armour: `EquipmentLayerRenderer`'s trim layer. A
//! trim's texture is `textures/trims/entity/<layer>/<pattern>.png` recoloured
//! by `PalettedTextureManager`: every pixel whose colour is in the texture's
//! base palette (its `palette` metadata section, `trim_base`) takes the colour
//! at the same index of the material's palette (`textures/palettes/trim/*`),
//! unless the equipment asset's `trim_overrides` pick another texture or
//! palette (iron armour with an iron trim uses `trim/iron_darker`).
use horizon_assets::palette::apply_palette;
use serde_json::Value;
use std::{collections::HashMap, fs, path::Path};
/// An RGBA image: width, height, pixels.
pub type Image = (u32, u32, Vec<u8>);
/// `minecraft:` added to an identifier without a namespace.
fn qualified(id: &str) -> String {
if id.contains(':') {
id.to_owned()
} else {
format!("minecraft:{id}")
}
}
/// `assets/<namespace>/<folder>/<path><suffix>` of an identifier.
fn asset_path(root: &Path, folder: &str, id: &str, suffix: &str) -> std::path::PathBuf {
let id = qualified(id);
let (namespace, path) = id.split_once(':').unwrap_or(("minecraft", &id));
root.join("assets")
.join(namespace)
.join(folder)
.join(format!("{path}{suffix}"))
}
/// `EquipmentClientInfo.TrimOverride`: when the trim matches (`when`'s
/// material and pattern, each optional), use `texture` instead of the
/// pattern's asset id and `palette` (none when absent) as the palette.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct TrimOverride {
pub material: Option<String>,
pub pattern: Option<String>,
pub texture: Option<String>,
pub palette: Option<String>,
}
impl TrimOverride {
/// An equipment asset's `trim_overrides` list.
pub fn list(equipment: &Value) -> Vec<Self> {
let Some(list) = equipment.get("trim_overrides").and_then(Value::as_array) else {
return Vec::new();
};
let id = |v: &Value, key: &str| v.get(key).and_then(Value::as_str).map(qualified);
list.iter()
.filter_map(|o| {
let when = o.get("when")?;
Some(Self {
material: id(when, "material"),
pattern: id(when, "pattern"),
texture: id(o, "texture"),
palette: id(o, "palette"),
})
})
.collect()
}
/// `TrimPredicate.matches`.
fn matches(&self, material: &str, pattern: &str) -> bool {
self.material.as_deref().is_none_or(|m| m == material)
&& self.pattern.as_deref().is_none_or(|p| p == pattern)
}
}
/// The `trim_pattern` (asset id) and `trim_material` (palette id) registries.
#[derive(Clone, Debug, Default)]
pub struct TrimRegistry {
patterns: HashMap<String, String>,
materials: HashMap<String, String>,
}
impl TrimRegistry {
/// Every `data/<namespace>/trim_pattern` and `trim_material` entry.
pub fn load(root: &Path) -> Self {
let mut out = Self::default();
let Ok(namespaces) = fs::read_dir(root.join("data")) else {
return out;
};
for ns in namespaces.flatten() {
let namespace = ns.file_name().to_string_lossy().into_owned();
for (folder, key, map) in [
("trim_pattern", "asset_id", &mut out.patterns),
("trim_material", "palette_id", &mut out.materials),
] {
let Ok(files) = fs::read_dir(ns.path().join(folder)) else {
continue;
};
for f in files.flatten() {
let path = f.path();
if path.extension().is_none_or(|e| e != "json") {
continue;
}
let Some(value) = fs::read(&path)
.ok()
.and_then(|b| serde_json::from_slice::<Value>(&b).ok())
else {
continue;
};
if let Some(v) = value.get(key).and_then(Value::as_str) {
let name = path.file_stem().unwrap_or_default().to_string_lossy();
map.insert(format!("{namespace}:{name}"), qualified(v));
}
}
}
}
out
}
#[cfg(test)]
fn of(patterns: &[(&str, &str)], materials: &[(&str, &str)]) -> Self {
let map = |l: &[(&str, &str)]| {
l.iter()
.map(|(k, v)| (k.to_string(), v.to_string()))
.collect()
};
Self {
patterns: map(patterns),
materials: map(materials),
}
}
}
/// The texture and palette of one trim layer.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct TrimTexture {
/// `<namespace>:trims/entity/<layer>/<path>`, under `textures/`.
pub texture: String,
/// The target palette under `textures/palettes/`; none draws the
/// texture's own colours.
pub palette: Option<String>,
}
impl TrimTexture {
/// `TrimTextureKey.getOrPrepareTexture`: the trim (`material`,
/// `pattern` registry ids) on the `layer` (`humanoid`,
/// `humanoid_leggings`...) of an equipment asset with `overrides`.
pub fn resolve(
registry: &TrimRegistry,
overrides: &[TrimOverride],
material: &str,
pattern: &str,
layer: &str,
) -> Option<Self> {
let (material, pattern) = (qualified(material), qualified(pattern));
let mut texture = registry.patterns.get(&pattern)?.clone();
let mut palette = Some(registry.materials.get(&material)?.clone());
if let Some(o) = overrides.iter().find(|o| o.matches(&material, &pattern)) {
if let Some(t) = &o.texture {
texture.clone_from(t);
}
palette.clone_from(&o.palette);
}
let (namespace, path) = texture.split_once(':')?;
Some(Self {
texture: format!("{namespace}:trims/entity/{layer}/{path}"),
palette,
})
}
/// The atlas sprite name the generated texture is stored under.
pub fn sprite(&self) -> String {
format!(
"horizon/trim/{}/{}",
self.texture,
self.palette.as_deref().unwrap_or("-")
)
}
/// `PalettedTextureManager.prepareSlot`: the texture with its base
/// palette's colours swapped for the target palette's (`PaletteMapping`;
/// unchanged when a palette is missing or the sizes differ). None when
/// the texture itself is missing.
pub fn generate(&self, root: &Path) -> Option<Image> {
let path = asset_path(root, "textures", &self.texture, ".png");
let (w, h, pixels) = crate::hud::decode(&path).ok()?;
let Some(palette) = &self.palette else {
return Some((w, h, pixels));
};
let base = fs::read(path.with_extension("png.mcmeta"))
.ok()
.and_then(|b| serde_json::from_slice::<Value>(&b).ok())
.and_then(|m| {
m.get("palette")?
.get("base_palette")?
.as_str()
.map(str::to_owned)
});
let load = |id: &str| {
crate::hud::decode(&asset_path(root, "textures/palettes", id, ".png"))
.ok()
.map(|(_, _, p)| argb(&p))
};
let mut mapped = argb(&pixels);
if let (Some(key), Some(target)) = (base.as_deref().and_then(load), load(palette)) {
// Different sizes: PaletteMapping.NONE, the texture as it is.
let _ = apply_palette(&mut mapped, &key, &target);
}
let out = mapped
.iter()
.flat_map(|p| {
let [a, r, g, b] = p.to_be_bytes();
[r, g, b, a]
})
.collect();
Some((w, h, out))
}
}
fn argb(rgba: &[u8]) -> Vec<u32> {
rgba.as_chunks::<4>()
.0
.iter()
.map(|p| u32::from_be_bytes([p[3], p[0], p[1], p[2]]))
.collect()
}
/// The largest trim texture of the resources (the size of the atlas's trim
/// slots), at least vanilla's 64x32.
pub fn slot_size(root: &Path) -> (u32, u32) {
let mut size = (64, 32);
let Ok(namespaces) = fs::read_dir(root.join("assets")) else {
return size;
};
for ns in namespaces.flatten() {
let Ok(layers) = fs::read_dir(ns.path().join("textures/trims/entity")) else {
continue;
};
for layer in layers.flatten() {
for f in fs::read_dir(layer.path()).into_iter().flatten().flatten() {
let path = f.path();
if path.extension().is_some_and(|e| e == "png")
&& let Some((w, h)) = png_size(&path)
{
size = (size.0.max(w.min(512)), size.1.max(h.min(512)));
}
}
}
}
size
}
/// The width and height in a PNG's IHDR chunk.
fn png_size(path: &Path) -> Option<(u32, u32)> {
use std::io::Read;
let mut head = [0u8; 24];
fs::File::open(path).ok()?.read_exact(&mut head).ok()?;
let be = |i: usize| u32::from_be_bytes(head[i..i + 4].try_into().unwrap());
(&head[12..16] == b"IHDR").then(|| (be(16), be(20)))
}
#[cfg(test)]
mod tests {
use super::*;
fn registry() -> TrimRegistry {
TrimRegistry::of(
&[("minecraft:coast", "minecraft:coast")],
&[
("minecraft:iron", "minecraft:trim/iron"),
("minecraft:gold", "minecraft:trim/gold"),
],
)
}
#[test]
fn material_palette_and_layer_folder() {
let t = TrimTexture::resolve(
&registry(),
&[],
"minecraft:gold",
"minecraft:coast",
"humanoid_leggings",
)
.unwrap();
assert_eq!(t.texture, "minecraft:trims/entity/humanoid_leggings/coast");
assert_eq!(t.palette.as_deref(), Some("minecraft:trim/gold"));
// Unknown registry entries draw nothing.
assert!(
TrimTexture::resolve(
&registry(),
&[],
"minecraft:wood",
"minecraft:coast",
"humanoid"
)
.is_none()
);
}
#[test]
fn equipment_overrides_pick_the_darker_palette() {
let iron = serde_json::json!({"trim_overrides": [
{"palette": "minecraft:trim/iron_darker", "when": {"material": "minecraft:iron"}},
]});
let overrides = TrimOverride::list(&iron);
let resolve =
|m| TrimTexture::resolve(&registry(), &overrides, m, "coast", "humanoid").unwrap();
assert_eq!(
resolve("iron").palette.as_deref(),
Some("minecraft:trim/iron_darker")
);
assert_eq!(
resolve("gold").palette.as_deref(),
Some("minecraft:trim/gold")
);
// An override without a palette leaves the texture's own colours.
let plain = TrimOverride::list(&serde_json::json!({"trim_overrides": [
{"texture": "minecraft:other", "when": {"pattern": "minecraft:coast"}},
]}));
let t = TrimTexture::resolve(&registry(), &plain, "gold", "coast", "humanoid").unwrap();
assert_eq!(t.texture, "minecraft:trims/entity/humanoid/other");
assert_eq!(t.palette, None);
}
#[test]
fn vanilla_trims_are_recoloured() {
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3");
if !root.join("assets/minecraft/textures/trims").is_dir() {
return;
}
let registry = TrimRegistry::load(&root);
let t = TrimTexture::resolve(
&registry,
&[],
"minecraft:gold",
"minecraft:coast",
"humanoid",
)
.unwrap();
let (w, h, gold) = t.generate(&root).unwrap();
assert_eq!((w, h), (64, 32));
let plain = TrimTexture {
palette: None,
..t.clone()
};
let (_, _, grey) = plain.generate(&root).unwrap();
// Every opaque pixel of the grey pattern takes a gold palette colour.
let gold_palette = argb(
&crate::hud::decode(&root.join("assets/minecraft/textures/palettes/trim/gold.png"))
.unwrap()
.2,
);
let mut opaque = 0;
for (g, c) in grey.chunks(4).zip(gold.chunks(4)) {
if g[3] != 0 {
opaque += 1;
let c = u32::from_be_bytes([0xFF, c[0], c[1], c[2]]);
assert!(gold_palette.contains(&c), "{c:08x}");
}
}
assert!(opaque > 0);
assert_eq!(slot_size(&root), (64, 32));
}
}