From 635acffda91c254efcf0b6f25c3c7001f3dc9c68 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sat, 10 Oct 2026 22:16:37 +0200 Subject: [PATCH] Draw every item through the resolved item model pipeline The client now resolves stacks with horizon-assets' ItemModelResolver into an ItemStackRenderState equivalent (item_render): baked cuboid layers with their display and local transforms, tints and foil, and the special model renderers (chests, shulker boxes, banners, heads, shields, tridents, decorated pots, conduits, bells, books, copper golem statues) posed from the entity model layers. GUI icons are submitted under the GuiItemAtlas pose with ITEMS_3D/ITEMS_FLAT lighting, back faces culled and clipped to the slot; dropped items follow ItemEntityRenderer (bounding box hover, spin and seeded cluster copies); item frames, first-person and mob, player and armour stand hands, worn skulls and head items submit the same state in the world. The client atlas also runs the atlas sprite sources (directory, single, filter, unstitch, paletted_permutations), so armour trim sprites exist. The ad-hoc icon, held-banner, shield, potion-layer and glint paths are gone. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/atlas_sources.rs | 464 ++++++++++ crates/horizon-client/src/game.rs | 610 +------------ .../horizon-client/src/game/armor_stands.rs | 120 +++ crates/horizon-client/src/game/banners.rs | 159 ---- crates/horizon-client/src/game/creatures.rs | 1 - crates/horizon-client/src/game/frames.rs | 113 +-- crates/horizon-client/src/game/item_draw.rs | 373 ++++++++ crates/horizon-client/src/game/mob_blocks.rs | 121 +-- crates/horizon-client/src/game/packs.rs | 6 +- crates/horizon-client/src/game/perspective.rs | 2 + crates/horizon-client/src/game/shield.rs | 129 --- crates/horizon-client/src/game/stations.rs | 94 -- crates/horizon-client/src/hud.rs | 53 ++ crates/horizon-client/src/item_render.rs | 815 ++++++++++++++++++ crates/horizon-client/src/item_render/gui.rs | 245 ++++++ .../horizon-client/src/item_render/special.rs | 597 +++++++++++++ crates/horizon-client/src/lib.rs | 2 + crates/horizon-client/src/mobs/anim.rs | 1 + crates/horizon-client/src/mobs/render.rs | 163 +--- crates/horizon-client/src/packs.rs | 2 +- 20 files changed, 2817 insertions(+), 1253 deletions(-) create mode 100644 crates/horizon-client/src/atlas_sources.rs create mode 100644 crates/horizon-client/src/game/item_draw.rs create mode 100644 crates/horizon-client/src/item_render.rs create mode 100644 crates/horizon-client/src/item_render/gui.rs create mode 100644 crates/horizon-client/src/item_render/special.rs diff --git a/crates/horizon-client/src/atlas_sources.rs b/crates/horizon-client/src/atlas_sources.rs new file mode 100644 index 000000000..1eea24666 --- /dev/null +++ b/crates/horizon-client/src/atlas_sources.rs @@ -0,0 +1,464 @@ +//! Atlas sprite sources (`SpriteSourceList`): the `atlases/*.json` +//! definitions listing which sprites an atlas holds. `directory`, `single`, +//! `filter`, `unstitch` and `paletted_permutations` sources run in order +//! against the resource tree; a later source replaces an earlier sprite of +//! the same id and a filter removes the matching ones. +use crate::packs::pattern::Pattern; +use horizon_assets::palette::apply_palette; +use serde_json::Value; +use std::{ + collections::BTreeMap, + fs, + path::{Path, PathBuf}, +}; + +/// One region of an `unstitch` source, in units of the divisors. +#[derive(Clone, Debug, PartialEq)] +pub struct Region { + pub sprite: String, + pub x: f64, + pub y: f64, + pub width: f64, + pub height: f64, +} +#[derive(Clone, Debug)] +pub enum SpriteSource { + Directory { + source: String, + prefix: String, + }, + Single { + resource: String, + sprite: Option, + }, + Filter { + namespace: Option, + path: Option, + }, + Unstitch { + resource: String, + regions: Vec, + divisor_x: f64, + divisor_y: f64, + }, + PalettedPermutations { + textures: Vec, + palette_key: String, + permutations: BTreeMap, + separator: String, + }, +} +/// Where a listed sprite's pixels come from. +#[derive(Clone, Debug, PartialEq)] +pub enum SpriteOrigin { + /// A whole texture (`textures/.png`), by texture identifier. + File(String), + /// `Unstitcher.RegionInstance`: part of a texture. + Region { + texture: String, + region: Region, + divisor_x: f64, + divisor_y: f64, + }, + /// `PalettedSpriteSupplier`: a texture with its colours remapped. + Paletted { + texture: String, + palette_key: String, + palette: String, + }, +} + +/// `Identifier.parse` default namespace. +pub fn qualified(id: &str) -> String { + if id.contains(':') { + id.to_owned() + } else { + format!("minecraft:{id}") + } +} +fn string(v: &Value, key: &str) -> Option { + v.get(key)?.as_str().map(str::to_owned) +} +fn number(v: &Value, key: &str, default: f64) -> Option { + match v.get(key) { + None => Some(default), + Some(n) => n.as_f64(), + } +} + +/// `SpriteSources.FILE_CODEC`: the `sources` list of an atlas definition. +/// A malformed source fails the whole file, as the codec does. +pub fn decode(text: &str) -> Option> { + let json: Value = serde_json::from_str(text).ok()?; + json.get("sources")? + .as_array()? + .iter() + .map(decode_source) + .collect() +} +fn decode_source(s: &Value) -> Option { + Some(match qualified(s.get("type")?.as_str()?).as_str() { + "minecraft:directory" => SpriteSource::Directory { + source: string(s, "source")?, + prefix: string(s, "prefix")?, + }, + "minecraft:single" => SpriteSource::Single { + resource: qualified(&string(s, "resource")?), + sprite: match s.get("sprite") { + None => None, + Some(v) => Some(qualified(v.as_str()?)), + }, + }, + "minecraft:filter" => { + let p = s.get("pattern")?; + let pattern = |key: &str| -> Option> { + match p.get(key) { + None => Some(None), + Some(v) => Pattern::new(v.as_str()?).map(Some), + } + }; + SpriteSource::Filter { + namespace: pattern("namespace")?, + path: pattern("path")?, + } + } + "minecraft:unstitch" => { + let regions = s + .get("regions")? + .as_array()? + .iter() + .map(|r| { + Some(Region { + sprite: qualified(&string(r, "sprite")?), + x: r.get("x")?.as_f64()?, + y: r.get("y")?.as_f64()?, + width: r.get("width")?.as_f64()?, + height: r.get("height")?.as_f64()?, + }) + }) + .collect::>>()?; + if regions.is_empty() { + return None; + } + SpriteSource::Unstitch { + resource: qualified(&string(s, "resource")?), + regions, + divisor_x: number(s, "divisor_x", 1.0)?, + divisor_y: number(s, "divisor_y", 1.0)?, + } + } + "minecraft:paletted_permutations" => SpriteSource::PalettedPermutations { + textures: s + .get("textures")? + .as_array()? + .iter() + .map(|t| t.as_str().map(qualified)) + .collect::>()?, + palette_key: qualified(&string(s, "palette_key")?), + permutations: s + .get("permutations")? + .as_object()? + .iter() + .map(|(k, v)| Some((k.clone(), qualified(v.as_str()?)))) + .collect::>()?, + separator: match s.get("separator") { + None => "_".to_owned(), + Some(v) => v.as_str()?.to_owned(), + }, + }, + _ => return None, + }) +} + +/// The texture files of a resource tree: `namespace:path` for every +/// `assets//textures/.png`. +pub fn list_textures(root: &Path) -> Vec { + let mut out = Vec::new(); + let Ok(namespaces) = fs::read_dir(root.join("assets")) else { + return out; + }; + for ns in namespaces.flatten() { + let namespace = ns.file_name().to_string_lossy().into_owned(); + let base = ns.path().join("textures"); + let mut stack = vec![base.clone()]; + while let Some(dir) = stack.pop() { + let Ok(entries) = fs::read_dir(&dir) else { + continue; + }; + for e in entries.flatten() { + let p = e.path(); + if p.is_dir() { + stack.push(p); + } else if p.extension().is_some_and(|x| x == "png") + && let Ok(rel) = p.strip_prefix(&base) + { + let rel = rel.with_extension("").to_string_lossy().replace('\\', "/"); + out.push(format!("{namespace}:{rel}")); + } + } + } + } + out.sort(); + out +} +/// The file of a texture identifier. +pub fn texture_path(root: &Path, texture: &str, directory: &str) -> PathBuf { + let (namespace, path) = texture.split_once(':').unwrap_or(("minecraft", texture)); + root.join(format!("assets/{namespace}/{directory}/{path}.png")) +} + +/// `SpriteSourceList.list`: every sprite id of the atlas and its origin. +/// `textures` are the available texture identifiers ([`list_textures`]). +pub fn list(sources: &[SpriteSource], textures: &[String]) -> BTreeMap { + let mut out = BTreeMap::new(); + let exists = |t: &str| textures.binary_search_by(|x| x.as_str().cmp(t)).is_ok(); + for source in sources { + match source { + SpriteSource::Directory { source, prefix } => { + // FileToIdConverter("textures/" + source, ".png"). + let dir = format!("{source}/"); + for t in textures { + let (namespace, path) = t.split_once(':').unwrap_or(("minecraft", t)); + if let Some(rest) = path.strip_prefix(&dir) { + out.insert( + format!("{namespace}:{prefix}{rest}"), + SpriteOrigin::File(t.clone()), + ); + } + } + } + SpriteSource::Single { resource, sprite } => { + if exists(resource) { + out.insert( + sprite.clone().unwrap_or_else(|| resource.clone()), + SpriteOrigin::File(resource.clone()), + ); + } + } + SpriteSource::Filter { namespace, path } => { + out.retain(|id: &String, _| { + let (ns, p) = id.split_once(':').unwrap_or(("minecraft", id)); + !(namespace.as_ref().is_none_or(|m| m.is_match(ns)) + && path.as_ref().is_none_or(|m| m.is_match(p))) + }); + } + SpriteSource::Unstitch { + resource, + regions, + divisor_x, + divisor_y, + } => { + if exists(resource) { + for region in regions { + out.insert( + region.sprite.clone(), + SpriteOrigin::Region { + texture: resource.clone(), + region: region.clone(), + divisor_x: *divisor_x, + divisor_y: *divisor_y, + }, + ); + } + } + } + SpriteSource::PalettedPermutations { + textures: bases, + palette_key, + permutations, + separator, + } => { + for base in bases { + if !exists(base) { + continue; + } + for (suffix, palette) in permutations { + out.insert( + format!("{base}{separator}{suffix}"), + SpriteOrigin::Paletted { + texture: base.clone(), + palette_key: palette_key.clone(), + palette: palette.clone(), + }, + ); + } + } + } + } + } + out +} + +/// An RGBA image. +pub type Image = (u32, u32, Vec); + +fn argb(rgba: &[u8]) -> Vec { + rgba.as_chunks::<4>() + .0 + .iter() + .map(|p| u32::from_be_bytes([p[3], p[0], p[1], p[2]])) + .collect() +} +/// The pixels of a generated sprite (`Region` or `Paletted`); `None` for a +/// plain file, which loads as itself. +pub fn generate( + origin: &SpriteOrigin, + load: &dyn Fn(&str, &str) -> Option, +) -> Option { + match origin { + SpriteOrigin::File(_) => None, + SpriteOrigin::Region { + texture, + region, + divisor_x, + divisor_y, + } => { + let (w, h, pixels) = load(texture, "textures")?; + let x_scale = f64::from(w) / divisor_x; + let y_scale = f64::from(h) / divisor_y; + let x = (region.x * x_scale).floor() as i64; + let y = (region.y * y_scale).floor() as i64; + let width = (region.width * x_scale).floor() as i64; + let height = (region.height * y_scale).floor() as i64; + if width <= 0 || height <= 0 { + return None; + } + let mut out = vec![0u8; (width * height * 4) as usize]; + for row in 0..height { + for col in 0..width { + let (sx, sy) = (x + col, y + row); + if sx < 0 || sy < 0 || sx >= i64::from(w) || sy >= i64::from(h) { + continue; + } + let s = ((sy * i64::from(w) + sx) * 4) as usize; + let d = ((row * width + col) * 4) as usize; + out[d..d + 4].copy_from_slice(&pixels[s..s + 4]); + } + } + Some((width as u32, height as u32, out)) + } + SpriteOrigin::Paletted { + texture, + palette_key, + palette, + } => { + let (w, h, pixels) = load(texture, "textures")?; + let (_, _, key) = load(palette_key, "textures/palettes")?; + let (_, _, target) = load(palette, "textures/palettes")?; + let mut mapped = argb(&pixels); + apply_palette(&mut mapped, &argb(&key), &argb(&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)) + } + } +} + +/// Every atlas definition of a resource tree (`atlases/*.json` in every +/// namespace), by atlas id. +pub fn atlases(root: &Path) -> BTreeMap> { + let mut out = BTreeMap::new(); + let Ok(namespaces) = fs::read_dir(root.join("assets")) else { + return out; + }; + for ns in namespaces.flatten() { + let namespace = ns.file_name().to_string_lossy().into_owned(); + let Ok(files) = fs::read_dir(ns.path().join("atlases")) else { + continue; + }; + for f in files.flatten() { + let path = f.path(); + if path.extension().is_none_or(|e| e != "json") { + continue; + } + let name = path.file_stem().unwrap_or_default().to_string_lossy(); + if let Some(sources) = fs::read_to_string(&path).ok().and_then(|t| decode(&t)) { + out.insert(format!("{namespace}:{name}"), sources); + } + } + } + out +} + +#[cfg(test)] +mod tests { + use super::*; + + fn textures() -> Vec { + let mut t: Vec = [ + "minecraft:item/apple", + "minecraft:item/stick", + "minecraft:trims/items/boots_trim", + "minecraft:block/stone", + "minecraft:entity/sheet", + ] + .iter() + .map(|s| s.to_string()) + .collect(); + t.sort(); + t + } + #[test] + fn sources_run_in_order() { + let sources = decode( + r#"{"sources":[ + {"type":"directory","source":"item","prefix":"item/"}, + {"type":"minecraft:single","resource":"block/stone","sprite":"item/stone"}, + {"type":"filter","pattern":{"path":"stick"}}, + {"type":"unstitch","resource":"entity/sheet","divisor_x":2,"regions":[{"sprite":"a","x":1,"y":0,"width":1,"height":1}]}, + {"type":"paletted_permutations","textures":["trims/items/boots_trim"],"palette_key":"trims/color_palettes/trim_palette","permutations":{"quartz":"trims/color_palettes/quartz"}} + ]}"#, + ) + .unwrap(); + let listed = list(&sources, &textures()); + let ids: Vec<&str> = listed.keys().map(String::as_str).collect(); + assert_eq!( + ids, + [ + "minecraft:a", + "minecraft:item/apple", + "minecraft:item/stone", + "minecraft:trims/items/boots_trim_quartz" + ] + ); + assert_eq!( + listed["minecraft:item/stone"], + SpriteOrigin::File("minecraft:block/stone".into()) + ); + } + #[test] + fn malformed_sources_fail_the_file() { + assert!(decode(r#"{"sources":[{"type":"directory","source":"item"}]}"#).is_none()); + assert!( + decode(r#"{"sources":[{"type":"unstitch","resource":"x","regions":[]}]}"#).is_none() + ); + assert!(decode(r#"{"sources":[{"type":"horizon"}]}"#).is_none()); + } + #[test] + fn unstitch_cuts_by_divisor() { + let pixels: Vec = (0..16u8).flat_map(|i| [i, i, i, 255]).collect(); + let load = |_: &str, _: &str| Some((4u32, 4u32, pixels.clone())); + let origin = SpriteOrigin::Region { + texture: "t".into(), + region: Region { + sprite: "s".into(), + x: 1.0, + y: 1.0, + width: 1.0, + height: 1.0, + }, + divisor_x: 2.0, + divisor_y: 2.0, + }; + let (w, h, out) = generate(&origin, &load).unwrap(); + assert_eq!((w, h), (2, 2)); + assert_eq!(out[0], 10); + assert_eq!(out[4], 11); + assert_eq!(out[8], 14); + } +} diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index b81c403fd..8a768c811 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -35,6 +35,7 @@ mod ghasts; mod golems; mod growth; mod health_hud; +mod item_draw; mod jukebox; mod lan; mod lan_actions; @@ -290,16 +291,6 @@ enum Screen { /// WorldOptionsScreen (game/lan_screen.rs). WorldOptions, } -#[derive(Clone)] -enum Icon { - Flat(String), - Cube { - top: String, - left: String, - right: String, - tint: u32, - }, -} struct Mining { pos: [i32; 3], progress: f32, @@ -493,7 +484,6 @@ pub struct Resources { biomes: Arc, environment: Environment, atlas: HudAtlas, - icons: HashMap>, layer_names: HashMap, mob_types: HashMap>, mob_data: horizon_client::mobs::MobData, @@ -514,8 +504,8 @@ pub struct Resources { threads: usize, player_arm: Option, player_type: Option>, - /// firstperson_righthand display transforms per item: (rotation, translation, scale). - displays: HashMap>, + /// Item definitions, baked item models and special renderers. + item_renderer: Arc, /// Enchantments, workstation recipes and brewing (game/stations.rs). stations: horizon_client::stations::StationData, } @@ -979,37 +969,6 @@ impl Game<'_> { } Some(stack) } - /// The block's particle texture (approximated by its first model face) and tint. - /// The `particle` texture of a block's first blockstate model (for models without faces). - fn model_particle(&self, block: &str) -> Option { - let root = &self.options.resources; - let read = |path: String| -> Option { - serde_json::from_slice(&std::fs::read(root.join(path)).ok()?).ok() - }; - let states = read(format!("assets/minecraft/blockstates/{block}.json"))?; - let mut model = states["variants"] - .as_object()? - .values() - .next() - .and_then(|v| v["model"].as_str().or_else(|| v[0]["model"].as_str()))? - .to_owned(); - for _ in 0..8 { - let m = read(format!( - "assets/minecraft/models/{}.json", - model.trim_start_matches("minecraft:") - ))?; - if let Some(p) = m["textures"]["particle"].as_str() { - let p = if let Some(alias) = p.strip_prefix('#') { - m["textures"][alias].as_str()? - } else { - p - }; - return Some(p.trim_start_matches("minecraft:").to_owned()); - } - model = m["parent"].as_str()?.to_owned(); - } - None - } fn particle_sprite(&self, state: BlockStateId) -> Option<(String, u32)> { let models = self .res @@ -2150,7 +2109,15 @@ impl Game<'_> { 0.5 + 0.5 * self.world.random.next_int_bound(2).unwrap_or(0) as f32, pitch, ); - if let Some(Icon::Flat(sprite)) = self.icon(&stack.item) { + // `ItemParticleOption`: the particle material of a random layer of + // the stack resolved for the ground (`BreakingItemParticle`). + let state = self.resolve_item( + &stack, + horizon_assets::item_model::DisplayContext::Ground, + None, + 0, + ); + if let Some(sprite) = state.pick_particle(&mut self.world.random) { let (yaw, pitch) = ( f64::from(self.yaw).to_radians(), f64::from(self.pitch).to_radians(), @@ -2834,231 +2801,11 @@ impl Game<'_> { } window.set_cursor_visible(!self.captured); } - fn icon(&mut self, item: &str) -> Option { - if let Some(icon) = self.res.icons.get(item) { - return icon.clone(); - } - let icon = self.resolve_icon(item); - self.res.icons.insert(item.to_owned(), icon.clone()); - icon - } - fn resolve_icon(&self, item: &str) -> Option { - let root = &self.options.resources; - let name = item.trim_start_matches("minecraft:"); - let info = self.res.items.get(item); - let model_name = info.map_or(name.to_owned(), |i| { - i.model.trim_start_matches("minecraft:").to_owned() - }); - let def: serde_json::Value = serde_json::from_slice( - &std::fs::read(root.join(format!("assets/minecraft/items/{model_name}.json"))).ok()?, - ) - .ok()?; - // Find the first plain model reference in the item model definition. - fn first_model(v: &serde_json::Value) -> Option { - match v { - serde_json::Value::Object(o) => { - if o.get("type").and_then(|t| t.as_str()) == Some("minecraft:model") { - return o.get("model").and_then(|m| m.as_str()).map(str::to_owned); - } - // A display_context select: the inventory shows the `gui` case. - if o.get("property").and_then(|t| t.as_str()) - == Some("minecraft:display_context") - && let Some(case) = - o.get("cases").and_then(|c| c.as_array()).and_then(|cases| { - cases.iter().find(|c| match &c["when"] { - serde_json::Value::String(w) => w == "gui", - serde_json::Value::Array(ws) => ws.iter().any(|w| w == "gui"), - _ => false, - }) - }) - { - return first_model(&case["model"]); - } - for key in [ - "model", "fallback", "on_false", "on_true", "cases", "entries", "tints", - ] { - if let Some(m) = o.get(key).and_then(first_model) { - return Some(m); - } - } - o.values().find_map(first_model) - } - serde_json::Value::Array(a) => a.iter().find_map(first_model), - _ => None, - } - } - let Some(model) = first_model(&def["model"]) else { - // Special item models (chests, beds, banners...): show the block's particle texture. - let block = self - .res - .assets - .registry - .default_state(item) - .or_else(|| info.and_then(|i| i.block))?; - let (sprite, tint) = self - .particle_sprite(block) - .or_else(|| self.model_particle(name).map(|s| (s, 0xFFFFFF)))?; - return Some(Icon::Cube { - top: sprite.clone(), - left: sprite.clone(), - right: sprite, - tint, - }); - }; - let path = model.trim_start_matches("minecraft:").to_owned(); - let mut current = path.clone(); - let mut textures = serde_json::Map::new(); - for _ in 0..16 { - let text = - std::fs::read(root.join(format!("assets/minecraft/models/{current}.json"))).ok()?; - let m: serde_json::Value = serde_json::from_slice(&text).ok()?; - if let Some(t) = m["textures"].as_object() { - for (k, v) in t { - textures.entry(k.clone()).or_insert(v.clone()); - } - } - match m["parent"].as_str() { - Some(p) - if p.ends_with("item/generated") - || p.ends_with("item/handheld") - || p.contains("handheld") => - { - let layer = textures.get("layer0")?.as_str()?; - return Some(Icon::Flat( - layer.trim_start_matches("minecraft:").to_owned(), - )); - } - Some(p) => current = p.trim_start_matches("minecraft:").to_owned(), - None => break, - } - } - if path.starts_with("block/") { - let block = self - .res - .assets - .registry - .default_state(&format!("minecraft:{name}")) - .or_else(|| info.and_then(|i| i.block))?; - let models = self - .res - .assets - .model_catalog - .collect(block, horizon_core::position::BlockPos::new(0, 0, 0)) - .ok()?; - let mut faces: HashMap = HashMap::new(); - for (_, m) in &models { - for f in &m.faces { - faces - .entry(f.quad.facing as usize) - .or_insert((f.layer, f.quad.tint_index)); - } - } - use horizon_assets::model::Direction as D; - let get = |d: D| { - faces - .get(&(d as usize)) - .and_then(|(l, _)| self.res.layer_names.get(l)) - .cloned() - }; - let top = get(D::Up)?; - let tinted = faces.get(&(D::Up as usize)).is_some_and(|(_, t)| *t >= 0); - let tint = if tinted { - if name.contains("leaves") || name == "vine" { - 0x48B518 - } else { - 0x91BD59 - } - } else { - 0xFFFFFF - }; - return Some(Icon::Cube { - left: get(D::South).unwrap_or(top.clone()), - right: get(D::East).unwrap_or(top.clone()), - top, - tint, - }); - } - textures - .get("layer0") - .or_else(|| textures.get("all")) - .or_else(|| textures.get("texture")) - .and_then(|t| t.as_str()) - .map(|t| Icon::Flat(t.trim_start_matches("minecraft:").to_owned())) - } fn draw_item(&mut self, batch: &mut HudBatch, stack: &ItemStack, x: f32, y: f32) { - // Special-model items: the shield and banners draw their own 3D icon. - let banner = if &*stack.item == "minecraft:shield" { - let passes = shield::shield_passes(&self.res.stations.banners, stack); - shield::draw_shield_icon(batch, &self.res.atlas, x, y, &passes); - true - } else { - self.draw_banner_icon(batch, stack, x, y) - }; - let icon = if banner { None } else { self.icon(&stack.item) }; + // `GuiGraphics.renderItem`: the resolved item model (tints, foil and + // special renderers included), then the decorations. + self.draw_item_model(batch, stack, x, y); let atlas = &self.res.atlas; - match icon { - None if banner => {} - Some(Icon::Flat(name)) => batch.sprite_scaled(atlas, &name, x, y, 16.0, 16.0, u32::MAX), - Some(Icon::Cube { - top, - left, - right, - tint, - }) => { - let color = |b: f32| { - let c = |s: u32| (((tint >> s) & 255) as f32 * b) as u8; - rgba(c(16), c(8), c(0), 255) - }; - let (cx, top_y) = (x + 8.0, y + 1.0); - let quad = |batch: &mut HudBatch, name: &str, p: [[f32; 2]; 4], c: u32| { - if let Some(r) = atlas.sprites.get(name).copied() { - batch.quad( - p, - [[r.u0, r.v0], [r.u1, r.v0], [r.u1, r.v1], [r.u0, r.v1]], - c, - ); - } - }; - let (w, h) = (7.0, 3.6); - quad( - batch, - &top, - [ - [cx, top_y], - [cx + w, top_y + h], - [cx, top_y + 2.0 * h], - [cx - w, top_y + h], - ], - color(1.0), - ); - let side = 8.0; - quad( - batch, - &left, - [ - [cx - w, top_y + h], - [cx, top_y + 2.0 * h], - [cx, top_y + 2.0 * h + side], - [cx - w, top_y + h + side], - ], - color(0.8), - ); - quad( - batch, - &right, - [ - [cx, top_y + 2.0 * h], - [cx + w, top_y + h], - [cx + w, top_y + h + side], - [cx, top_y + 2.0 * h + side], - ], - color(0.6), - ); - } - None => batch.fill(atlas, x + 2.0, y + 2.0, 12.0, 12.0, rgba(200, 0, 200, 255)), - } - self.draw_potion_layers(batch, stack, x, y); - self.draw_glint(batch, stack, x, y); if stack.count > 1 { let text = stack.count.to_string(); let w = HudBatch::text_width(atlas, &text); @@ -4234,147 +3981,8 @@ impl Game<'_> { /// ItemEntityRenderer: items bob and spin; blocks render as small cubes. fn entity_geometry(&mut self, camera: glam::DVec3, alpha: f64) -> Vec { let mut out = Vec::new(); - let items = self.dropped.clone(); - for item in &items { - let p = item.previous; - let q = item.position; - let pos = glam::DVec3::new( - p.x + (q.x - p.x) * alpha, - p.y + (q.y - p.y) * alpha, - p.z + (q.z - p.z) * alpha, - ) - camera; - if pos.length_squared() > 64.0 * 64.0 { - continue; - } - let age = item.age as f32 + alpha as f32; - let bob = (age / 10.0 + item.bob_offset).sin() * 0.1 + 0.1; - let spin = age / 20.0 + item.bob_offset; - let light = self.world.light( - q.x.floor() as i32, - (q.y + 0.1).floor() as i32, - q.z.floor() as i32, - ); - let packed = (u32::from(light >> 4) * 16) | ((u32::from(light & 15) * 16) << 8); - let center = pos.as_vec3() + glam::Vec3::new(0.0, bob + 0.125, 0.0); - let rot = glam::Mat3::from_rotation_y(spin); - let icon = self.icon(&item.stack.item); - let atlas = &self.res.atlas; - let mut quad = |corners: [glam::Vec3; 4], name: &str, shade: f32, tint: u32| { - let Some(r) = atlas.sprites.get(name).copied() else { - return; - }; - let uv = [[r.u0, r.v1], [r.u1, r.v1], [r.u1, r.v0], [r.u0, r.v0]]; - let c = |sft: u32| (((tint >> sft) & 255) as f32 * shade) as u32; - let color = 0xFF00_0000 | c(0) << 16 | c(8) << 8 | c(16); - for (corner, uv) in corners.iter().zip(uv) { - let v = center + rot * *corner; - out.push(Vertex { - pos: v.to_array(), - uv, - layer: 0, - color, - light: packed, - }); - } - }; - let copies = match item.stack.count { - 0..=1 => 1, - 2..=16 => 2, - 17..=32 => 3, - _ => 4, - }; - for k in 0..copies { - let o = glam::Vec3::new(k as f32 * 0.03, k as f32 * 0.03, k as f32 * 0.05); - match &icon { - Some(Icon::Cube { - top, - left, - right, - tint, - }) => { - let h = 0.125; - let v = |x: f32, y: f32, z: f32| glam::Vec3::new(x * h, y * h, z * h) + o; - quad( - [ - v(-1., 1., 1.), - v(1., 1., 1.), - v(1., 1., -1.), - v(-1., 1., -1.), - ], - top, - 1.0, - *tint, - ); - quad( - [ - v(-1., -1., -1.), - v(1., -1., -1.), - v(1., -1., 1.), - v(-1., -1., 1.), - ], - top, - 0.5, - *tint, - ); - quad( - [ - v(-1., -1., 1.), - v(1., -1., 1.), - v(1., 1., 1.), - v(-1., 1., 1.), - ], - left, - 0.8, - 0xFFFFFF, - ); - quad( - [ - v(1., -1., -1.), - v(-1., -1., -1.), - v(-1., 1., -1.), - v(1., 1., -1.), - ], - left, - 0.8, - 0xFFFFFF, - ); - quad( - [ - v(1., -1., 1.), - v(1., -1., -1.), - v(1., 1., -1.), - v(1., 1., 1.), - ], - right, - 0.6, - 0xFFFFFF, - ); - quad( - [ - v(-1., -1., -1.), - v(-1., -1., 1.), - v(-1., 1., 1.), - v(-1., 1., -1.), - ], - right, - 0.6, - 0xFFFFFF, - ); - } - Some(Icon::Flat(name)) => { - let h = 0.25; - let v = |x: f32, y: f32| glam::Vec3::new(x * h, y * h + 0.125, 0.0) + o; - quad( - [v(-1., -1.), v(1., -1.), v(1., 1.), v(-1., 1.)], - name, - 1.0, - 0xFFFFFF, - ); - } - None => {} - } - } - } + // `ItemEntityRenderer`. + self.dropped_item_geometry(camera, alpha, &mut out); // Mobs and their projectiles. self.mob_geometry(camera, alpha, &mut out); self.player_model_geometry(camera, alpha, &mut out); @@ -6507,67 +6115,6 @@ impl Game<'_> { self.hand_item = held; } } - fn display_transform(&mut self, item: &str) -> Option<([f32; 3], [f32; 3], [f32; 3])> { - if let Some(d) = self.res.displays.get(item) { - return *d; - } - let root = &self.options.resources; - let name = item.trim_start_matches("minecraft:"); - let model_name = self.res.items.get(item).map_or(name.to_owned(), |i| { - i.model.trim_start_matches("minecraft:").to_owned() - }); - let mut found = None; - let def: Option = - std::fs::read(root.join(format!("assets/minecraft/items/{model_name}.json"))) - .ok() - .and_then(|b| serde_json::from_slice(&b).ok()); - let mut current = def.and_then(|d| { - fn first(v: &serde_json::Value) -> Option { - match v { - serde_json::Value::Object(o) => { - if o.get("type").and_then(|t| t.as_str()) == Some("minecraft:model") { - return o.get("model").and_then(|m| m.as_str()).map(str::to_owned); - } - o.values().find_map(first) - } - serde_json::Value::Array(a) => a.iter().find_map(first), - _ => None, - } - } - first(&d["model"]) - }); - if item.ends_with("_banner") { - // The banner item model is a special renderer over this base model. - current = Some("minecraft:item/template_banner".to_owned()); - } - for _ in 0..16 { - let Some(m) = current.take() else { break }; - let path = m.trim_start_matches("minecraft:").to_owned(); - let Some(model) = - std::fs::read(root.join(format!("assets/minecraft/models/{path}.json"))) - .ok() - .and_then(|b| serde_json::from_slice::(&b).ok()) - else { - break; - }; - let d = &model["display"]["firstperson_righthand"]; - if d.is_object() { - let v = |k: &str, default: f32| -> [f32; 3] { - let a = d[k].as_array(); - std::array::from_fn(|i| { - a.and_then(|a| a.get(i)) - .and_then(|x| x.as_f64()) - .map_or(default, |x| x as f32) - }) - }; - found = Some((v("rotation", 0.0), v("translation", 0.0), v("scale", 1.0))); - break; - } - current = model["parent"].as_str().map(str::to_owned); - } - self.res.displays.insert(item.to_owned(), found); - found - } /// FirstPersonHandsAndItemsRenderer: the right arm or held item in view /// space, converted to camera-relative world space. fn hand_geometry(&mut self, alpha: f64) -> Vec { @@ -6663,115 +6210,39 @@ impl Game<'_> { ); } Some(stack) => { - let display = self - .display_transform(&stack.item) - .unwrap_or(([0.0; 3], [0.0; 3], [1.0; 3])); - let icon = self.icon(&stack.item); // applyItemArmTransform + swingArm (applyItemArmAttackTransform) let x = -0.4 * (sqrt_attack * std::f32::consts::PI).sin(); let y = 0.2 * (sqrt_attack * std::f32::consts::TAU).sin(); let z = -0.2 * (attack * std::f32::consts::PI).sin(); let y_swing_rot = (attack * attack * std::f32::consts::PI).sin(); let xz_swing_rot = (sqrt_attack * std::f32::consts::PI).sin(); - let (rot, trans, scale) = display; let m = to_world - * glam::Mat4::from_translation(glam::Vec3::new(0.56, -0.52 + inverse_height * -0.6, -0.72)) + * glam::Mat4::from_translation(glam::Vec3::new( + 0.56, + -0.52 + inverse_height * -0.6, + -0.72, + )) * glam::Mat4::from_translation(glam::Vec3::new(x, y, z)) * glam::Mat4::from_rotation_y(deg(45.0 + y_swing_rot * -20.0)) * glam::Mat4::from_rotation_z(deg(xz_swing_rot * -20.0)) * glam::Mat4::from_rotation_x(deg(xz_swing_rot * -80.0)) - * glam::Mat4::from_rotation_y(deg(-45.0)) - // ItemTransform.apply: translation is in sixteenths, rotation XYZ, then scale. - * glam::Mat4::from_translation(glam::Vec3::from(trans) / 16.0) - * glam::Mat4::from_quat(glam::Quat::from_euler(glam::EulerRot::XYZ, deg(rot[0]), deg(rot[1]), deg(rot[2]))) - * glam::Mat4::from_scale(glam::Vec3::from(scale)) - * glam::Mat4::from_translation(glam::Vec3::splat(-0.5)); - if self.held_banner_geometry(m, &stack, packed, &mut out) { - return out; - } - let atlas = &self.res.atlas; - let quad = |corners: [glam::Vec3; 4], - name: &str, - shade: f32, - tint: u32, - out: &mut Vec| { - let Some(r) = atlas.sprites.get(name).copied() else { - return; - }; - let uv = [[r.u0, r.v1], [r.u1, r.v1], [r.u1, r.v0], [r.u0, r.v0]]; - let c = |sft: u32| (((tint >> sft) & 255) as f32 * shade) as u32; - let color = 0xFF00_0000 | c(0) << 16 | c(8) << 8 | c(16); - for (p, uv) in corners.iter().zip(uv) { - out.push(Vertex { - pos: m.transform_point3(*p).to_array(), - uv, - layer: 0, - color, - light: packed, - }); - } - }; - let v = glam::Vec3::new; - match icon { - Some(Icon::Cube { - top, - left, - right, - tint, - }) => { - quad( - [v(0., 1., 1.), v(1., 1., 1.), v(1., 1., 0.), v(0., 1., 0.)], - &top, - 1.0, - tint, - &mut out, - ); - quad( - [v(0., 0., 1.), v(1., 0., 1.), v(1., 1., 1.), v(0., 1., 1.)], - &left, - 0.8, - 0xFFFFFF, - &mut out, - ); - quad( - [v(1., 0., 0.), v(0., 0., 0.), v(0., 1., 0.), v(1., 1., 0.)], - &left, - 0.8, - 0xFFFFFF, - &mut out, - ); - quad( - [v(1., 0., 1.), v(1., 0., 0.), v(1., 1., 0.), v(1., 1., 1.)], - &right, - 0.6, - 0xFFFFFF, - &mut out, - ); - quad( - [v(0., 0., 0.), v(0., 0., 1.), v(0., 1., 1.), v(0., 1., 0.)], - &right, - 0.6, - 0xFFFFFF, - &mut out, - ); - } - Some(Icon::Flat(name)) => { - // Generated item models are a sprite on the z = 8/16 plane. - quad( - [ - v(0., 0., 0.5), - v(1., 0., 0.5), - v(1., 1., 0.5), - v(0., 1., 0.5), - ], - &name, - 1.0, - 0xFFFFFF, - &mut out, - ); - } - None => {} - } + * glam::Mat4::from_rotation_y(deg(-45.0)); + // `ItemInHandRenderer.renderItem`: the player as owner, seeded by + // its id plus the display context ordinal. + let owner = self.player_owner(Some(&stack)); + let context = horizon_assets::item_model::DisplayContext::FirstPersonRightHand; + let state = self.resolve_item(&stack, context, Some(&owner), 4); + let light = self.world.light( + eye[0].floor() as i32, + eye[1].floor() as i32, + eye[2].floor() as i32, + ); + self.submit_item_world( + &state, + m, + horizon_client::block_entity_render::vertex_light(light), + &mut out, + ); } } out @@ -8386,7 +7857,7 @@ pub fn run() -> Result<()> { biomes, environment, atlas, - icons: HashMap::new(), + item_renderer: Arc::new(horizon_client::item_render::ItemRenderer::load(&root)?), layer_names, providers: Providers::load(&root), block_entity_render: horizon_client::block_entity_render::BlockEntityRenderer::load( @@ -8424,7 +7895,6 @@ pub fn run() -> Result<()> { player_type: perspective::player_type(&root), player_arm: horizon_client::mobs::load_model(&root, "minecraft:player#main") .and_then(|m| m.children.into_iter().find(|c| c.name == "right_arm")), - displays: HashMap::new(), }; let inventory = vec![None; 36]; let now = Instant::now(); diff --git a/crates/horizon-client/src/game/armor_stands.rs b/crates/horizon-client/src/game/armor_stands.rs index 5fff87c9d..abf17b545 100644 --- a/crates/horizon-client/src/game/armor_stands.rs +++ b/crates/horizon-client/src/game/armor_stands.rs @@ -415,6 +415,8 @@ impl Game<'_> { pose[5] = deg(rot[2]); } } + // Item layers pose from the hidden arms too (`visible` only skips drawing). + let posed = poses.clone(); let mut hide = |name: &str| { if poses.has(name) { let pose = poses.get(name); @@ -446,6 +448,7 @@ impl Game<'_> { 0, out, ); + self.armor_stand_items(a, model, base, &posed, packed, out); // HumanoidArmorLayer: head, chest, legs, feet. for (slot, layer) in [ (5usize, "helmet"), @@ -562,3 +565,120 @@ impl Game<'_> { true } } +impl Game<'_> { + /// `ItemInHandLayer` and `CustomHeadLayer` of an armour stand: the hand + /// items in the third-person contexts, and a non-armour head item on the + /// head (`translateToHead`: down a quarter, turned, 0.625 scale). + fn armor_stand_items( + &self, + a: &ArmorStand, + model: &Part, + base: glam::Mat4, + poses: &Poses, + light: u32, + out: &mut Vec, + ) { + use horizon_assets::item_model::DisplayContext; + use horizon_client::mobs::render::part_matrix; + let owner = super::item_draw::owner_at( + [a.position.x, a.position.y, a.position.z], + a.yaw, + "minecraft:armor_stand", + ); + // `useBabyOffset`: small stands use the baby hand offsets. + let (ox, oy, oz) = if a.small { + (0.0, 1.0, -4.5) + } else { + (1.0, 2.0, -10.0) + }; + for (slot, left, context) in [ + (0usize, false, DisplayContext::ThirdPersonRightHand), + (1, true, DisplayContext::ThirdPersonLeftHand), + ] { + let Some(stack) = &a.equipment[slot] else { + continue; + }; + let arm = if left { "left_arm" } else { "right_arm" }; + let Some(hand) = part_matrix(model, base, poses, arm, 0.0) else { + continue; + }; + let pose = hand + * glam::Mat4::from_rotation_x((-90.0f32).to_radians()) + * glam::Mat4::from_rotation_y(std::f32::consts::PI) + * glam::Mat4::from_translation(glam::Vec3::new( + if left { -ox } else { ox } / 16.0, + oy / 16.0, + oz / 16.0, + )); + let seed = a.id as i32 + if left { 1 } else { 2 }; + let state = self.resolve_item(stack, context, Some(&owner), seed); + self.submit_item_world(&state, pose, light, out); + } + // `CustomHeadLayer`: a worn skull draws the skull model. + if let Some(stack) = &a.equipment[5] + && let Some(kind) = skull_kind(&stack.item) + && let Some(head) = part_matrix(model, base, poses, "head", 0.0) + { + let pose = head * glam::Mat4::from_scale(glam::Vec3::splat(1.1875)); + let special = horizon_assets::item_model::SpecialModel { + kind: if kind == "player" { + horizon_assets::item_model::SpecialKind::PlayerHead + } else { + horizon_assets::item_model::SpecialKind::Head { + kind: kind.to_owned(), + texture: None, + animation: 0.0, + } + }, + }; + let mut sink = horizon_client::item_render::WorldSink { + out, + light, + lights: Some(horizon_client::block_entity_render::diffuse_lights( + self.dim == super::Dim::Nether, + )), + }; + self.res.item_renderer.submit_special( + &special, + &serde_json::Value::Null, + false, + pose, + &self.res.atlas.sprites, + &self.item_host(), + &mut sink, + ); + return; + } + // A head item that is not worn armour. + if let Some(stack) = &a.equipment[5] + && self + .res + .items + .get(&stack.item) + .is_none_or(|i| i.equip_asset.is_none()) + && let Some(head) = part_matrix(model, base, poses, "head", 0.0) + { + let pose = head + * glam::Mat4::from_translation(glam::Vec3::new(0.0, -0.25, 0.0)) + * glam::Mat4::from_rotation_y(std::f32::consts::PI) + * glam::Mat4::from_scale(glam::Vec3::new(0.625, -0.625, -0.625)); + // `updateForLiving`: seeded by the entity id plus HEAD's ordinal. + let state = + self.resolve_item(stack, DisplayContext::Head, Some(&owner), a.id as i32 + 5); + self.submit_item_world(&state, pose, light, out); + } + } +} +/// `AbstractSkullBlock.getType` of a skull item. +fn skull_kind(item: &str) -> Option<&'static str> { + Some(match item { + "minecraft:skeleton_skull" => "skeleton", + "minecraft:wither_skeleton_skull" => "wither_skeleton", + "minecraft:zombie_head" => "zombie", + "minecraft:creeper_head" => "creeper", + "minecraft:dragon_head" => "dragon", + "minecraft:piglin_head" => "piglin", + "minecraft:player_head" => "player", + _ => return None, + }) +} diff --git a/crates/horizon-client/src/game/banners.rs b/crates/horizon-client/src/game/banners.rs index b9f701a0c..d767dc9b8 100644 --- a/crates/horizon-client/src/game/banners.rs +++ b/crates/horizon-client/src/game/banners.rs @@ -2,14 +2,10 @@ //! banner item to the block when placed and back to the dropped item when //! broken (`copy_components` in the banner loot tables). use super::Game; -use glam::{EulerRot, Mat4, Quat, Vec3}; use horizon_client::{ banner::{self, BannerLayer}, - block_entity_render::{Paint, draw_part}, containers::{Banner, BlockEntity}, - hud::{HudBatch, rgba}, items::ItemStack, - mesher::Vertex, }; impl Game<'_> { @@ -34,161 +30,6 @@ impl Game<'_> { b.name = stack.custom_name().map(str::to_owned); } } - /// A banner in a slot: `item/template_banner`'s `gui` transform on the - /// banner model (pole, bar and flag with every layer), flat-lit and - /// depth-sorted. False when the stack is not a banner. - pub(super) fn draw_banner_icon( - &self, - batch: &mut HudBatch, - stack: &ItemStack, - x: f32, - y: f32, - ) -> bool { - let Some(base) = banner::banner_color(&stack.item) else { - return false; - }; - let Some((main, flag)) = self.res.block_entity_render.banner_models() else { - return true; - }; - let banners = &self.res.stations.banners; - let sprites = &self.res.atlas.sprites; - // display.gui, then the item's special transformation (a banner is - // modelled upside down and 2/3 size around the block centre). - let m = Mat4::from_translation(Vec3::new(0.0, -3.25 / 16.0, 0.0)) - * Mat4::from_quat(Quat::from_euler( - EulerRot::XYZ, - 30f32.to_radians(), - 20f32.to_radians(), - 0.0, - )) - * Mat4::from_scale(Vec3::splat(0.5325)) - * Mat4::from_translation(Vec3::new(0.0, -0.5, 0.0)) - * Mat4::from_scale(Vec3::new(2.0 / 3.0, -2.0 / 3.0, -2.0 / 3.0)); - let wave = |name: &str, p: &mut [f32; 9]| { - if name == "flag" { - p[3] = (-0.0125 + 0.01) * std::f32::consts::PI; - } - }; - let none = |_: &str, _: &mut [f32; 9]| {}; - let mut passes: Vec<(&str, u32, bool, String)> = vec![ - ("entity/banner/banner_base", 0xFFFFFF, true, String::new()), - ( - "entity/banner/base", - banner::dye_rgb(base), - false, - String::new(), - ), - ]; - for layer in banner::layers(stack).iter().take(16) { - passes.push(( - "", - banner::dye_rgb(&layer.color), - false, - banners.banner_texture(&layer.pattern), - )); - } - // (depth, pass, screen corners, uv, colour) - let mut faces: Vec<(f32, usize, [[f32; 2]; 4], [[f32; 2]; 4], u32)> = Vec::new(); - for (index, (fixed, tint, with_pole, dynamic)) in passes.iter().enumerate() { - let name = if fixed.is_empty() { - dynamic.as_str() - } else { - fixed - }; - let Some(sprite) = sprites.get(name).copied() else { - continue; - }; - let paint = Paint { - sprite, - tint: 0xFFFFFF, - light: 0, - lights: (Vec3::ZERO, Vec3::ZERO), - }; - let mut verts: Vec = Vec::new(); - if *with_pole { - draw_part(main, "root", m, &none, paint, &mut verts); - } - draw_part(flag, "root", m, &wave, paint, &mut verts); - for quad in verts.as_chunks::<4>().0 { - let p = |i: usize| Vec3::from(quad[i].pos); - let normal = (p(1) - p(0)).cross(p(2) - p(0)).normalize_or_zero(); - // Faces turned away from the viewer are culled. - if normal.z <= 0.0 { - continue; - } - let depth = (0..4).map(|i| p(i).z).sum::() / 4.0; - let shade = (0.6 + 0.4 * normal.z).min(1.0); - let c = |s: u32| (((tint >> s) & 255) as f32 * shade) as u8; - faces.push(( - depth, - index, - std::array::from_fn(|i| { - [ - x + 8.0 + quad[i].pos[0] * 16.0, - y + 8.0 - quad[i].pos[1] * 16.0, - ] - }), - std::array::from_fn(|i| quad[i].uv), - rgba(c(16), c(8), c(0), 255), - )); - } - } - faces.sort_by(|a, b| a.0.total_cmp(&b.0).then(a.1.cmp(&b.1))); - for (_, _, corners, uv, color) in faces { - batch.quad(corners, uv, color); - } - true - } - /// A banner in the first-person hand: the standing banner model under the - /// item's `firstperson_righthand` transform (`m`) and its special - /// transformation. False when the stack is not a banner. - pub(super) fn held_banner_geometry( - &self, - m: Mat4, - stack: &ItemStack, - packed: u32, - out: &mut Vec, - ) -> bool { - let Some(base) = banner::banner_color(&stack.item) else { - return false; - }; - let Some((main, flag)) = self.res.block_entity_render.banner_models() else { - return true; - }; - let m = m - * Mat4::from_translation(Vec3::new(0.5, 0.0, 0.5)) - * Mat4::from_scale(Vec3::new(2.0 / 3.0, -2.0 / 3.0, -2.0 / 3.0)); - let wave = |name: &str, p: &mut [f32; 9]| { - if name == "flag" { - p[3] = (-0.0125 + 0.01) * std::f32::consts::PI; - } - }; - let none = |_: &str, _: &mut [f32; 9]| {}; - let lights = horizon_client::block_entity_render::diffuse_lights(false); - let sprites = &self.res.atlas.sprites; - let paint = |name: &str, tint: u32| { - sprites.get(name).map(|&sprite| Paint { - sprite, - tint, - light: packed, - lights, - }) - }; - if let Some(p) = paint("entity/banner/banner_base", 0xFFFFFF) { - draw_part(main, "root", m, &none, p, out); - draw_part(flag, "root", m, &wave, p, out); - } - if let Some(p) = paint("entity/banner/base", banner::dye_rgb(base)) { - draw_part(flag, "root", m, &wave, p, out); - } - for layer in banner::layers(stack).iter().take(16) { - let texture = self.res.stations.banners.banner_texture(&layer.pattern); - if let Some(p) = paint(&texture, banner::dye_rgb(&layer.color)) { - draw_part(flag, "root", m, &wave, p, out); - } - } - true - } /// The layers a banner dropped at `pos` carries. pub(super) fn attach_banner_layers(&mut self, pos: [i32; 3], stack: &mut ItemStack) { if !stack.item.ends_with("_banner") { diff --git a/crates/horizon-client/src/game/creatures.rs b/crates/horizon-client/src/game/creatures.rs index 26c1bf86f..792a07539 100644 --- a/crates/horizon-client/src/game/creatures.rs +++ b/crates/horizon-client/src/game/creatures.rs @@ -718,7 +718,6 @@ impl Game<'_> { self.mobs.append(&mut mobs); self.sync_riders(); self.tick_skeleton_traps(); - self.cache_mob_icons(); self.tick_apparition(); self.villager_reputation_tick(); self.villager_pickups(); diff --git a/crates/horizon-client/src/game/frames.rs b/crates/horizon-client/src/game/frames.rs index 269a4958c..5d80a424b 100644 --- a/crates/horizon-client/src/game/frames.rs +++ b/crates/horizon-client/src/game/frames.rs @@ -2,7 +2,7 @@ //! `ItemFrame.survives`, `interact` (put an item in, then rotate it), //! `hurtServer` (take the item out, then break the frame) and //! `ItemFrameRenderer` (the frame model and the item at a 45 degree step). -use super::{Game, Hit, Icon, view_vector}; +use super::{Game, Hit, view_vector}; use horizon_assets::{bake::bake_model, model::CuboidModel, resolve::ModelLibrary}; use horizon_client::{entities::ItemFrame, items::ItemStack, mesher::Vertex}; use horizon_core::{ @@ -300,17 +300,10 @@ impl Game<'_> { } /// ItemFrameRenderer: the frame model, then the item half size on its face. pub(super) fn frame_geometry(&mut self, camera: glam::DVec3, out: &mut Vec) { - let icons: Vec> = (0..self.item_frames.len()) - .map(|i| { - self.item_frames[i] - .item - .clone() - .and_then(|s| self.icon(&s.item)) - }) - .collect(); let sprites = &self.res.atlas.sprites; let mut maps: Vec<(i32, glam::Mat4, u32)> = Vec::new(); - for (f, icon) in self.item_frames.iter().zip(icons) { + let mut items: Vec<(ItemStack, u32, glam::Mat4, u8)> = Vec::new(); + for f in &self.item_frames { let map = f.item.as_ref().and_then(super::maps::map_id); let s = f.step(); // Pose: to the block centre, then X/Y rotation by facing. @@ -391,89 +384,33 @@ impl Game<'_> { maps.push((id, m.as_mat4(), item_light)); continue; } - let Some(icon) = icon else { continue }; - // GlowItemFrame items render full bright. - let item_light = if f.glow { 240 | 240 << 8 } else { packed }; + let Some(stack) = f.item.clone() else { + continue; + }; + // `GlowItemFrame` items render full bright (15728880). + let item_light = if f.glow { 0xFF } else { light }; let depth = if f.invisible { 0.5 } else { 0.4375 }; let m = pose * glam::DMat4::from_translation(glam::DVec3::new(0.0, 0.0, depth)) * glam::DMat4::from_rotation_z((f64::from(f.rotation) * 45.0).to_radians()) * glam::DMat4::from_scale(glam::DVec3::splat(0.5)); - let full = |r: &horizon_client::hud::Rect| { - [[r.u0, r.v1], [r.u1, r.v1], [r.u1, r.v0], [r.u0, r.v0]] - }; - match icon { - // A flat item faces out of the frame (towards -z here). - Icon::Flat(sprite) => { - if let Some(r) = sprites.get(&sprite) { - let z = -0.03125; - quad( - &m, - [ - [0.5, -0.5, z], - [-0.5, -0.5, z], - [-0.5, 0.5, z], - [0.5, 0.5, z], - ], - full(r), - item_light, - ); - } - } - Icon::Cube { - top, left, right, .. - } => { - let h = 0.25; - let face = |name: &str| sprites.get(name).copied(); - if let (Some(t), Some(l), Some(r)) = (face(&top), face(&left), face(&right)) { - let c = |x: f64, y: f64, z: f64| [x * h, y * h, z * h - h]; - quad( - &m, - [ - c(-1., 1., -1.), - c(1., 1., -1.), - c(1., 1., 1.), - c(-1., 1., 1.), - ], - full(&t), - item_light, - ); - quad( - &m, - [ - c(1., -1., -1.), - c(-1., -1., -1.), - c(-1., 1., -1.), - c(1., 1., -1.), - ], - full(&l), - item_light, - ); - quad( - &m, - [ - c(-1., -1., -1.), - c(-1., -1., 1.), - c(-1., 1., 1.), - c(-1., 1., -1.), - ], - full(&r), - item_light, - ); - quad( - &m, - [ - c(1., -1., 1.), - c(1., -1., -1.), - c(1., 1., -1.), - c(1., 1., 1.), - ], - full(&r), - item_light, - ); - } - } - } + items.push((stack, f.id, m.as_mat4(), item_light)); + } + // `extractRenderState`: FIXED, seeded by the frame entity. + for (stack, id, m, light) in items { + let owner = super::item_draw::owner_at([0.0; 3], 0.0, "minecraft:item_frame"); + let state = self.resolve_item( + &stack, + horizon_assets::item_model::DisplayContext::Fixed, + Some(&owner), + id as i32, + ); + self.submit_item_world( + &state, + m, + horizon_client::block_entity_render::vertex_light(light), + out, + ); } for (id, m, light) in maps { self.map_vertices(id, m, light, out); diff --git a/crates/horizon-client/src/game/item_draw.rs b/crates/horizon-client/src/game/item_draw.rs new file mode 100644 index 000000000..d5a4db677 --- /dev/null +++ b/crates/horizon-client/src/game/item_draw.rs @@ -0,0 +1,373 @@ +//! Items drawn through the resolved item model pipeline +//! (`horizon_client::item_render`): GUI icons (`GuiGraphics.renderItem`), +//! dropped items (`ItemEntityRenderer`) and items posed in the world (hands, +//! frames, armour stands). This binds the resolver's host services +//! (`ItemEnv`) and the special renderers' registries to the game. +use super::{Dim, Game}; +use horizon_assets::item_model::{ + Components, DisplayContext, GlobalPos, ItemEnv, LevelState, OwnerState, StackView, +}; +use horizon_client::{ + block_entity_render::{diffuse_lights, vertex_light}, + hud::HudBatch, + item_render::{self, ItemRenderState, SpecialHost, WorldSink}, + items::ItemStack, + mesher::Vertex, +}; +use serde_json::Value; +use winit::keyboard::KeyCode; + +/// The game's answers to what the resolver cannot read from the stack. +pub(super) struct Env<'a, 'g> { + game: &'a Game<'g>, +} +impl ItemEnv for Env<'_, '_> { + fn potion_effect_color(&self, contents: &Value) -> Option { + // `PotionContents.getColorOr`: the effect mix when any effect is visible. + let id = contents["potion"].as_str(); + let effects = id + .and_then(horizon_client::brewing::potion) + .is_some_and(|p| !p.effects.is_empty()); + effects.then(|| (0xFF00_0000 | horizon_client::brewing::potion_color(id)) as i32) + } + fn grass_color(&self, temperature: f64, downfall: f64) -> i32 { + self.game + .res + .item_renderer + .grass_color(temperature, downfall) + } + fn bundle_fullness(&self, _stack: &StackView, components: &Components) -> f32 { + // `BundleContents.weight`: count / max stack size, summed. + let Some(items) = components + .get("minecraft:bundle_contents") + .and_then(Value::as_array) + else { + return 0.0; + }; + let prototypes = &self.game.res.item_renderer.models.prototypes; + let mut total = 0.0f64; + for item in items { + let id = item["id"].as_str().unwrap_or(""); + let count = item["count"].as_i64().unwrap_or(1) as f64; + let max = prototypes + .get(id) + .and_then(|c| c.get("minecraft:max_stack_size")) + .and_then(Value::as_i64) + .unwrap_or(1) as f64; + total += count / max; + } + total as f32 + } + fn has_shift_down(&self) -> bool { + self.game.keys.contains(&KeyCode::ShiftLeft) + || self.game.keys.contains(&KeyCode::ShiftRight) + } + fn local_time(&self, pattern: &str, _locale: &str, _time_zone: Option<&str>) -> String { + local_time(pattern) + } + fn random_float(&self) -> f32 { + let nanos = self.game.started.elapsed().subsec_nanos(); + (nanos % 1_000_000) as f32 / 1_000_000.0 + } +} +/// The days since 1970-01-01 as a civil (year, month, day) date. +fn civil(days: i64) -> (i64, u32, u32) { + let z = days + 719_468; + let era = z.div_euclid(146_097); + let doe = z.rem_euclid(146_097); + let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365; + let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); + let mp = (5 * doy + 2) / 153; + let d = (doy - (153 * mp + 2) / 5 + 1) as u32; + let m = if mp < 10 { mp + 3 } else { mp - 9 } as u32; + (yoe + era * 400 + i64::from(m <= 2), m, d) +} +/// `DateTimeFormatter.ofPattern(pattern).format(now)` for the month, day, +/// year and time letters item models use (UTC: no time zone database). +pub(super) fn local_time(pattern: &str) -> String { + let secs = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map_or(0, |d| d.as_secs() as i64); + let (y, mo, d) = civil(secs.div_euclid(86_400)); + let s = secs.rem_euclid(86_400); + let (h, mi, se) = (s / 3600, s / 60 % 60, s % 60); + let mut out = String::new(); + let chars: Vec = pattern.chars().collect(); + let mut i = 0; + while i < chars.len() { + let c = chars[i]; + let mut n = 1; + while i + n < chars.len() && chars[i + n] == c { + n += 1; + } + let num = |v: i64| format!("{v:0n$}"); + match c { + 'M' => out += &num(i64::from(mo)), + 'd' => out += &num(i64::from(d)), + 'y' | 'u' => out += &if n == 2 { num(y % 100) } else { num(y) }, + 'H' => out += &num(h), + 'm' => out += &num(mi), + 's' => out += &num(se), + '\'' => { + // Quoted literal text. + let end = chars[i + 1..].iter().position(|&x| x == '\''); + if let Some(e) = end { + out.extend(&chars[i + 1..i + 1 + e]); + i += e + 2; + continue; + } + n = 1; + } + other => out.extend(std::iter::repeat_n(other, n)), + } + i += n; + } + out +} + +/// Banner and shield pattern textures from the banner pattern registry. +pub(super) struct Host<'a> { + banners: &'a horizon_client::banner::Banners, +} +impl SpecialHost for Host<'_> { + fn banner_texture(&self, pattern: &str) -> Option { + self.banners + .pattern(pattern) + .map(|_| self.banners.banner_texture(pattern)) + } + fn shield_texture(&self, pattern: &str) -> Option { + self.banners + .pattern(pattern) + .map(|_| self.banners.shield_texture(pattern)) + } +} + +/// `ItemOwner` of an entity holding or showing an item. +pub(super) fn owner_at(position: [f64; 3], yaw: f32, entity_type: &str) -> OwnerState { + OwnerState { + position, + visual_rotation_y_degrees: yaw, + entity_type: entity_type.to_owned(), + ..Default::default() + } +} +/// `UseDuration` of a stack: 72000 for drawn items, the consume time for food. +fn use_duration(components: &Components) -> i32 { + if let Some(c) = components.get("minecraft:consumable") { + let seconds = c["consume_seconds"].as_f64().unwrap_or(1.6); + return (seconds * 20.0) as i32; + } + let item_model = components + .get("minecraft:item_model") + .and_then(Value::as_str) + .unwrap_or(""); + match item_model { + "minecraft:bow" + | "minecraft:crossbow" + | "minecraft:trident" + | "minecraft:spyglass" + | "minecraft:goat_horn" + | "minecraft:brush" => 72_000, + _ => 0, + } +} + +impl Game<'_> { + pub(super) fn item_env(&self) -> Env<'_, '_> { + Env { game: self } + } + pub(super) fn item_host(&self) -> Host<'_> { + Host { + banners: &self.res.stations.banners, + } + } + /// The client level as item models read it. + pub(super) fn item_level(&self) -> LevelState { + let dimension = match self.dim { + Dim::Overworld => "minecraft:overworld", + Dim::Nether => "minecraft:the_nether", + Dim::End => "minecraft:the_end", + }; + let sky = self + .dim_environment() + .sample(self.world.day_time, None, None); + LevelState { + dimension: dimension.to_owned(), + game_time: self.world.game_time, + sun_angle: sky.sun_angle, + moon_phase: (self.world.day_time.div_euclid(24_000)).rem_euclid(8) as i32, + respawn: self.spawn.map(|s| GlobalPos { + dimension: "minecraft:overworld".to_owned(), + pos: [s.x.floor() as i32, s.y.floor() as i32, s.z.floor() as i32], + }), + runs_normally: true, + } + } + /// The local player as `ItemOwner`; `stack` is the stack drawn, to tell + /// whether it is the one in use. + pub(super) fn player_owner(&self, stack: Option<&ItemStack>) -> OwnerState { + let position = self + .player + .as_ref() + .map_or([0.0; 3], |p| [p.position.x, p.position.y, p.position.z]); + let mut owner = owner_at(position, self.yaw, "minecraft:player"); + owner.main_arm_left = self.settings.main_hand_left; + owner.is_local_player = true; + owner.is_view_entity = true; + if let (Some((slot, ticks)), Some(stack)) = (self.using, stack) + && self.inventory.get(slot).and_then(Option::as_ref) == Some(stack) + { + let view = item_render::stack_view(stack); + let duration = use_duration(&self.res.item_renderer.models.components(&view)); + owner.using_this_item = true; + owner.use_duration = duration; + owner.use_item_remaining_ticks = duration - ticks as i32; + owner.crossbow_charge_duration = 25; + } + owner.is_selected = + stack.is_some() && self.inventory.get(self.selected).and_then(Option::as_ref) == stack; + owner.is_carried = owner.is_selected; + owner + } + /// `ItemModelResolver.updateForTopItem`. + pub(super) fn resolve_item( + &self, + stack: &ItemStack, + display: DisplayContext, + owner: Option<&OwnerState>, + seed: i32, + ) -> ItemRenderState { + let level = self.item_level(); + self.res.item_renderer.resolve( + &item_render::stack_view(stack), + display, + owner, + Some(&level), + seed, + &self.item_env(), + ) + } + /// `GuiGraphics.renderItem(player, level, stack, x, y, 0)`. + pub(super) fn draw_item_model(&self, batch: &mut HudBatch, stack: &ItemStack, x: f32, y: f32) { + let owner = self.player_owner(Some(stack)); + let state = self.resolve_item(stack, DisplayContext::Gui, Some(&owner), 0); + item_render::gui::draw( + &state, + &self.res.item_renderer, + &self.res.atlas.sprites, + &self.item_host(), + batch, + x, + y, + self.started.elapsed().as_secs_f32(), + ); + } + /// Submit a resolved item under `pose` (camera-relative) at `light` + /// (packed lightmap coordinates). + pub(super) fn submit_item_world( + &self, + state: &ItemRenderState, + pose: glam::Mat4, + light: u32, + out: &mut Vec, + ) { + let mut sink = WorldSink { + out, + light, + lights: Some(diffuse_lights(self.dim == Dim::Nether)), + }; + state.submit( + &self.res.item_renderer, + &self.res.atlas.sprites, + &self.item_host(), + pose, + &mut sink, + ); + } + /// [`Self::submit_item_world`] without the level's diffuse shading. + pub(super) fn submit_item_unlit( + &self, + state: &ItemRenderState, + pose: glam::Mat4, + light: u32, + out: &mut Vec, + ) { + let mut sink = WorldSink { + out, + light, + lights: None, + }; + state.submit( + &self.res.item_renderer, + &self.res.atlas.sprites, + &self.item_host(), + pose, + &mut sink, + ); + } + /// `ItemEntityRenderer.submit` for every dropped item. + pub(super) fn dropped_item_geometry( + &self, + camera: glam::DVec3, + alpha: f64, + out: &mut Vec, + ) { + for item in &self.dropped { + let (p, q) = (item.previous, item.position); + let pos = glam::DVec3::new( + p.x + (q.x - p.x) * alpha, + p.y + (q.y - p.y) * alpha, + p.z + (q.z - p.z) * alpha, + ) - camera; + if pos.length_squared() > 64.0 * 64.0 { + continue; + } + // `extractItemGroupRenderState`: GROUND, seeded by the entity id. + let owner = owner_at([q.x, q.y, q.z], 0.0, "minecraft:item"); + let state = self.resolve_item( + &item.stack, + DisplayContext::Ground, + Some(&owner), + item.id as i32, + ); + if state.is_empty() { + continue; + } + let age = item.age as f32 + alpha as f32; + let (lo, _) = state.bounding_box(); + let min_offset_y = -lo.y + 0.0625; + let bob = (age / 10.0 + item.bob_offset).sin() * 0.1 + 0.1; + let spin = item_render::item_spin(age, item.bob_offset); + let pose = glam::Mat4::from_translation(pos.as_vec3()) + * glam::Mat4::from_translation(glam::Vec3::new(0.0, bob + min_offset_y, 0.0)) + * glam::Mat4::from_rotation_y(spin); + let packed = self.world.light( + q.x.floor() as i32, + (q.y + 0.1).floor() as i32, + q.z.floor() as i32, + ); + let seed = i64::from(self.res.item_renderer.item_id(&item.stack.item)) + + i64::from(item.stack.damage); + for copy in item_render::cluster_poses( + &state, + pose, + item_render::rendered_amount(item.stack.count), + seed, + ) { + self.submit_item_world(&state, copy, vertex_light(packed), out); + } + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn civil_dates_follow_the_gregorian_calendar() { + assert_eq!(civil(0), (1970, 1, 1)); + assert_eq!(civil(19_716), (2023, 12, 25)); + assert_eq!(civil(11_016), (2000, 2, 29)); + } +} diff --git a/crates/horizon-client/src/game/mob_blocks.rs b/crates/horizon-client/src/game/mob_blocks.rs index b7570ea27..d2fe1f8af 100644 --- a/crates/horizon-client/src/game/mob_blocks.rs +++ b/crates/horizon-client/src/game/mob_blocks.rs @@ -1,8 +1,9 @@ //! Blocks mobs carry: block items in a hand (`ItemInHandLayer`) and the //! block an enderman holds (`CarriedBlockLayer`), drawn as shaded cubes like //! dropped block items. -use super::{Game, Icon}; +use super::Game; use horizon_client::{ + items::ItemStack, mesher::Vertex, mobs::{Mob, Species, render}, }; @@ -176,22 +177,6 @@ impl Game<'_> { render::draw(flag, m, &flag_poses, r, color, light, 0, out); } } - /// Resolve the icons of the items mobs hold, so drawing can look them up. - pub(super) fn cache_mob_icons(&mut self) { - let items: Vec = self - .mobs - .iter() - .filter(|m| m.extra.main_hand.is_some() || m.extra.off_hand.is_some()) - .flat_map(|m| [m.extra.main_hand.clone(), m.extra.off_hand.clone()]) - .flatten() - .map(|i| i.to_string()) - .collect(); - for item in items { - if !self.res.icons.contains_key(&item) { - let _ = self.icon(&item); - } - } - } fn push_cube( &self, t: glam::Mat4, @@ -232,40 +217,7 @@ impl Game<'_> { ) { let overlay = u32::from(mob.hurt_time > 0); self.captain_banner_geometry(mob, camera, alpha, light, out); - for (item, left) in [(&mob.extra.main_hand, false), (&mob.extra.off_hand, true)] { - let Some(item) = item else { continue }; - let Some(Icon::Cube { - top, - left: z, - right: x, - tint, - }) = self.res.icons.get(&**item).cloned().flatten() - else { - continue; - }; - let Some(t) = - render::held_block_transform(mob, alpha as f32, camera, &self.res.mob_data, left) - else { - continue; - }; - let slot = if left { - horizon_client::mobs::gear::OFF - } else { - horizon_client::mobs::gear::MAIN - }; - let glint = horizon_client::mobs::gear::enchanted(mob, slot); - let overlay = if glint { 7 } else { overlay }; - self.push_cube( - t, - &Cube { - sprites: [&top, &z, &x], - tint, - }, - light, - overlay, - out, - ); - } + self.held_item_geometry(mob, camera, alpha, light, true, out); if mob.species() == Species::Enderman && let Some(state) = mob.extra.carried && let Some((sprite, tint)) = self.particle_sprite(state) @@ -292,4 +244,71 @@ impl Game<'_> { ); } } + /// `ItemInHandLayer`: both hands through the item model pipeline; `lit` + /// applies the level's diffuse lighting (off for GUI previews, which + /// light the projected quads themselves). + pub(super) fn held_item_geometry( + &self, + mob: &Mob, + camera: glam::DVec3, + alpha: f64, + light: u32, + lit: bool, + out: &mut Vec, + ) { + let overlay = u32::from(mob.hurt_time > 0); + for (item, left) in [(&mob.extra.main_hand, false), (&mob.extra.off_hand, true)] { + let Some(item) = item else { continue }; + let Some(t) = + render::held_item_transform(mob, alpha as f32, camera, &self.res.mob_data, left) + else { + continue; + }; + let slot = if left { + horizon_client::mobs::gear::OFF + } else { + horizon_client::mobs::gear::MAIN + }; + let mut stack = ItemStack::new(item, 1); + if horizon_client::mobs::gear::enchanted(mob, slot) { + // The gear's enchantments are not tracked, only that it has some. + stack.enchant("minecraft:unbreaking", 1); + } + if &**item == "minecraft:crossbow" && mob.extra.flag2 { + stack.data_mut().charged = vec![ItemStack::new("minecraft:arrow", 1)]; + } + let mut owner = super::item_draw::owner_at( + [mob.position.x, mob.position.y, mob.position.z], + mob.body_yaw, + &mob.kind.id, + ); + if !left && mob.extra.using_item > 0 { + owner.using_this_item = true; + owner.use_duration = 72_000; + owner.use_item_remaining_ticks = 72_000 - mob.extra.using_item; + owner.crossbow_charge_duration = 25; + } + let context = if left { + horizon_assets::item_model::DisplayContext::ThirdPersonLeftHand + } else { + horizon_assets::item_model::DisplayContext::ThirdPersonRightHand + }; + // `updateForLiving`: seeded by the entity id plus the context ordinal. + let seed = mob.id as i32 + if left { 1 } else { 2 }; + let state = self.resolve_item(&stack, context, Some(&owner), seed); + let start = out.len(); + if lit { + self.submit_item_world(&state, t, light, out); + } else { + self.submit_item_unlit(&state, t, light, out); + } + if overlay != 0 { + for v in &mut out[start..] { + if v.layer == 0 { + v.layer = overlay; + } + } + } + } + } } diff --git a/crates/horizon-client/src/game/packs.rs b/crates/horizon-client/src/game/packs.rs index a1f4b8c25..fe438915d 100644 --- a/crates/horizon-client/src/game/packs.rs +++ b/crates/horizon-client/src/game/packs.rs @@ -123,8 +123,10 @@ impl Game<'_> { ); } self.res.atlas = atlas; - self.res.icons.clear(); - self.res.displays.clear(); + match horizon_client::item_render::ItemRenderer::load(&root) { + Ok(r) => self.res.item_renderer = std::sync::Arc::new(r), + Err(e) => eprintln!("Horizon: item model reload failed: {e}"), + } } else { eprintln!( "Horizon: resource pack atlas size changed; restart to apply GUI textures" diff --git a/crates/horizon-client/src/game/perspective.rs b/crates/horizon-client/src/game/perspective.rs index c175733bb..9d4ae7fa6 100644 --- a/crates/horizon-client/src/game/perspective.rs +++ b/crates/horizon-client/src/game/perspective.rs @@ -242,6 +242,7 @@ impl Game<'_> { &self.player_armor_layers(), out, ); + self.held_item_geometry(m, camera, alpha, packed, true, out); } /// `extractEntityInInventoryFollowsMouse`: the player in the box /// `[x0, x1) x [y0, y1)`, `size` pixels per block, turned toward the @@ -295,6 +296,7 @@ impl Game<'_> { &self.player_armor_layers(), &mut verts, ); + self.held_item_geometry(&m, camera, 1.0, 240 | 240 << 8, false, &mut verts); let height = if m.extra.crouching { 1.5 } else { 1.8 }; // PictureInPictureRenderer: the box centre, (size, size, -size); // then the translation and Rz(pi) * Rx(y_angle * 20 degrees). diff --git a/crates/horizon-client/src/game/shield.rs b/crates/horizon-client/src/game/shield.rs index 7857c047e..2821738c5 100644 --- a/crates/horizon-client/src/game/shield.rs +++ b/crates/horizon-client/src/game/shield.rs @@ -244,132 +244,3 @@ impl Game<'_> { } } } - -/// The shield in a slot: `ShieldSpecialRenderer`'s plate and handle boxes -/// under item/shield's `gui` display transform, flat-lit and depth-sorted. -pub(super) fn draw_shield_icon( - batch: &mut horizon_client::hud::HudBatch, - atlas: &horizon_client::hud::HudAtlas, - x: f32, - y: f32, - passes: &[(String, u32)], -) { - // display.gui: rotation [15, -25, -5], translation [2, 3, 0], scale 0.65. - let (sx, cx) = 15f32.to_radians().sin_cos(); - let (sy, cy) = (-25f32).to_radians().sin_cos(); - let (sz, cz) = (-5f32).to_radians().sin_cos(); - // Quaternionf.rotationXYZ: Rx * Ry * Rz. - let rotate = |[x, y, z]: [f32; 3]| { - let (x, y) = (x * cz - y * sz, x * sz + y * cz); - let (x, z) = (x * cy + z * sy, -x * sy + z * cy); - let (y, z) = (y * cx - z * sx, y * sx + z * cx); - [x, y, z] - }; - // Model pixels -> slot pixels: S(1,-1,-1), T(-0.5), S(0.65), R, T, and - // the GUI's (16, -16, 16) around the slot centre. - let place = |[px, py, pz]: [f32; 3]| { - let q = [px / 16.0 - 0.5, -py / 16.0 - 0.5, -pz / 16.0 - 0.5].map(|v| v * 0.65); - let [qx, qy, qz] = rotate(q); - [ - x + 8.0 + (qx + 2.0 / 16.0) * 16.0, - y + 8.0 - (qy + 3.0 / 16.0) * 16.0, - qz, - ] - }; - // ShieldModel: plate texOffs(0, 0) box(-6, -11, -2, 12, 22, 1) and - // handle texOffs(26, 0) box(-1, -3, -1, 2, 6, 6). - let mut faces: Vec<(f32, [[f32; 2]; 4], [[f32; 2]; 4], f32)> = Vec::new(); - for (tu, tv, from, size) in [ - (0.0, 0.0, [-6.0, -11.0, -2.0], [12.0, 22.0, 1.0]), - (26.0, 0.0, [-1.0, -3.0, -1.0], [2.0, 6.0, 6.0]), - ] { - let [w, h, d] = size; - let (x0, y0, z0) = (from[0], from[1], from[2]); - let (x1, y1, z1) = (x0 + w, y0 + h, z0 + d); - let t0 = [x0, y0, z0]; - let t1 = [x1, y0, z0]; - let t2 = [x1, y1, z0]; - let t3 = [x0, y1, z0]; - let l0 = [x0, y0, z1]; - let l1 = [x1, y0, z1]; - let l2 = [x1, y1, z1]; - let l3 = [x0, y1, z1]; - let (u0, u1, u2) = (tu, tu + d, tu + d + w); - let (u22, u3, u4) = (tu + d + w + w, tu + d + w + d, tu + d + w + d + w); - let (v0, v1, v2) = (tv, tv + d, tv + d + h); - // ModelPart.Cube's polygons: (vertices, u0, v0, u1, v1, normal). - for (verts, a, b, c, e, n) in [ - ([l1, l0, t0, t1], u1, v0, u2, v1, [0.0, -1.0, 0.0]), - ([t2, t3, l3, l2], u2, v1, u22, v0, [0.0, 1.0, 0.0]), - ([t0, l0, l3, t3], u0, v1, u1, v2, [-1.0, 0.0, 0.0]), - ([t1, t0, t3, t2], u1, v1, u2, v2, [0.0, 0.0, -1.0]), - ([l1, t1, t2, l2], u2, v1, u3, v2, [1.0, 0.0, 0.0]), - ([l0, l1, l2, l3], u3, v1, u4, v2, [0.0, 0.0, 1.0]), - ] { - let normal = rotate([n[0], -n[1], -n[2]]); - if normal[2] <= 0.0 { - continue; - } - let p = verts.map(place); - let depth = p.iter().map(|q| q[2]).sum::() / 4.0; - let texels = [[c, b], [a, b], [a, e], [c, e]]; - // Flat item lighting: faces toward the viewer are brightest. - let shade = (0.6 + 0.4 * normal[2]).min(1.0); - faces.push((depth, p.map(|q| [q[0], q[1]]), texels, shade)); - } - } - // Every pass redraws the same boxes; equal depths keep the pass order. - let mut quads = Vec::new(); - for (index, (name, tint)) in passes.iter().enumerate() { - let Some(r) = atlas.sprites.get(name).copied() else { - continue; - }; - for (depth, p, texels, shade) in &faces { - let uv = texels.map(|[u, v]| { - [ - r.u0 + (r.u1 - r.u0) * u / 64.0, - r.v0 + (r.v1 - r.v0) * v / 64.0, - ] - }); - let c = |s: u32| (((tint >> s) & 255) as f32 * shade) as u8; - quads.push(( - *depth, - index, - *p, - uv, - horizon_client::hud::rgba(c(16), c(8), c(0), 255), - )); - } - } - quads.sort_by(|a, b| a.0.total_cmp(&b.0).then(a.1.cmp(&b.1))); - for (_, _, p, uv, color) in quads { - batch.quad(p, uv, color); - } -} -/// The textures a shield draws: the plain or patterned base, then the -/// banner layers (`ShieldSpecialRenderer.submit`). -pub(super) fn shield_passes( - banners: &horizon_client::banner::Banners, - stack: &ItemStack, -) -> Vec<(String, u32)> { - let data = stack.data(); - let layers = data.map_or(&[][..], |d| &d.banner_patterns[..]); - let base = data.and_then(|d| d.base_color.as_deref()); - if layers.is_empty() && base.is_none() { - return vec![("entity/shield/shield_base_nopattern".into(), 0xFFFFFF)]; - } - let mut passes = vec![ - ("entity/shield/shield_base".into(), 0xFFFFFF), - ( - "entity/shield/base".into(), - horizon_client::banner::dye_rgb(base.unwrap_or("white")), - ), - ]; - for layer in layers.iter().take(16) { - passes.push(( - banners.shield_texture(&layer.pattern), - horizon_client::banner::dye_rgb(&layer.color), - )); - } - passes -} diff --git a/crates/horizon-client/src/game/stations.rs b/crates/horizon-client/src/game/stations.rs index 90892be56..e75db5b6f 100644 --- a/crates/horizon-client/src/game/stations.rs +++ b/crates/horizon-client/src/game/stations.rs @@ -1991,100 +1991,6 @@ impl Game<'_> { self.draw_tooltip_lines(batch, &[(text, u32::MAX)], self.cursor.0, self.cursor.1); } } - /// Potion items: `layer0` tinted with the potion colour under the bottle - /// (`minecraft:potion` item tint source). - pub(super) fn draw_potion_layers( - &self, - batch: &mut HudBatch, - stack: &ItemStack, - x: f32, - y: f32, - ) { - let (overlay, base) = match &*stack.item { - "minecraft:potion" => ("item/potion_overlay", "item/potion"), - "minecraft:splash_potion" => ("item/potion_overlay", "item/splash_potion"), - "minecraft:lingering_potion" => ("item/potion_overlay", "item/lingering_potion"), - "minecraft:tipped_arrow" => ("item/tipped_arrow_head", "item/tipped_arrow_base"), - _ => return, - }; - let c = brewing::potion_color(stack.potion()); - let atlas = &self.res.atlas; - batch.sprite_scaled( - atlas, - overlay, - x, - y, - 16.0, - 16.0, - rgba( - (c >> 16 & 255) as u8, - (c >> 8 & 255) as u8, - (c & 255) as u8, - 255, - ), - ); - batch.sprite_scaled(atlas, base, x, y, 16.0, 16.0, u32::MAX); - } - /// The enchantment glint over an item icon: a shimmering purple tint. - pub(super) fn draw_glint(&self, batch: &mut HudBatch, stack: &ItemStack, x: f32, y: f32) { - if !self.res.stations.enchantments.has_glint(stack) { - return; - } - // ItemRenderer glint: the enchanted_glint texture scrolls diagonally over the - // item's shape. Approximated with a grid of item-texture quads whose vertex - // colours carry a purple base tint plus a moving bright band. - let t = self.started.elapsed().as_secs_f32(); - let glint = |gx: f32, gy: f32| -> u32 { - let d = ((gx + gy) / 32.0 - t * 0.35).rem_euclid(1.0); - let band = (1.0 - (d - 0.5).abs() * 6.0).max(0.0); - let a = 45.0 + 110.0 * band; - rgba( - (170.0 + 70.0 * band) as u8, - (90.0 + 110.0 * band) as u8, - 255, - a as u8, - ) - }; - match self.res.icons.get(&*stack.item).cloned().flatten() { - Some(super::Icon::Flat(name)) => { - let Some(r) = self.res.atlas.sprites.get(&name).copied() else { - return; - }; - const N: usize = 4; - let cell = 16.0 / N as f32; - let (du, dv) = ((r.u1 - r.u0) / N as f32, (r.v1 - r.v0) / N as f32); - for row in 0..N { - for col in 0..N { - let (x0, y0) = (col as f32 * cell, row as f32 * cell); - let (u0, v0) = (r.u0 + du * col as f32, r.v0 + dv * row as f32); - let corners = [ - (x0, y0, u0, v0), - (x0 + cell, y0, u0 + du, v0), - (x0 + cell, y0 + cell, u0 + du, v0 + dv), - (x0, y0 + cell, u0, v0 + dv), - ]; - for i in [0usize, 1, 2, 0, 2, 3] { - let (cx, cy, u, v) = corners[i]; - batch.vertices.push(horizon_client::hud::HudVertex { - pos: [x + cx, y + cy], - uv: [u + 2.0, v], - color: glint(cx, cy), - }); - } - } - } - } - Some(super::Icon::Cube { .. }) => batch.fill( - &self.res.atlas, - x + 1.0, - y + 1.0, - 14.0, - 14.0, - glint(8.0, 8.0) & 0x7FFF_FFFF, - ), - None => {} - } - } // ---------------------------------------------------------------- brewing stand diff --git a/crates/horizon-client/src/hud.rs b/crates/horizon-client/src/hud.rs index ed1a91c15..bc78f3ccd 100644 --- a/crates/horizon-client/src/hud.rs +++ b/crates/horizon-client/src/hud.rs @@ -62,6 +62,58 @@ fn walk(dir: &Path, out: &mut Vec) { } } } +/// A packed atlas image: sprite name, size and RGBA pixels. +type PackedImage = (String, u32, u32, Vec); +/// Sprites the atlas definitions (`atlases/*.json`) add beyond the texture +/// files already packed: generated ones (`paletted_permutations` such as the +/// armour trim sprites, `unstitch` regions) and files listed under another id. +fn atlas_sprites(root: &Path, packed: &[PackedImage]) -> Vec { + use crate::atlas_sources::{self, SpriteOrigin}; + let have: std::collections::HashSet<&str> = packed.iter().map(|i| i.0.as_str()).collect(); + let textures = atlas_sources::list_textures(root); + let load = |texture: &str, directory: &str| { + decode(&atlas_sources::texture_path(root, texture, directory)).ok() + }; + let mut out: Vec = Vec::new(); + let mut added = std::collections::HashSet::new(); + for (atlas, sources) in atlas_sources::atlases(root) { + // The other atlases' renamed files (GUI sprites, particles...) are + // looked up by their texture paths here. + let item_models = atlas == "minecraft:blocks" || atlas == "minecraft:items"; + for (id, origin) in atlas_sources::list(&sources, &textures) { + if !item_models && matches!(origin, SpriteOrigin::File(_)) { + continue; + } + let name = id.strip_prefix("minecraft:").unwrap_or(&id).to_owned(); + if have.contains(name.as_str()) || added.contains(&name) { + continue; + } + let image = match &origin { + SpriteOrigin::File(texture) => { + let path = texture.strip_prefix("minecraft:").unwrap_or(texture); + // Packed under its own name already: only a renamed file is new. + if path == name { + continue; + } + load(texture, "textures").map(|(w, h, p)| { + // Animated strips keep their first frame, like the packed files. + if h > w && (path.starts_with("block/") || path.starts_with("item/")) { + (w, w, p[..(w * w * 4) as usize].to_vec()) + } else { + (w, h, p) + } + }) + } + generated => atlas_sources::generate(generated, &load), + }; + if let Some((w, h, pixels)) = image { + added.insert(name.clone()); + out.push((name, w, h, pixels)); + } + } + } + out +} impl HudAtlas { /// A font glyph's atlas cell (8x8 GUI pixels) and advance. pub fn glyph(&self, ch: char) -> Option<(Rect, f32)> { @@ -131,6 +183,7 @@ impl HudAtlas { .flat_map(|h| h.join().unwrap_or_default()) .collect() }); + images.extend(atlas_sprites(root, &images)); images.push(("horizon/white".into(), 4, 4, vec![255; 64])); // Map textures (game/maps.rs) are written into these slots at run time. for i in 0..MAP_SLOTS { diff --git a/crates/horizon-client/src/item_render.rs b/crates/horizon-client/src/item_render.rs new file mode 100644 index 000000000..bd5c47179 --- /dev/null +++ b/crates/horizon-client/src/item_render.rs @@ -0,0 +1,815 @@ +//! Item rendering through the resolved item model pipeline: the +//! `ItemModelResolver` of `horizon-assets` fills an [`ItemRenderState`] +//! (`ItemStackRenderState`: layers of baked quads or special renderers, each +//! with its display transform, local transform, tints and foil), and +//! [`ItemRenderState::submit`] turns it into the quads `ItemFeatureRenderer` +//! and the special model renderers submit, in pose space. A sink then draws +//! them: [`gui`] into the HUD batch with the GUI item lighting, [`WorldSink`] +//! into entity vertices with the level's lighting. +pub mod gui; +mod special; + +use crate::{ + block_entity_render::{ModelPart, diffuse}, + hud::Rect, + mesher::Vertex, +}; +use glam::{Mat3, Mat4, Vec3}; +use horizon_assets::{ + animation::AnimationMetadata, + item_bake::{BakedItemModel, SpriteLookup, SpriteMask, bake_item_model}, + item_model::{ + ClientItem, Components, Context, DisplayContext, FoilType, ItemEnv, ItemModels, + LayerContent, LevelState, OwnerState, SpecialModel, StackView, + }, + model::{CuboidModel, Direction}, + palette::PalettedPermutations, + resolve::{MISSING_MODEL, ModelLibrary}, +}; +use horizon_world::nbt::Tag; +use serde_json::Value; +use std::{ + collections::{BTreeMap, HashMap}, + fs, + path::{Path, PathBuf}, + sync::{Arc, Mutex}, +}; + +/// One quad as submitted for drawing: pose-space corners, atlas UVs, the +/// transformed unit normal, ARGB colour (tint, `-1` white) and its glint. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct ItemQuad { + pub pos: [Vec3; 4], + pub uv: [[f32; 2]; 4], + pub normal: Vec3, + pub color: u32, + pub foil: Foil, + /// `MaterialInfo.lightEmission` (block light floor). + pub light_emission: u8, +} +/// Which glint render type a quad uses. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Foil { + None, + /// `GLINT_TEXTURING` over the sprite's UVs (`itemGlintRenderType`, + /// `entitySolidGlint`). + Standard, + /// `itemGlintSpecialRenderType`: compasses and clocks, a sheeted decal. + Special, +} +/// Where submitted quads go. +pub trait ItemSink { + fn quad(&mut self, quad: ItemQuad); +} +impl ItemSink for Vec { + fn quad(&mut self, quad: ItemQuad) { + self.push(quad); + } +} + +/// Data special renderers read from the game (registries, skins). +pub trait SpecialHost { + /// The banner atlas texture of a banner pattern (`entity/banner/`). + fn banner_texture(&self, pattern: &str) -> Option; + /// The shield atlas texture of a banner pattern (`entity/shield/`). + fn shield_texture(&self, pattern: &str) -> Option; + /// The skin texture of a `minecraft:profile` component, if loaded. + fn player_skin(&self, _profile: &Value) -> Option { + None + } +} +/// A host with no registries: patterns and skins fall back to defaults. +pub struct NoHost; +impl SpecialHost for NoHost { + fn banner_texture(&self, _: &str) -> Option { + None + } + fn shield_texture(&self, _: &str) -> Option { + None + } +} + +/// The geometry of one layer. +#[derive(Clone, Debug)] +pub enum LayerGeometry { + Quads(Arc), + Special { + model: SpecialModel, + argument: Value, + }, +} +/// `ItemStackRenderState.LayerRenderState`. +#[derive(Clone, Debug)] +pub struct LayerRender { + pub geometry: LayerGeometry, + pub tints: Vec, + pub foil: FoilType, + /// `applyTransform`: the display transform, then the local transform. + pub matrix: Mat4, + /// `particleMaterial` (atlas sprite name). + pub particle: String, + pub uses_block_light: bool, + /// Untransformed extents (quad corners or the special model's parts). + pub extents: Arc>, +} +/// `ItemStackRenderState`. +#[derive(Clone, Debug)] +pub struct ItemRenderState { + pub display: DisplayContext, + pub layers: Vec, + pub oversized_in_gui: bool, + pub animated: bool, +} +impl ItemRenderState { + pub fn is_empty(&self) -> bool { + self.layers.is_empty() + } + /// `pickParticleMaterial`: a random layer's particle sprite. + pub fn pick_particle( + &self, + random: &mut impl horizon_core::random::RandomSource, + ) -> Option { + if self.layers.is_empty() { + return None; + } + let i = random.next_int_bound(self.layers.len() as i32).unwrap_or(0) as usize; + self.layers.get(i).map(|l| l.particle.clone()) + } + /// `usesBlockLight` of the first layer (GUI lighting choice). + pub fn uses_block_light(&self) -> bool { + self.layers.first().is_some_and(|l| l.uses_block_light) + } + /// `getModelBoundingBox`: the transformed extents of every layer, as + /// (min, max); a zero box at the origin when there are none. + pub fn bounding_box(&self) -> (Vec3, Vec3) { + let mut lo = Vec3::splat(f32::INFINITY); + let mut hi = Vec3::splat(f32::NEG_INFINITY); + for layer in &self.layers { + for p in layer.extents.iter() { + let q = layer.matrix.transform_point3(*p); + lo = lo.min(q); + hi = hi.max(q); + } + } + if lo.x > hi.x { + (Vec3::ZERO, Vec3::ZERO) + } else { + (lo, hi) + } + } + /// `ItemStackRenderState.submit` under `pose`. + pub fn submit( + &self, + renderer: &ItemRenderer, + sprites: &HashMap, + host: &dyn SpecialHost, + pose: Mat4, + sink: &mut dyn ItemSink, + ) { + for layer in &self.layers { + let m = pose * layer.matrix; + match &layer.geometry { + LayerGeometry::Quads(baked) => { + submit_quads(baked, layer, self.display, m, sprites, sink); + } + LayerGeometry::Special { model, argument } => special::submit( + renderer, + model, + argument, + layer.foil != FoilType::None, + m, + sprites, + host, + sink, + ), + } + } + } +} + +/// The atlas name of a sprite identifier (`minecraft:item/apple` -> `item/apple`). +pub fn sprite_name(sprite: &str) -> &str { + sprite.strip_prefix("minecraft:").unwrap_or(sprite) +} +/// `Direction.getUnitVec3f`. +pub fn direction_vector(d: Direction) -> Vec3 { + match d { + Direction::Down => Vec3::NEG_Y, + Direction::Up => Vec3::Y, + Direction::North => Vec3::NEG_Z, + Direction::South => Vec3::Z, + Direction::West => Vec3::NEG_X, + Direction::East => Vec3::X, + } +} +/// `PoseStack.Pose.transformNormal`: the normal matrix, renormalized. +pub fn transform_normal(m: Mat4, n: Vec3) -> Vec3 { + let normal = Mat3::from_mat4(m).inverse().transpose(); + (normal * n).normalize_or_zero() +} +/// An `ARGB` int as the `u32` colour of an [`ItemQuad`]. +pub fn argb(color: i32) -> u32 { + color as u32 +} + +/// `ItemFeatureRenderer.prepareMainSubmit` for one cuboid layer. +fn submit_quads( + baked: &BakedItemModel, + layer: &LayerRender, + display: DisplayContext, + m: Mat4, + sprites: &HashMap, + sink: &mut dyn ItemSink, +) { + let foil = match layer.foil { + FoilType::None => Foil::None, + FoilType::Standard => Foil::Standard, + FoilType::Special => Foil::Special, + }; + let _ = display; + for q in &baked.quads { + let Some(r) = sprites + .get(sprite_name(&q.material.sprite)) + .or_else(|| sprites.get("misc/missingno")) + .or_else(|| sprites.get("horizon/missingno")) + .copied() + else { + continue; + }; + // `getLayerColorSafe`: an untinted quad, or a tint index past the + // tints, draws white. + let color = if q.tint_index >= 0 { + layer + .tints + .get(q.tint_index as usize) + .copied() + .unwrap_or(-1) + } else { + -1 + }; + let pos = q.positions.map(|p| m.transform_point3(Vec3::from(p))); + let uv = + q.uv.map(|[u, v]| [r.u0 + (r.u1 - r.u0) * u, r.v0 + (r.v1 - r.v0) * v]); + sink.quad(ItemQuad { + pos, + uv, + normal: transform_normal(m, direction_vector(q.facing)), + color: argb(color), + foil, + light_emission: q.light_emission, + }); + } +} + +// --------------------------------------------------------------------------- +// Sprites for baking +// --------------------------------------------------------------------------- + +/// The alpha masks of item and block sprites, read from the texture files +/// (every unique animation frame) and the items atlas's palette sprites. +struct FileSprites { + root: PathBuf, + permutations: Vec, + cache: Mutex>>, +} +impl SpriteLookup for FileSprites { + fn mask(&self, sprite: &str) -> Option { + if let Ok(cache) = self.cache.lock() + && let Some(hit) = cache.get(sprite) + { + return hit.clone(); + } + let mask = self.load(sprite); + if let Ok(mut cache) = self.cache.lock() { + cache.insert(sprite.to_owned(), mask.clone()); + } + mask + } +} +fn argb_pixels(rgba: &[u8]) -> Vec { + rgba.as_chunks::<4>() + .0 + .iter() + .map(|p| u32::from_be_bytes([p[3], p[0], p[1], p[2]])) + .collect() +} +impl FileSprites { + fn png(&self, sprite: &str, directory: &str) -> PathBuf { + crate::atlas_sources::texture_path(&self.root, sprite, directory) + } + fn image(&self, sprite: &str, directory: &str) -> Option<(usize, usize, Vec)> { + let (w, h, rgba) = crate::hud::decode(&self.png(sprite, directory)).ok()?; + Some((w as usize, h as usize, argb_pixels(&rgba))) + } + fn load(&self, sprite: &str) -> Option { + let png = self.png(sprite, "textures"); + let (iw, ih, argb) = match self.image(sprite, "textures") { + Some(image) => image, + None => { + let p = self.permutations.iter().find_map(|s| s.find(sprite))?; + let (w, h, mut pixels) = self.image(p.base, "textures")?; + let (_, _, key) = self.image(p.palette_key, "textures/palettes")?; + let (_, _, target) = self.image(p.palette, "textures/palettes")?; + horizon_assets::palette::apply_palette(&mut pixels, &key, &target)?; + (w, h, pixels) + } + }; + let alpha: Vec = argb.iter().map(|p| (p >> 24) as u8).collect(); + let animation = fs::read_to_string(png.with_extension("png.mcmeta")) + .ok() + .and_then(|m| serde_json::from_str::(&m).ok()) + .and_then(|m| m.get("animation").map(Value::to_string)) + .and_then(|a| AnimationMetadata::from_json(&a).ok()); + let (w, h) = match &animation { + Some(a) => { + let [w, h] = a.frame_size(iw as i32, ih as i32); + (w as usize, h as usize) + } + None => (iw, ih), + }; + if w == 0 || h == 0 { + return None; + } + let columns = iw / w; + let total = columns * (ih / h); + let clip = animation.and_then(|a| a.clip(total as u32).ok().flatten()); + let frames: Vec = match clip { + Some(clip) => { + let mut unique = Vec::new(); + for (index, _) in clip.sequence() { + if !unique.contains(&(*index as usize)) { + unique.push(*index as usize); + } + } + unique + } + None => vec![0], + }; + let frames = frames + .into_iter() + .map(|f| { + let (fx, fy) = (f % columns * w, f / columns * h); + (0..h) + .flat_map(|y| (0..w).map(move |x| (x, y))) + .map(|(x, y)| alpha[(fy + y) * iw + fx + x] == 0) + .collect() + }) + .collect(); + Some(SpriteMask { + width: w, + height: h, + frames, + }) + } +} + +// --------------------------------------------------------------------------- +// The renderer +// --------------------------------------------------------------------------- + +/// The baked item models and everything resolution needs. +pub struct ItemRenderer { + pub models: ItemModels, + library: ModelLibrary, + sprites: FileSprites, + baked: Mutex>>, + extents: Mutex>>>, + /// Entity model layers of the special renderers. + parts: HashMap, + /// `colormap/grass.png` as ARGB. + grass: Vec, + /// `minecraft:item` registry ids (`Item.getId`). + item_ids: HashMap, +} + +/// Every `models/**.json` of a namespace directory, by identifier. +fn load_models(root: &Path) -> BTreeMap { + let mut out = BTreeMap::new(); + let Ok(namespaces) = fs::read_dir(root.join("assets")) else { + return out; + }; + for ns in namespaces.flatten() { + let namespace = ns.file_name().to_string_lossy().into_owned(); + let base = ns.path().join("models"); + let mut stack = vec![base.clone()]; + while let Some(dir) = stack.pop() { + let Ok(entries) = fs::read_dir(&dir) else { + continue; + }; + for e in entries.flatten() { + let path = e.path(); + if path.is_dir() { + stack.push(path); + } else if path.extension().is_some_and(|x| x == "json") + && let Ok(rel) = path.strip_prefix(&base) + && let Ok(text) = fs::read_to_string(&path) + && let Ok(model) = CuboidModel::from_json(&text) + { + let rel = rel.with_extension("").to_string_lossy().replace('\\', "/"); + out.insert(format!("{namespace}:{rel}"), model); + } + } + } + } + out +} +/// Every `items/*.json` client item definition, by identifier. +fn load_definitions(root: &Path) -> BTreeMap { + let mut out = BTreeMap::new(); + let Ok(namespaces) = fs::read_dir(root.join("assets")) else { + return out; + }; + for ns in namespaces.flatten() { + let namespace = ns.file_name().to_string_lossy().into_owned(); + let Ok(files) = fs::read_dir(ns.path().join("items")) else { + continue; + }; + for f in files.flatten() { + let path = f.path(); + if path.extension().is_none_or(|e| e != "json") { + continue; + } + let name = path.file_stem().unwrap_or_default().to_string_lossy(); + if let Some(item) = fs::read_to_string(&path) + .ok() + .and_then(|t| ClientItem::from_json(&t).ok()) + { + out.insert(format!("{namespace}:{name}"), item); + } + } + } + out +} + +impl ItemRenderer { + /// Load item definitions, item prototypes (`items.json`), every model, + /// the special renderers' entity models and the grass colormap. + pub fn load(root: &Path) -> crate::Result { + let prototypes: BTreeMap = + serde_json::from_slice(&fs::read(root.join("items.json"))?)?; + let models = ItemModels { + definitions: load_definitions(root), + prototypes, + }; + let library = ModelLibrary::with_item_generator(load_models(root)) + .map_err(|e| format!("item models: {e:?}"))?; + let permutations = PalettedPermutations::from_atlas( + &fs::read_to_string(root.join("assets/minecraft/atlases/items.json")) + .unwrap_or_default(), + ); + let parts = special::load_parts(root); + let grass = crate::hud::decode(&root.join("assets/minecraft/textures/colormap/grass.png")) + .map(|(_, _, rgba)| argb_pixels(&rgba).into_iter().map(|p| p as i32).collect()) + .unwrap_or_default(); + let item_ids = horizon_protocol::registry::Builtin::find(root) + .and_then(|p| horizon_protocol::registry::Builtin::load(&p).ok()) + .and_then(|b| { + let ids = b.get("minecraft:item")?; + let mut out = HashMap::new(); + for i in 0.. { + let Some(name) = ids.name(i) else { break }; + out.insert(name.to_owned(), i); + } + Some(out) + }) + .unwrap_or_default(); + Ok(Self { + item_ids, + models, + library, + sprites: FileSprites { + root: root.to_path_buf(), + permutations, + cache: Mutex::default(), + }, + baked: Mutex::default(), + extents: Mutex::default(), + parts, + grass, + }) + } + /// `ModelBakery` item baking, cached per model. + pub fn bake(&self, model: &str) -> Arc { + if let Ok(cache) = self.baked.lock() + && let Some(hit) = cache.get(model) + { + return hit.clone(); + } + let baked = bake_item_model(&self.library, &self.sprites, model) + .or_else(|_| bake_item_model(&self.library, &self.sprites, MISSING_MODEL)) + .map(Arc::new) + .unwrap_or_else(|_| { + Arc::new(BakedItemModel { + quads: Vec::new(), + uses_block_light: false, + particle: horizon_assets::model::Material { + sprite: horizon_assets::item_bake::MISSING_SPRITE.to_owned(), + force_translucent: false, + }, + transforms: Default::default(), + }) + }); + if let Ok(mut cache) = self.baked.lock() { + cache.insert(model.to_owned(), baked.clone()); + } + baked + } + /// `CuboidItemModelWrapper.computeExtents`: the distinct quad corners. + fn quad_extents(&self, model: &str, baked: &BakedItemModel) -> Arc> { + if let Ok(cache) = self.extents.lock() + && let Some(hit) = cache.get(model) + { + return hit.clone(); + } + let mut out: Vec = Vec::new(); + for q in &baked.quads { + for p in q.positions { + let p = Vec3::from(p); + if !out.contains(&p) { + out.push(p); + } + } + } + let out = Arc::new(out); + if let Ok(mut cache) = self.extents.lock() { + cache.insert(model.to_owned(), out.clone()); + } + out + } + fn special_extents(&self, model: &SpecialModel) -> Arc> { + let key = model.to_json().to_string(); + if let Ok(cache) = self.extents.lock() + && let Some(hit) = cache.get(&key) + { + return hit.clone(); + } + let out = Arc::new(special::extents(self, model)); + if let Ok(mut cache) = self.extents.lock() { + cache.insert(key, out.clone()); + } + out + } + /// `ItemModelResolver.updateForTopItem`. + pub fn resolve( + &self, + stack: &StackView, + display: DisplayContext, + owner: Option<&OwnerState>, + level: Option<&LevelState>, + seed: i32, + env: &dyn ItemEnv, + ) -> ItemRenderState { + let ctx = Context { + display, + owner, + level, + seed, + }; + let resolved = self.models.resolve(stack, &ctx, env); + let mut animated = false; + let layers = resolved + .layers + .into_iter() + .map(|layer| { + let (geometry, baked, extents) = match layer.content { + LayerContent::Model { model } => { + let baked = self.bake(&model); + let extents = self.quad_extents(&model, &baked); + (LayerGeometry::Quads(baked.clone()), baked, extents) + } + LayerContent::Missing => { + let baked = self.bake(MISSING_MODEL); + let extents = self.quad_extents(MISSING_MODEL, &baked); + (LayerGeometry::Quads(baked.clone()), baked, extents) + } + LayerContent::Special { + base, + model, + argument, + } => { + let baked = self.bake(&base); + let extents = self.special_extents(&model); + (LayerGeometry::Special { model, argument }, baked, extents) + } + }; + if layer.foil != FoilType::None { + animated = true; + } + LayerRender { + geometry, + tints: layer.tints, + foil: layer.foil, + matrix: glam_matrix(&baked.layer_matrix(display, &layer.transform)), + uses_block_light: baked.uses_block_light, + particle: sprite_name(&baked.particle.sprite).to_owned(), + extents, + } + }) + .collect(); + ItemRenderState { + display, + layers, + oversized_in_gui: resolved.oversized_in_gui, + animated, + } + } + /// `GrassColor.get` over the loaded colormap. + pub fn grass_color(&self, temperature: f64, downfall: f64) -> i32 { + let rain = downfall * temperature; + let x = ((1.0 - temperature) * 255.0) as i64; + let y = ((1.0 - rain) * 255.0) as i64; + let index = (y << 8 | x) as usize; + self.grass.get(index).copied().unwrap_or(-65281) + } + /// Submit a special model renderer directly (worn skulls of + /// `CustomHeadLayer`, which draw the skull model, not the item). + #[allow(clippy::too_many_arguments)] + pub fn submit_special( + &self, + model: &SpecialModel, + argument: &Value, + has_foil: bool, + pose: Mat4, + sprites: &HashMap, + host: &dyn SpecialHost, + sink: &mut dyn ItemSink, + ) { + special::submit(self, model, argument, has_foil, pose, sprites, host, sink); + } + /// `Item.getId` (0 when the registry report is missing). + pub fn item_id(&self, item: &str) -> i32 { + self.item_ids.get(item).copied().unwrap_or(0) + } + pub(crate) fn part(&self, key: &str) -> Option<&ModelPart> { + self.parts.get(key) + } +} +/// A `horizon-assets` (row-major, JOML-exact) matrix as glam's. +pub fn glam_matrix(m: &horizon_assets::math::Mat4) -> Mat4 { + Mat4::from_cols_array_2d(&m.rows()).transpose() +} + +// --------------------------------------------------------------------------- +// Stacks +// --------------------------------------------------------------------------- + +/// An NBT value as the JSON its component codec reads. +pub fn tag_json(tag: &Tag) -> Value { + match tag { + Tag::End => Value::Null, + Tag::Byte(v) => Value::from(*v), + Tag::Short(v) => Value::from(*v), + Tag::Int(v) => Value::from(*v), + Tag::Long(v) => Value::from(*v), + Tag::Float(bits) => serde_json::Number::from_f64(f64::from(f32::from_bits(*bits))) + .map_or(Value::Null, Value::Number), + Tag::Double(bits) => { + serde_json::Number::from_f64(f64::from_bits(*bits)).map_or(Value::Null, Value::Number) + } + Tag::ByteArray(a) => Value::Array(a.iter().map(|b| Value::from(*b as i8)).collect()), + Tag::String(s) => Value::String(s.to_string_lossy()), + Tag::List(l) => Value::Array(l.iter().map(tag_json).collect()), + Tag::Compound(c) => Value::Object( + c.iter() + .map(|(k, v)| (k.to_string_lossy(), tag_json(v))) + .collect(), + ), + Tag::IntArray(a) => Value::Array(a.iter().map(|v| Value::from(*v)).collect()), + Tag::LongArray(a) => Value::Array(a.iter().map(|v| Value::from(*v)).collect()), + } +} +/// The resolver's view of a client stack: its item, count and component patch. +pub fn stack_view(stack: &crate::items::ItemStack) -> StackView { + let mut view = StackView::new(&stack.item, stack.count as i32); + if let Some(Tag::Compound(c)) = crate::item_data::components_tag(stack.damage, stack.data()) { + for (k, v) in &c { + let key = k.to_string_lossy(); + match key.strip_prefix('!') { + Some(removed) => view.patch.insert(removed.to_owned(), None), + None => view.patch.insert(key, Some(tag_json(v))), + }; + } + } + view +} + +// --------------------------------------------------------------------------- +// World drawing +// --------------------------------------------------------------------------- + +/// Entity vertices for submitted quads: the `item`/`entity` shader's +/// `minecraft_mix_light` with the level's diffuse lights on the vertex +/// colour, the packed lightmap coordinates (raised by light emission) and +/// overlay 7 for the glint. +pub struct WorldSink<'a> { + pub out: &'a mut Vec, + /// Packed light (`block_entity_render::vertex_light`). + pub light: u32, + /// The level's diffuse lights; `None` leaves the colour unshaded. + pub lights: Option<(Vec3, Vec3)>, +} +impl ItemSink for WorldSink<'_> { + fn quad(&mut self, q: ItemQuad) { + let brightness = self.lights.map_or(1.0, |l| diffuse(q.normal, l)); + let [a, r, g, b] = q.color.to_be_bytes(); + let c = |v: u8| (f32::from(v) * brightness) as u32; + let color = u32::from(a) << 24 | c(b) << 16 | c(g) << 8 | c(r); + // `LightCoordsUtil.lightCoordsWithEmission`: block light at least the emission. + let emission = u32::from(q.light_emission) * 16; + let light = if (self.light >> 8 & 0xFF) < emission { + (self.light & 0xFF) | emission << 8 + } else { + self.light + }; + let overlay = if q.foil == Foil::None { 0 } else { 7 }; + for (p, uv) in q.pos.iter().zip(q.uv) { + self.out.push(Vertex { + pos: p.to_array(), + uv, + layer: overlay, + color, + light, + }); + } + } +} + +/// `ItemEntity.getSpin`. +pub fn item_spin(age_in_ticks: f32, bob_offset: f32) -> f32 { + age_in_ticks / 20.0 + bob_offset +} +/// `ItemClusterRenderState.getRenderedAmount`. +pub fn rendered_amount(count: u32) -> u32 { + match count { + 0..=1 => 1, + 2..=16 => 2, + 17..=32 => 3, + 33..=48 => 4, + _ => 5, + } +} +/// `ItemEntityRenderer.submitMultipleFromCount`: the poses of each copy of +/// a stack (`seed` is `ItemClusterRenderState.getSeedForItemStack`). +pub fn cluster_poses(state: &ItemRenderState, pose: Mat4, amount: u32, seed: i64) -> Vec { + use horizon_core::random::{LegacyRandom, RandomSource}; + let mut out = Vec::new(); + if amount == 0 { + return out; + } + let mut random = LegacyRandom::new(seed); + let (lo, hi) = state.bounding_box(); + let depth = hi.z - lo.z; + let mut next = || random.next_float() * 2.0 - 1.0; + if depth > 0.0625 { + out.push(pose); + for _ in 1..amount { + let (x, y, z) = (next() * 0.15, next() * 0.15, next() * 0.15); + out.push(pose * Mat4::from_translation(Vec3::new(x, y, z))); + } + } else { + let offset = depth * 1.5; + let mut p = pose + * Mat4::from_translation(Vec3::new(0.0, 0.0, -(offset * (amount - 1) as f32 / 2.0))); + out.push(p); + p *= Mat4::from_translation(Vec3::new(0.0, 0.0, offset)); + for _ in 1..amount { + let (x, y) = (next() * 0.15 * 0.5, next() * 0.15 * 0.5); + out.push(p * Mat4::from_translation(Vec3::new(x, y, 0.0))); + p *= Mat4::from_translation(Vec3::new(0.0, 0.0, offset)); + } + } + out +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn rendered_amounts_follow_the_count_bands() { + let bands: Vec = [0, 1, 2, 16, 17, 32, 33, 48, 49, 64] + .iter() + .map(|c| rendered_amount(*c)) + .collect(); + assert_eq!(bands, [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]); + } + #[test] + fn nbt_components_read_as_json() { + let tag = Tag::compound([ + ("a", Tag::Int(3)), + ("b", Tag::List(vec![Tag::String("x".into())])), + ("c", Tag::Float(1.5f32.to_bits())), + ]); + assert_eq!( + tag_json(&tag), + serde_json::json!({"a": 3, "b": ["x"], "c": 1.5}) + ); + } + #[test] + fn normals_follow_the_inverse_transpose() { + let m = Mat4::from_scale(Vec3::new(2.0, 1.0, 1.0)); + assert_eq!(transform_normal(m, Vec3::X), Vec3::X); + let r = Mat4::from_rotation_y(std::f32::consts::FRAC_PI_2); + assert!((transform_normal(r, Vec3::Z) - Vec3::X).length() < 1e-6); + } +} diff --git a/crates/horizon-client/src/item_render/gui.rs b/crates/horizon-client/src/item_render/gui.rs new file mode 100644 index 000000000..0000b2613 --- /dev/null +++ b/crates/horizon-client/src/item_render/gui.rs @@ -0,0 +1,245 @@ +//! `GuiGraphics.renderItem` drawn into the HUD batch: the item's layers are +//! submitted under the GUI item pose (`translate(x + 8, y + 8)`, +//! `scale(16, -16, 16)`), lit with `Lighting.Entry.ITEMS_3D` or `ITEMS_FLAT` +//! (`minecraft_mix_light` on the transformed normals), back faces culled, +//! drawn far to near, and clipped to the item's 16x16 slot unless the model +//! is oversized in the GUI (`GuiItemAtlas` draws each item into a scissored +//! 16x16 slot; oversized items get a picture-in-picture of their bounds). +use super::{Foil, ItemQuad, ItemRenderState, ItemRenderer, SpecialHost}; +use crate::hud::{HudBatch, Rect}; +use glam::{EulerRot, Mat4, Vec2, Vec3}; +use std::{collections::HashMap, f32::consts::PI}; + +/// `Lighting.DIFFUSE_LIGHT_0` and `DIFFUSE_LIGHT_1`. +fn diffuse_lights() -> (Vec3, Vec3) { + ( + Vec3::new(0.2, 1.0, -0.7).normalize(), + Vec3::new(-0.2, 1.0, 0.7).normalize(), + ) +} +/// `Lighting.Entry.ITEMS_FLAT`: `rotationY(-PI/8).rotateX(3PI/4)`. +pub fn items_flat_lights() -> (Vec3, Vec3) { + let m = Mat4::from_rotation_y(-PI / 8.0) * Mat4::from_rotation_x(PI * 3.0 / 4.0); + let (a, b) = diffuse_lights(); + (m.transform_vector3(a), m.transform_vector3(b)) +} +/// JOML `rotateYXZ(y, x, z)`. +fn rotate_yxz(y: f32, x: f32, z: f32) -> Mat4 { + Mat4::from_euler(EulerRot::YXZ, y, x, z) +} +/// `Lighting.Entry.ITEMS_3D`. +pub fn items_3d_lights() -> (Vec3, Vec3) { + let m = Mat4::from_scale(Vec3::new(1.0, -1.0, 1.0)) + * rotate_yxz(1.082_104_1, 3.237_585_8, 0.0) + * rotate_yxz(-PI / 8.0, PI * 3.0 / 4.0, 0.0); + let (a, b) = diffuse_lights(); + (m.transform_vector3(a), m.transform_vector3(b)) +} + +/// A GUI-space vertex: position, atlas UV. +#[derive(Clone, Copy, Debug)] +struct Point { + p: Vec2, + uv: [f32; 2], +} +fn lerp(a: Point, b: Point, t: f32) -> Point { + Point { + p: a.p + (b.p - a.p) * t, + uv: [ + a.uv[0] + (b.uv[0] - a.uv[0]) * t, + a.uv[1] + (b.uv[1] - a.uv[1]) * t, + ], + } +} +/// Sutherland-Hodgman against one half plane `dot(p, n) <= limit`. +fn clip_edge(poly: &[Point], axis: usize, limit: f32, keep_below: bool) -> Vec { + let inside = |p: &Point| { + let v = p.p[axis]; + if keep_below { v <= limit } else { v >= limit } + }; + let mut out = Vec::with_capacity(poly.len() + 2); + for i in 0..poly.len() { + let (a, b) = (poly[i], poly[(i + 1) % poly.len()]); + let (ia, ib) = (inside(&a), inside(&b)); + if ia { + out.push(a); + } + if ia != ib { + let t = (limit - a.p[axis]) / (b.p[axis] - a.p[axis]); + out.push(lerp(a, b, t)); + } + } + out +} +/// A triangle clipped to `[x0, x1] x [y0, y1]`, as a fan. +fn clip_triangle(tri: [Point; 3], rect: [f32; 4]) -> Vec { + let mut poly = tri.to_vec(); + for (axis, limit, below) in [ + (0, rect[0], false), + (0, rect[2], true), + (1, rect[1], false), + (1, rect[3], true), + ] { + if poly.is_empty() { + break; + } + poly = clip_edge(&poly, axis, limit, below); + } + poly +} + +/// RGBA vertex colour of a lit quad: `minecraft_mix_light` on the tint. +fn lit_color(q: &ItemQuad, lights: (Vec3, Vec3)) -> u32 { + let light = crate::block_entity_render::diffuse(q.normal, lights); + let [a, r, g, b] = q.color.to_be_bytes(); + let c = |v: u8| (f32::from(v) * light) as u8; + crate::hud::rgba(c(r), c(g), c(b), a) +} +/// The glint's moving sheen at a GUI position (a stand-in for the +/// `GLINT_TEXTURING`-scrolled `enchanted_glint_item` texture added on top). +fn glint_color(p: Vec2, time: f32) -> u32 { + let d = ((p.x + p.y) / 32.0 - time * 0.35).rem_euclid(1.0); + let band = (1.0 - (d - 0.5).abs() * 6.0).max(0.0); + crate::hud::rgba( + (170.0 + 70.0 * band) as u8, + (90.0 + 110.0 * band) as u8, + 255, + (45.0 + 110.0 * band) as u8, + ) +} + +fn emit(batch: &mut HudBatch, fan: &[Point], color: impl Fn(Vec2) -> u32, glint: bool) { + let shift = if glint { 2.0 } else { 0.0 }; + for i in 1..fan.len().saturating_sub(1) { + let (a, b, c) = (fan[0], fan[i], fan[i + 1]); + let corners = [a, b, c, c]; + // `HudBatch.quad` draws (0, 1, 2) and (0, 2, 3): the second is empty. + batch.quad( + corners.map(|v| v.p.to_array()), + corners.map(|v| [v.uv[0] + shift, v.uv[1]]), + color(a.p), + ); + if glint { + // Per-vertex colours are flat per quad in the HUD batch: use the + // fan centre for the sheen. + let n = batch.vertices.len(); + for v in &mut batch.vertices[n - 6..] { + v.color = color(Vec2::from(v.pos)); + } + } + } +} + +/// Submit, light, cull, sort and clip one item's quads into `batch` at GUI +/// position `(x, y)`. +#[allow(clippy::too_many_arguments)] +pub fn draw( + state: &ItemRenderState, + renderer: &ItemRenderer, + sprites: &HashMap, + host: &dyn SpecialHost, + batch: &mut HudBatch, + x: f32, + y: f32, + time: f32, +) { + if state.is_empty() { + return; + } + let pose = Mat4::from_translation(Vec3::new(x + 8.0, y + 8.0, 0.0)) + * Mat4::from_scale(Vec3::new(16.0, -16.0, 16.0)); + let mut quads: Vec = Vec::new(); + state.submit(renderer, sprites, host, pose, &mut quads); + let lights = if state.uses_block_light() { + items_3d_lights() + } else { + items_flat_lights() + }; + // Back-face culling: front faces wind counter-clockwise on screen with y up. + let mut visible: Vec<(f32, usize)> = quads + .iter() + .enumerate() + .filter(|(_, q)| { + let p = q.pos.map(|v| Vec2::new(v.x, -v.y)); + let area: f32 = (0..4) + .map(|i| { + let (a, b) = (p[i], p[(i + 1) % 4]); + a.x * b.y - b.x * a.y + }) + .sum(); + area > 0.0 + }) + .map(|(i, q)| (q.pos.iter().map(|v| v.z).sum::() / 4.0, i)) + .collect(); + // Far to near; the depth buffer of the item atlas, approximated per quad. + visible.sort_by(|a, b| a.0.total_cmp(&b.0)); + let rect = if state.oversized_in_gui { + [ + f32::NEG_INFINITY, + f32::NEG_INFINITY, + f32::INFINITY, + f32::INFINITY, + ] + } else { + [x, y, x + 16.0, y + 16.0] + }; + for (_, i) in visible { + let q = &quads[i]; + let points: [Point; 4] = std::array::from_fn(|k| Point { + p: Vec2::new(q.pos[k].x, q.pos[k].y), + uv: q.uv[k], + }); + let color = lit_color(q, lights); + for tri in [ + [points[0], points[1], points[2]], + [points[0], points[2], points[3]], + ] { + let fan = clip_triangle(tri, rect); + if fan.len() < 3 { + continue; + } + emit(batch, &fan, |_| color, false); + if q.foil != Foil::None { + emit(batch, &fan, |p| glint_color(p, time), true); + } + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn flat_lights_match_joml() { + // new Matrix4f().rotationY(-PI/8).rotateX(3PI/4).transformDirection(L0). + let (l0, _) = items_flat_lights(); + let l = Vec3::new(0.2, 1.0, -0.7).normalize(); + let (s, c) = ((3.0 * PI / 4.0).sin(), (3.0 * PI / 4.0).cos()); + let rx = Vec3::new(l.x, c * l.y - s * l.z, s * l.y + c * l.z); + let (s, c) = ((-PI / 8.0).sin(), (-PI / 8.0).cos()); + let ry = Vec3::new(c * rx.x + s * rx.z, rx.y, -s * rx.x + c * rx.z); + assert!((l0 - ry).length() < 1e-6); + } + #[test] + fn triangles_clip_to_the_slot() { + let p = |x: f32, y: f32| Point { + p: Vec2::new(x, y), + uv: [x, y], + }; + let fan = clip_triangle( + [p(-4.0, 0.0), p(8.0, 0.0), p(8.0, 8.0)], + [0.0, 0.0, 16.0, 16.0], + ); + assert!(fan.iter().all(|v| v.p.x >= 0.0)); + // UVs follow the cut affinely. + assert!(fan.iter().all(|v| (v.uv[0] - v.p.x).abs() < 1e-6)); + assert!( + clip_triangle( + [p(20.0, 0.0), p(30.0, 0.0), p(30.0, 5.0)], + [0.0, 0.0, 16.0, 16.0] + ) + .is_empty() + ); + } +} diff --git a/crates/horizon-client/src/item_render/special.rs b/crates/horizon-client/src/item_render/special.rs new file mode 100644 index 000000000..fe9f0cfa8 --- /dev/null +++ b/crates/horizon-client/src/item_render/special.rs @@ -0,0 +1,597 @@ +//! `SpecialModelRenderer`s: items drawn with entity models (chests, shulker +//! boxes, banners, heads, shields, tridents, decorated pots, conduits, bells, +//! books and copper golem statues). Each submits its model at the layer pose +//! as vanilla's `submit` does (no block-entity placement transform) and +//! reports `getExtents` over the same posed parts. +use super::{Foil, ItemQuad, ItemRenderer, ItemSink, SpecialHost, argb}; +use crate::{block_entity_render::ModelPart, hud::Rect}; +use glam::{Mat4, Quat, Vec3}; +use horizon_assets::item_model::{SpecialKind, SpecialModel}; +use serde_json::Value; +use std::{collections::HashMap, f32::consts::PI, path::Path}; + +/// Entity model layers the special renderers bake (`ModelLayers`). +const LAYERS: [(&str, &str); 22] = [ + ("chest", "minecraft:chest#main"), + ("double_chest_left", "minecraft:double_chest_left#main"), + ("double_chest_right", "minecraft:double_chest_right#main"), + ("shulker_box", "minecraft:shulker_box#main"), + ("standing_banner", "minecraft:standing_banner#main"), + ("standing_banner_flag", "minecraft:standing_banner#flag"), + ("wall_banner", "minecraft:wall_banner#main"), + ("wall_banner_flag", "minecraft:wall_banner#flag"), + ("skeleton", "minecraft:skeleton_skull#main"), + ("wither_skeleton", "minecraft:wither_skeleton_skull#main"), + ("zombie", "minecraft:zombie_head#main"), + ("creeper", "minecraft:creeper_head#main"), + ("dragon", "minecraft:dragon_skull#main"), + ("piglin", "minecraft:piglin_head#main"), + ("player", "minecraft:player_head#main"), + ("bell", "minecraft:bell#main"), + ("book", "minecraft:book#main"), + ("conduit_shell", "minecraft:conduit#shell"), + ("decorated_pot_base", "minecraft:decorated_pot_base#main"), + ("decorated_pot_sides", "minecraft:decorated_pot_sides#main"), + ("shield", "minecraft:shield#main"), + ("trident", "minecraft:trident#main"), +]; +const COPPER_GOLEM_LAYERS: [(&str, &str); 4] = [ + ("copper_golem", "minecraft:copper_golem#main"), + ( + "copper_golem_running", + "minecraft:copper_golem_running#main", + ), + ( + "copper_golem_sitting", + "minecraft:copper_golem_sitting#main", + ), + ("copper_golem_star", "minecraft:copper_golem_star#main"), +]; + +pub(super) fn load_parts(root: &Path) -> HashMap { + let Ok(all) = std::fs::read(root.join("entity-models.json")) + .map_err(|_| ()) + .and_then(|b| serde_json::from_slice::(&b).map_err(|_| ())) + else { + return HashMap::new(); + }; + LAYERS + .iter() + .chain(COPPER_GOLEM_LAYERS.iter()) + .filter_map(|(key, layer)| { + all.get(*layer) + .map(|v| ((*key).to_owned(), ModelPart::parse(v))) + }) + .collect() +} + +/// A pose override for a named part (`setupAnim`). +type Adjust<'a> = &'a dyn Fn(&str, &mut [f32; 9]); +fn none(_: &str, _: &mut [f32; 9]) {} + +/// `ModelPart.translateAndRotate`. +fn part_matrix(parent: Mat4, p: &[f32; 9]) -> Mat4 { + parent + * Mat4::from_translation(Vec3::new(p[0], p[1], p[2]) / 16.0) + * Mat4::from_quat(Quat::from_euler(glam::EulerRot::ZYX, p[5], p[4], p[3])) + * Mat4::from_scale(Vec3::new(p[6], p[7], p[8])) +} +/// `ModelPart.render` of `part` (named `name`) as item quads. +#[allow(clippy::too_many_arguments)] +fn draw( + part: &ModelPart, + name: &str, + parent: Mat4, + adjust: Adjust, + sprite: Rect, + color: u32, + foil: Foil, + sink: &mut dyn ItemSink, +) { + let mut p = part.pose; + adjust(name, &mut p); + let m = part_matrix(parent, &p); + for poly in &part.polygons { + let pos = poly.map(|v| m.transform_point3(Vec3::new(v[0], v[1], v[2]) / 16.0)); + let normal = (pos[1] - pos[0]).cross(pos[2] - pos[0]).normalize_or_zero(); + let normal = if normal == Vec3::ZERO { + (pos[2] - pos[1]) + .cross(pos[3] - pos[1]) + .normalize_or(Vec3::Y) + } else { + normal + }; + sink.quad(ItemQuad { + pos, + uv: poly.map(|v| { + [ + sprite.u0 + (sprite.u1 - sprite.u0) * v[3], + sprite.v0 + (sprite.v1 - sprite.v0) * v[4], + ] + }), + normal, + color, + foil, + light_emission: 0, + }); + } + for (child_name, child) in &part.children { + draw(child, child_name, m, adjust, sprite, color, foil, sink); + } +} +/// `ModelPart.getExtentsForGui` from an identity pose. +fn extents_of(part: &ModelPart, name: &str, parent: Mat4, adjust: Adjust, out: &mut Vec) { + if part.polygons.is_empty() && part.children.is_empty() { + return; + } + let mut p = part.pose; + adjust(name, &mut p); + let m = part_matrix(parent, &p); + for poly in &part.polygons { + for v in poly { + let q = m.transform_point3(Vec3::new(v[0], v[1], v[2]) / 16.0); + if !out.contains(&q) { + out.push(q); + } + } + } + for (child_name, child) in &part.children { + extents_of(child, child_name, m, adjust, out); + } +} +fn child<'a>(part: &'a ModelPart, name: &str) -> Option<&'a ModelPart> { + part.child(name) +} + +/// A texture identifier relative to `textures/` (`minecraft:entity/x` or a +/// full `minecraft:textures/entity/x.png`) as its atlas sprite name. +fn texture_sprite(id: &str) -> String { + let path = id.strip_prefix("minecraft:").unwrap_or(id); + let path = path.strip_prefix("textures/").unwrap_or(path); + path.strip_suffix(".png").unwrap_or(path).to_owned() +} +fn mapped(directory: &str, id: &str) -> String { + format!( + "entity/{directory}/{}", + id.strip_prefix("minecraft:").unwrap_or(id) + ) +} +/// `DyeColor.getTextureDiffuseColor` as ARGB. +fn dye(name: &str) -> u32 { + 0xFF00_0000 | crate::banner::dye_rgb(name) +} + +/// The chest model of a chest type, with `ChestModel.setupAnim(openness)`. +fn chest_model(chest_type: &str) -> &'static str { + match chest_type { + "left" => "double_chest_left", + "right" => "double_chest_right", + _ => "chest", + } +} +fn skull_layer(kind: &str) -> &'static str { + match kind { + "skeleton" => "skeleton", + "wither_skeleton" => "wither_skeleton", + "zombie" => "zombie", + "creeper" => "creeper", + "dragon" => "dragon", + "piglin" => "piglin", + _ => "player", + } +} +/// `SkullBlockRenderer.SKIN_BY_TYPE`. +fn skull_texture(kind: &str) -> &'static str { + match kind { + "skeleton" => "entity/skeleton/skeleton", + "wither_skeleton" => "entity/skeleton/wither_skeleton", + "zombie" => "entity/zombie/zombie", + "creeper" => "entity/creeper/creeper", + "dragon" => "entity/enderdragon/dragon", + "piglin" => "entity/piglin/piglin", + _ => "entity/player/wide/steve", + } +} +/// `SkullModelBase.setupAnim` for a head at `animation` (yRot = xRot = 0). +fn skull_pose(kind: &str, animation: f32) -> impl Fn(&str, &mut [f32; 9]) + '_ { + move |name: &str, p: &mut [f32; 9]| match (kind, name) { + (_, "head") => { + p[3] = 0.0; + p[4] = 0.0; + } + ("dragon", "jaw") => p[3] = (((animation * PI * 0.2) as f64).sin() as f32 + 1.0) * 0.2, + ("piglin", "left_ear") => { + p[5] = -((((animation * PI * 0.2 * 1.2) as f64).cos() + 2.5) as f32) * 0.2; + } + ("piglin", "right_ear") => { + p[5] = ((((animation * PI * 0.2) as f64).cos() + 2.5) as f32) * 0.2; + } + _ => {} + } +} +fn shulker_pose(progress: f32) -> impl Fn(&str, &mut [f32; 9]) { + move |name: &str, p: &mut [f32; 9]| { + if name == "lid" { + p[0] = 0.0; + p[1] = 24.0 - progress * 0.5 * 16.0; + p[2] = 0.0; + p[4] = 270.0 * progress * (PI / 180.0); + } + } +} +fn chest_pose(open: f32) -> impl Fn(&str, &mut [f32; 9]) { + move |name: &str, p: &mut [f32; 9]| { + if name == "lid" || name == "lock" { + p[3] = -(open * (PI / 2.0)); + } + } +} +/// `BannerFlagModel.setupAnim(0)`. +fn flag_pose(name: &str, p: &mut [f32; 9]) { + if name == "flag" { + p[3] = (-0.0125 + 0.01 * (2.0 * PI * 0.0f32).cos()) * PI; + } +} +/// `BookModel.setupAnim`. +fn book_pose(openness: f32, flip1: f32, flip2: f32) -> impl Fn(&str, &mut [f32; 9]) { + move |name: &str, p: &mut [f32; 9]| match name { + "left_lid" => p[4] = PI + openness, + "right_lid" => p[4] = -openness, + "left_pages" => { + p[4] = openness; + p[0] = openness.sin(); + } + "right_pages" => { + p[4] = -openness; + p[0] = openness.sin(); + } + "flip_page1" => { + p[4] = openness - openness * 2.0 * flip1; + p[0] = openness.sin(); + } + "flip_page2" => { + p[4] = openness - openness * 2.0 * flip2; + p[0] = openness.sin(); + } + _ => {} + } +} +/// `CopperGolemStatueModel.setupAnim`. +fn statue_pose(name: &str, p: &mut [f32; 9]) { + if name == "root" { + p[1] = 0.0; + p[5] = PI; + } +} +fn statue_layer(pose: &str) -> &'static str { + match pose { + "running" => "copper_golem_running", + "sitting" => "copper_golem_sitting", + "star" => "copper_golem_star", + _ => "copper_golem", + } +} + +/// `SpecialModelRenderer.getExtents`. +pub(super) fn extents(renderer: &ItemRenderer, model: &SpecialModel) -> Vec { + let mut out = Vec::new(); + let id = Mat4::IDENTITY; + let mut add = |key: &str, adjust: Adjust| { + if let Some(part) = renderer.part(key) { + extents_of(part, "root", id, adjust, &mut out); + } + }; + match &model.kind { + SpecialKind::Bell => add("bell", &none), + SpecialKind::Banner { .. } => { + // `BannerRenderer.getExtents`: the standing models only. + add("standing_banner", &none); + add("standing_banner_flag", &flag_pose); + } + SpecialKind::Book { + open_angle, + page1, + page2, + } => add( + "book", + &book_pose(open_angle * (PI / 180.0), *page1, *page2), + ), + SpecialKind::Conduit => add("conduit_shell", &none), + SpecialKind::Chest { + openness, + chest_type, + .. + } => add(chest_model(chest_type), &chest_pose(*openness)), + SpecialKind::CopperGolemStatue { pose, .. } => add(statue_layer(pose), &statue_pose), + SpecialKind::DecoratedPot => { + if let Some(base) = renderer.part("decorated_pot_base") { + // `neck`, `top` and `bottom` are posed from an identity stack. + for name in ["neck", "top", "bottom"] { + if let Some(part) = child(base, name) { + extents_of(part, name, id, &none, &mut out); + } + } + } + } + SpecialKind::EndCube { .. } => {} + SpecialKind::Head { + kind, animation, .. + } => add(skull_layer(kind), &skull_pose(kind, *animation)), + SpecialKind::PlayerHead => add("player", &none), + SpecialKind::ShulkerBox { openness, .. } => add("shulker_box", &shulker_pose(*openness)), + SpecialKind::Shield => add("shield", &none), + SpecialKind::Trident => add("trident", &none), + } + out +} + +/// Banner pattern layers of a `minecraft:banner_patterns` value: the +/// pattern identifier (or inline asset) and the dye. +fn pattern_layers(v: &Value) -> Vec<(String, String)> { + v.as_array() + .into_iter() + .flatten() + .filter_map(|layer| { + let pattern = match &layer["pattern"] { + Value::String(s) => s.clone(), + Value::Object(o) => format!("#asset:{}", o.get("asset_id")?.as_str()?), + _ => return None, + }; + let color = layer["color"].as_str()?.to_owned(); + Some((pattern, color)) + }) + .collect() +} +fn pattern_texture(host: &dyn SpecialHost, banner: bool, pattern: &str) -> Option { + if let Some(asset) = pattern.strip_prefix("#asset:") { + let path = asset.strip_prefix("minecraft:").unwrap_or(asset); + return Some(format!( + "entity/{}/{path}", + if banner { "banner" } else { "shield" } + )); + } + if banner { + host.banner_texture(pattern) + } else { + host.shield_texture(pattern) + } +} +/// `DecoratedPotPatterns.getPatternFromItem` for one side's sherd item. +fn pot_side(item: Option<&str>) -> String { + let item = item.map(|i| i.strip_prefix("minecraft:").unwrap_or(i)); + match item.and_then(|i| i.strip_suffix("_pottery_sherd")) { + Some(name) => format!("entity/decorated_pot/{name}_pottery_pattern"), + None => "entity/decorated_pot/decorated_pot_side".to_owned(), + } +} +/// `PotDecorations` as [back, left, right, front] item ids, from the list +/// codec or a keyed object. +fn pot_sides(v: &Value) -> [Option; 4] { + let id = |s: &Value| match s { + Value::String(s) => Some(s.clone()), + Value::Object(o) => o.get("id").and_then(Value::as_str).map(str::to_owned), + _ => None, + }; + match v { + Value::Array(a) => std::array::from_fn(|i| a.get(i).and_then(id)), + Value::Object(o) => ["back", "left", "right", "front"].map(|k| o.get(k).and_then(id)), + _ => Default::default(), + } +} + +/// `SpecialModelRenderer.submit`. +#[allow(clippy::too_many_arguments)] +pub(super) fn submit( + renderer: &ItemRenderer, + model: &SpecialModel, + argument: &Value, + has_foil: bool, + pose: Mat4, + sprites: &HashMap, + host: &dyn SpecialHost, + sink: &mut dyn ItemSink, +) { + let white = argb(-1); + let mut part = |key: &str, adjust: Adjust, texture: &str, color: u32, foil: Foil| { + if let (Some(p), Some(r)) = (renderer.part(key), sprites.get(texture).copied()) { + draw(p, "root", pose, adjust, r, color, foil, sink); + } + }; + match &model.kind { + SpecialKind::Bell => part("bell", &none, "entity/bell/bell_body", white, Foil::None), + SpecialKind::Book { + open_angle, + page1, + page2, + } => part( + "book", + &book_pose(open_angle * (PI / 180.0), *page1, *page2), + "entity/enchantment/enchanting_table_book", + white, + Foil::None, + ), + SpecialKind::Conduit => { + part( + "conduit_shell", + &none, + "entity/conduit/base", + white, + Foil::None, + ); + } + SpecialKind::Chest { + texture, + openness, + chest_type, + } => part( + chest_model(chest_type), + &chest_pose(*openness), + &mapped("chest", texture), + white, + Foil::None, + ), + SpecialKind::ShulkerBox { texture, openness } => part( + "shulker_box", + &shulker_pose(*openness), + &mapped("shulker", texture), + white, + Foil::None, + ), + SpecialKind::CopperGolemStatue { texture, pose: p } => part( + statue_layer(p), + &statue_pose, + &texture_sprite(texture), + white, + Foil::None, + ), + SpecialKind::Head { + kind, + texture, + animation, + } => { + let skin = texture + .as_deref() + .map(|t| format!("entity/{}", t.strip_prefix("minecraft:").unwrap_or(t))) + .unwrap_or_else(|| skull_texture(kind).to_owned()); + part( + skull_layer(kind), + &skull_pose(kind, *animation), + &skin, + white, + Foil::None, + ); + } + SpecialKind::PlayerHead => { + let skin = (!argument.is_null()) + .then(|| host.player_skin(argument)) + .flatten() + .unwrap_or_else(|| "entity/player/wide/steve".to_owned()); + part("player", &none, &skin, white, Foil::None); + } + SpecialKind::Trident => { + let foil = if has_foil { Foil::Standard } else { Foil::None }; + part("trident", &none, "entity/trident/trident", white, foil); + } + SpecialKind::Banner { color, wall } => { + let (main, flag) = if *wall { + ("wall_banner", "wall_banner_flag") + } else { + ("standing_banner", "standing_banner_flag") + }; + part(main, &none, "entity/banner/banner_base", white, Foil::None); + part( + flag, + &flag_pose, + "entity/banner/banner_base", + white, + Foil::None, + ); + // `submitPatterns`: the base layer in the banner's colour, then up to 16 layers. + part( + flag, + &flag_pose, + "entity/banner/base", + dye(color), + Foil::None, + ); + for (pattern, color) in pattern_layers(argument).into_iter().take(16) { + if let Some(t) = pattern_texture(host, true, &pattern) { + part(flag, &flag_pose, &t, dye(&color), Foil::None); + } + } + } + SpecialKind::Shield => { + let patterns = pattern_layers(&argument["minecraft:banner_patterns"]); + let base_color = argument["minecraft:base_color"].as_str(); + let has_patterns = !patterns.is_empty() || base_color.is_some(); + let base = if has_patterns { + "entity/shield/shield_base" + } else { + "entity/shield/shield_base_nopattern" + }; + let foil = if has_foil && !has_patterns { + Foil::Standard + } else { + Foil::None + }; + part("shield", &none, base, white, foil); + if has_patterns { + part( + "shield", + &none, + "entity/shield/base", + dye(base_color.unwrap_or("white")), + Foil::None, + ); + for (pattern, color) in patterns.into_iter().take(16) { + if let Some(t) = pattern_texture(host, false, &pattern) { + part("shield", &none, &t, dye(&color), Foil::None); + } + } + if has_foil { + // `patternedShieldGlint`: the glint alone over the model. + part("shield", &none, base, white, Foil::Standard); + } + } + } + SpecialKind::DecoratedPot => { + let sides = pot_sides(argument); + if let Some(base) = renderer.part("decorated_pot_base") + && let Some(r) = sprites + .get("entity/decorated_pot/decorated_pot_base") + .copied() + { + for name in ["neck", "top", "bottom"] { + if let Some(p) = child(base, name) { + draw(p, name, pose, &none, r, white, Foil::None, sink); + } + } + } + if let Some(side_parts) = renderer.part("decorated_pot_sides") { + for (i, name) in ["back", "left", "right", "front"].into_iter().enumerate() { + let texture = pot_side(sides[i].as_deref()); + if let (Some(p), Some(r)) = (child(side_parts, name), sprites.get(&texture)) { + draw(p, name, pose, &none, *r, white, Foil::None, sink); + } + } + } + } + // `EndCubeSpecialRenderer` draws the end portal/gateway effect; no + // bundled item uses it. + SpecialKind::EndCube { .. } => {} + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn pot_sides_read_both_shapes() { + let list = serde_json::json!(["minecraft:brick", "minecraft:angler_pottery_sherd"]); + let sides = pot_sides(&list); + assert_eq!( + pot_side(sides[0].as_deref()), + "entity/decorated_pot/decorated_pot_side" + ); + assert_eq!( + pot_side(sides[1].as_deref()), + "entity/decorated_pot/angler_pottery_pattern" + ); + assert_eq!( + pot_side(sides[3].as_deref()), + "entity/decorated_pot/decorated_pot_side" + ); + } + #[test] + fn texture_ids_map_to_sprites() { + assert_eq!( + texture_sprite("minecraft:textures/entity/copper_golem/copper_golem.png"), + "entity/copper_golem/copper_golem" + ); + assert_eq!( + mapped("chest", "minecraft:christmas"), + "entity/chest/christmas" + ); + } +} diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index e5080ea4a..835dbd637 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -5,6 +5,7 @@ pub mod advancements; pub mod ambience; pub mod animate_tick; pub mod assets; +pub mod atlas_sources; pub mod attribute_updates; pub mod audio; pub mod banner; @@ -44,6 +45,7 @@ pub mod hud; pub mod hunger; pub mod input; pub mod item_data; +pub mod item_render; pub mod items; pub mod java_text; pub mod key_names; diff --git a/crates/horizon-client/src/mobs/anim.rs b/crates/horizon-client/src/mobs/anim.rs index 8644e25a4..27f441adc 100644 --- a/crates/horizon-client/src/mobs/anim.rs +++ b/crates/horizon-client/src/mobs/anim.rs @@ -101,6 +101,7 @@ impl AnimState { pub fn end_tick(&mut self, _swinging: bool) {} } /// Part poses for one draw, keyed by part name. +#[derive(Clone)] pub struct Poses { map: HashMap, dummy: [f32; 9], diff --git a/crates/horizon-client/src/mobs/render.rs b/crates/horizon-client/src/mobs/render.rs index 1ca00218a..7dce44559 100644 --- a/crates/horizon-client/src/mobs/render.rs +++ b/crates/horizon-client/src/mobs/render.rs @@ -915,7 +915,6 @@ fn render_visible( for (part, uv, color) in extra { draw(part, base, &poses, *uv, *color, light, overlay, out); } - held_items(m, &model, base, &poses, atlas, light, out); let mut all_layers = layers(m); // WardenRenderer: the translucent emissive layers fade with the animations. if m.species() == Species::Warden { @@ -1013,57 +1012,6 @@ pub fn part_matrix( .iter() .find_map(|c| part_matrix(c, m, poses, name, x_offset)) } -/// ItemModel thirdperson_righthand display transform by item model parent. -fn item_display(item: &str) -> ([f32; 3], [f32; 3], [f32; 3]) { - let name = item.trim_start_matches("minecraft:"); - if name == "bow" { - ([-80.0, 260.0, -40.0], [-1.0, -2.0, 2.5], [0.9; 3]) - } else if name == "crossbow" { - ([-90.0, 0.0, -60.0], [2.0, 0.1, -3.0], [0.9; 3]) - } else if name == "fishing_rod" - || name == "carrot_on_a_stick" - || name == "warped_fungus_on_a_stick" - { - ([0.0, 90.0, 55.0], [0.0, 4.0, 2.5], [0.85; 3]) - } else if [ - "_sword", - "_axe", - "_pickaxe", - "_shovel", - "_hoe", - "trident", - "mace", - "stick", - "bone", - "blaze_rod", - ] - .iter() - .any(|t| name.ends_with(t)) - { - ([0.0, -90.0, 55.0], [0.0, 4.0, 0.5], [0.85; 3]) - } else { - ([0.0, 0.0, 0.0], [0.0, 3.0, 1.0], [0.55; 3]) - } -} -/// The sprite drawn for a held item (bow pull frames while charging). -fn item_sprite(m: &Mob, item: &str) -> String { - let name = item.trim_start_matches("minecraft:"); - if name == "bow" && m.extra.using_item > 0 { - let pull = m.extra.using_item as f32 * 0.05; - let frame = if pull >= 0.9 { - 2 - } else if pull >= 0.65 { - 1 - } else { - 0 - }; - return format!("item/bow_pulling_{frame}"); - } - if name == "crossbow" && m.extra.flag2 { - return "item/crossbow_arrow".into(); - } - format!("item/{name}") -} /// The hand of a mob in model space, up to the item's own transform /// (`ItemInHandLayer.submitArmWithItem`). fn hand_base( @@ -1122,10 +1070,10 @@ pub fn part_transform( anim::setup(m, &s, &mut poses, &data.animations); part_matrix(&model, base, &poses, part, 0.0) } -/// Where a mob holds a block item (`block/block` thirdperson display: turned -/// 75 and 45 degrees, at 0.375 scale), as the hand transform for `left`, or -/// `None` when the mob shows no held items. -pub fn held_block_transform( +/// The pose a mob's held item is submitted under (`ItemInHandLayer`: +/// `translateToHand`, then the hand offset; the item model adds its own +/// display transform), or `None` when the mob shows no held items. +pub fn held_item_transform( m: &Mob, alpha: f32, camera: glam::DVec3, @@ -1145,106 +1093,5 @@ pub fn held_block_transform( .unwrap_or_else(|| m.kind.model.clone()); let mut poses = Poses::new(&model); anim::setup(m, &s, &mut poses, &data.animations); - let mut t = hand_base(m, &model, base, &poses, left)?; - let ry = if left { -45.0f32 } else { 45.0 }; - t *= glam::Mat4::from_translation(glam::Vec3::new(0.0, 2.5, 0.0) / 16.0); - t *= glam::Mat4::from_quat(glam::Quat::from_euler( - glam::EulerRot::XYZ, - 75.0f32.to_radians(), - ry.to_radians(), - 0.0, - )); - t *= glam::Mat4::from_scale(glam::Vec3::splat(0.375)); - t *= glam::Mat4::from_translation(glam::Vec3::splat(-0.5)); - Some(t) -} -/// ItemInHandLayer: items in the mob's hands. -fn held_items( - m: &Mob, - model: &Part, - base: glam::Mat4, - poses: &Poses, - atlas: Atlas, - light: u32, - out: &mut Vec, -) { - if !super::illager::shows_item(m) { - return; - } - for (item, left) in [(&m.extra.main_hand, false), (&m.extra.off_hand, true)] { - let Some(item) = item else { continue }; - let Some(mut t) = hand_base(m, model, base, poses, left) else { - continue; - }; - let Some(uv) = atlas(&item_sprite(m, item)) else { - continue; - }; - // ItemTransform.apply (mirrored for the left hand). - let (rot, tr, sc) = item_display(item); - let (ry, rz, tx) = if left { - (-rot[1], -rot[2], -tr[0]) - } else { - (rot[1], rot[2], tr[0]) - }; - t *= glam::Mat4::from_translation(glam::Vec3::new(tx, tr[1], tr[2]) / 16.0); - t *= glam::Mat4::from_quat(glam::Quat::from_euler( - glam::EulerRot::XYZ, - rot[0].to_radians(), - ry.to_radians(), - rz.to_radians(), - )); - t *= glam::Mat4::from_scale(glam::Vec3::from(sc)); - t *= glam::Mat4::from_translation(glam::Vec3::splat(-0.5)); - let glint = super::gear::enchanted( - m, - if left { - super::gear::OFF - } else { - super::gear::MAIN - }, - ); - draw_item_plane_with(t, uv, light, if glint { 7 } else { 0 }, out); - } -} -/// A generated item model: the sprite on two faces 1/16 apart. -pub fn draw_item_plane(t: glam::Mat4, uv: [f32; 4], light: u32, out: &mut Vec) { - draw_item_plane_with(t, uv, light, 0, out); -} -/// `draw_item_plane` with an entity shader overlay (7: enchantment glint). -pub fn draw_item_plane_with( - t: glam::Mat4, - uv: [f32; 4], - light: u32, - overlay: u32, - out: &mut Vec, -) { - let (u0, v0, u1, v1) = (uv[0], uv[1], uv[2], uv[3]); - let south = 8.5 / 16.0; - let north = 7.5 / 16.0; - let quads = [ - [ - ([0.0, 0.0, south], [u0, v1]), - ([1.0, 0.0, south], [u1, v1]), - ([1.0, 1.0, south], [u1, v0]), - ([0.0, 1.0, south], [u0, v0]), - ], - [ - ([1.0, 0.0, north], [u1, v1]), - ([0.0, 0.0, north], [u0, v1]), - ([0.0, 1.0, north], [u0, v0]), - ([1.0, 1.0, north], [u1, v0]), - ], - ]; - for q in quads { - for (p, uv) in q { - let pos = t.transform_point3(glam::Vec3::from(p)); - out.push(Vertex { - pos: pos.to_array(), - uv, - layer: overlay, - color: 0xFFFF_FFFF, - light, - }); - } - } + hand_base(m, &model, base, &poses, left) } diff --git a/crates/horizon-client/src/packs.rs b/crates/horizon-client/src/packs.rs index 5e0e35515..b5205922b 100644 --- a/crates/horizon-client/src/packs.rs +++ b/crates/horizon-client/src/packs.rs @@ -3,7 +3,7 @@ //! and High Contrast packs, `pack.mcmeta` metadata and format compatibility, //! and an overlay resource root that layers the enabled packs over the //! vanilla resources (later packs win), so every loader sees one tree. -mod pattern; +pub mod pattern; use crate::{text::Text, zip::Zip}; use pattern::Pattern; use std::{