Merge remote-tracking branch 'origin/main' into fix/dg1-villager-doors

This commit is contained in:
Ludovic Marie
2026-10-24 09:07:55 +02:00
274 changed files with 3488 additions and 929 deletions
+5
View File
@@ -85,6 +85,11 @@ mods = ["horizon-mods/runtime"]
# Records the call sites of mob random draws (`mob_ai_probe` traces).
rng-trace = ["horizon-core/rng-trace"]
# Its own name, not `probe`: Cargo copies every crate's examples into one target/<profile>/examples.
[[example]]
name = "client_probe"
path = "examples/probe/main.rs"
[lints]
workspace = true
@@ -41,7 +41,7 @@ pub fn main(names: &[&str], run: fn(&str) -> Option<ExitCode>) -> ExitCode {
let name = std::env::args().nth(1).unwrap_or_default();
run(&name).unwrap_or_else(|| {
eprintln!(
"usage: probe <name> [arguments...]\nprobes: {}",
"usage: client_probe <name> [arguments...]\nprobes: {}",
names.join(" ")
);
ExitCode::from(2)
@@ -293,6 +293,47 @@ fn spawn_seed(index: usize) -> i64 {
1000 + 7919 * index as i64
}
/// `Villager.spawnGolemIfNeeded` for villager `a`, the game's way: the golem
/// draws from the level's random and joins the scenario's mobs next tick,
/// seeded as the oracle seeds what a tick spawned.
fn summon_golem(
mobs: &mut [Mob],
a: usize,
needed: usize,
w: &MobWorld,
types: &MobTypes,
born: &mut Vec<Mob>,
level_random: &mut LegacyRandom,
) {
use horizon_client::mobs::{villager, villager_brain};
let Some(near) = villager::golem_summoners(mobs, a, w.game_time, needed) else {
return;
};
let kind = Arc::new(
types
.types
.get("minecraft:iron_golem")
.expect("iron golem")
.clone(),
);
let index = mobs.len() + born.len();
let p = mobs[a].position;
let start = [p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32];
let golem = villager::summon_golem(w, start, level_random, |random, at, yaw| {
let mut m = Mob::new(100_000 + index as u32, kind.clone(), at, yaw);
villager::finalize_summoned_golem(&mut m, random);
m
});
let Some(mut golem) = golem else {
return;
};
golem.random = LegacyRandom::new(spawn_seed(index));
born.push(golem);
for j in near {
villager_brain::golem_detected(&mut mobs[j], w.game_time);
}
}
/// Villager events that act at once in vanilla (`TradeWithVillager` and
/// `VillagerMakeLove` write the other villager directly).
fn villager_events(
@@ -304,6 +345,7 @@ fn villager_events(
items: &Items,
born: &mut Vec<Mob>,
day_time: i64,
level_random: &mut LegacyRandom,
) {
use horizon_client::mobs::villager;
let index = |mobs: &[Mob], id: u32| {
@@ -314,6 +356,7 @@ fn villager_events(
while i < events.len() {
match events[i] {
MobEvent::VillagerMeet { mob, other } => {
events.remove(i);
if let (Some(a), Some(b)) = (index(mobs, mob), index(mobs, other)) {
let meeting = villager::meet(mobs, a, b, w.game_time, |item| {
items.get(item).map_or(64, |i| i.max_stack)
@@ -322,8 +365,16 @@ fn villager_events(
meeting.thrown.is_empty(),
"villagers toss items: not modelled here"
);
if meeting.gossiped {
summon_golem(mobs, a, 5, w, types, born, level_random);
}
}
}
MobEvent::GolemCheck { mob, needed } => {
events.remove(i);
if let Some(a) = index(mobs, mob) {
summon_golem(mobs, a, needed, w, types, born, level_random);
}
}
MobEvent::VillagerBirth {
parent,
@@ -1167,6 +1218,7 @@ pub fn main() -> horizon_client::Result<()> {
&items,
&mut born,
s.time,
&mut scratch,
);
horizon_client::mobs::warden::hear_mob_events(&mut mobs, &events, from, &w);
// Melee hits on other mobs land during the attacker's tick
+39
View File
@@ -425,6 +425,29 @@ fn split_id(id: &str) -> (String, String) {
None => ("minecraft".to_owned(), id.to_owned()),
}
}
/// The slot under the cursor, for the search tab's keys.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Hover {
Nothing,
/// A display slot (`isCreativeSlot`), showing an item or past the end.
Display {
filled: bool,
},
/// Any other slot: the hotbar row, or the inventory tab's slots.
Slot,
}
/// `CreativeModeInventoryScreen.keyPressed` on the search tab: whether a
/// key is a hotbar swap on the hovered slot instead of text for the search
/// box. `numeric` is `getNumericKeyValue().isPresent()` (the digit and keypad
/// keys); `hotbar_key` is a `keyHotbarSlots` key. Over an empty display slot
/// the key types (`doQuickSwap` is false), and `checkHotbarKeyPressed` needs
/// a hovered slot and an empty cursor.
pub fn search_key_swaps(numeric: bool, hotbar_key: bool, hover: Hover, carrying: bool) -> bool {
let quick_swap = hover != Hover::Display { filled: false };
quick_swap && numeric && hotbar_key && !carrying && hover != Hover::Nothing
}
/// What a click on an item tab's display slot does besides changing the
/// carried stack.
#[derive(Clone, PartialEq, Debug)]
@@ -529,6 +552,22 @@ mod tests {
(carried, effect)
}
#[test]
fn search_tab_number_keys_swap_over_a_slot_before_typing() {
let filled = Hover::Display { filled: true };
let empty = Hover::Display { filled: false };
// Over an item, the hotbar row or another slot: the hotbar swap.
assert!(search_key_swaps(true, true, filled, false));
assert!(search_key_swaps(true, true, Hover::Slot, false));
// Over an empty display slot, nothing or with a carried stack: text.
assert!(!search_key_swaps(true, true, empty, false));
assert!(!search_key_swaps(true, true, Hover::Nothing, false));
assert!(!search_key_swaps(true, true, filled, true));
// Letters always type; so do the digits no hotbar key is bound to.
assert!(!search_key_swaps(false, false, filled, false));
assert!(!search_key_swaps(true, false, filled, false));
}
#[test]
fn display_slot_clicks_follow_slot_clicked() {
use crate::menu::Input::*;
+3 -2
View File
@@ -102,7 +102,8 @@ enum Provider {
/// One font (`FontSet`): its providers and the glyphs resolved so far.
struct FontSet {
providers: Vec<Provider>,
glyphs: HashMap<char, Glyph>,
/// Every char drawn looks up here, so the hasher is Fx, not SipHash.
glyphs: crate::fast_hash::FxHashMap<char, Glyph>,
/// `glyphsByWidth` for obfuscated text (built on first use).
by_width: Option<HashMap<u32, Vec<char>>>,
}
@@ -647,7 +648,7 @@ impl Font {
.collect();
FontSet {
providers,
glyphs: HashMap::new(),
glyphs: Default::default(),
by_width: None,
}
}
+134 -60
View File
@@ -285,11 +285,9 @@ struct Options {
benchmark: Option<String>,
/// `--dev-mod PATH` (repeatable): mods always on and reloaded when rebuilt.
dev_mods: Vec<PathBuf>,
/// `--server-thread` or `HORIZON_SERVER_THREAD=1`: single player runs on an
/// integrated server thread (game/integrated.rs), as vanilla's does. Off by
/// default again until a server's players reach parity with the in-frame
/// world (signs, books, totems, keep_inventory...); `--no-server-thread`
/// keeps it off.
/// Single player runs on an integrated server thread (game/integrated.rs),
/// as vanilla's does: the default. `--in-frame` (or `--no-server-thread`,
/// or `HORIZON_SERVER_THREAD=0`) runs the world in the frame instead.
server_thread: bool,
/// Set on the integrated server's own options: it draws nothing, so it skips meshing.
integrated: bool,
@@ -347,7 +345,7 @@ impl Options {
dev_mods: Vec::new(),
// The command harness (HORIZON_COMMAND_SCRIPT) drives the world
// itself, without the event loop: it stays in the frame.
server_thread: std::env::var("HORIZON_SERVER_THREAD").is_ok_and(|v| v == "1")
server_thread: std::env::var("HORIZON_SERVER_THREAD").map_or(true, |v| v != "0")
&& std::env::var_os("HORIZON_COMMAND_SCRIPT").is_none(),
integrated: false,
};
@@ -357,7 +355,7 @@ impl Options {
match arg.as_str() {
"--help" | "-h" => {
println!(
"Horizon — Minecraft Java Edition {} in Rust\n\n --resources PATH Prepared resources (horizon-prepare)\n --render-distance N Chunks, 2..64 (default 12)\n --world NAME World folder under saves/ (default \"New World\")\n --seed N World seed for new worlds (default 0)\n --width N, --height N Window size (default 1280 x 720)\n --creative Creative mode (default survival)\n --test-terrain Simple test terrain instead of vanilla generation\n --frames N Exit after N frames (testing)\n --world-frames N Exit after N frames drawn in the world (testing)\n --smoke-report PATH Write a JSON report on exit\n --benchmark SCENARIO Run a benchmark (standard, village, forest, ocean, mountain), write its report to benchmarks/ and quit\n --control Accept horizon-ctl commands on a local socket\n --control-socket PATH Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n --server HOST[:PORT] Join a multiplayer server (offline mode) at start\n --name NAME Player name for multiplayer (default: generated once, kept in horizon-player.txt)\n --session-file PATH Signed-in account from the launcher (read once, then deleted)\n --dev-mod PATH A Horizon mod (.hmod or folder) to develop: always on, reloaded when rebuilt\n --server-thread Run single player's world on its server thread (not at parity yet)\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause.",
"Horizon — Minecraft Java Edition {} in Rust\n\n --resources PATH Prepared resources (horizon-prepare)\n --render-distance N Chunks, 2..64 (default 12)\n --world NAME World folder under saves/ (default \"New World\")\n --seed N World seed for new worlds (default 0)\n --width N, --height N Window size (default 1280 x 720)\n --creative Creative mode (default survival)\n --test-terrain Simple test terrain instead of vanilla generation\n --frames N Exit after N frames (testing)\n --world-frames N Exit after N frames drawn in the world (testing)\n --smoke-report PATH Write a JSON report on exit\n --benchmark SCENARIO Run a benchmark (standard, village, forest, ocean, mountain), write its report to benchmarks/ and quit\n --control Accept horizon-ctl commands on a local socket\n --control-socket PATH Control socket path (default $XDG_RUNTIME_DIR/horizon-control.sock)\n --server HOST[:PORT] Join a multiplayer server (offline mode) at start\n --name NAME Player name for multiplayer (default: generated once, kept in horizon-player.txt)\n --session-file PATH Signed-in account from the launcher (read once, then deleted)\n --dev-mod PATH A Horizon mod (.hmod or folder) to develop: always on, reloaded when rebuilt\n --in-frame Run single player's world in the frame, not on its server thread\n\nControls: mouse look, WASD move, Space jump, Left Shift sneak, Left Ctrl sprint,\nleft click break, right click place/use, 1-9/scroll hotbar, E inventory,\nQ drop, F3 debug, Esc pause.",
horizon_core::VANILLA_VERSION
);
return Ok(None);
@@ -372,7 +370,7 @@ impl Options {
"--offscreen" => o.offscreen = true,
"--control" => o.control = Some(horizon_client::control::default_path()),
"--server-thread" => o.server_thread = true,
"--no-server-thread" => o.server_thread = false,
"--in-frame" | "--no-server-thread" => o.server_thread = false,
_ => {
let value = args
.next()
@@ -1446,6 +1444,8 @@ struct Game<'a> {
mount_menu: mount_menu::MountMenu,
/// The player's fishing hook.
hook: Option<fishing::Hook>,
/// The other players' hooks a server tracks to this client.
remote_hooks: Vec<fishing::RemoteHook>,
tridents: Vec<trident::ThrownTrident>,
rockets: Vec<fireworks::Rocket>,
/// Ominous trial spawners' item spawners.
@@ -1827,6 +1827,55 @@ impl Game<'_> {
.is_some_and(|i| i.glider && (i.max_damage == 0 || s.damage + 1 < i.max_damage))
})
}
/// What the window decides for its player's body every tick, in frame and
/// on a server alike: the look (Player.travel steers sprint-swimming by
/// the pitch), Auto Jump (LocalPlayer.sendPosition), the slowdown of an
/// item in use (LocalPlayer.modifyInput), the helmet's Respiration
/// (decreaseAirSupply), the wings, leather boots on powder snow
/// (PowderSnowBlock.canEntityWalkOnPowderSnow), freeze-immune wear
/// (LivingEntity.canFreeze) and the dimension's FAST_LAVA.
pub(crate) fn sync_player_body(&mut self) {
let glider = self.glider_worn();
let item_use_speed = self
.using
.and_then(|(slot, _)| {
if slot == shield::OFFHAND_SLOT {
self.offhand.as_ref()
} else {
self.inventory.get(slot)?.as_ref()
}
})
.and_then(|s| self.res.items().get(&s.item))
.map(|i| i.use_speed);
let respiration = self.armor[0]
.as_ref()
.map_or(0, |s| s.enchantment_level("minecraft:respiration") as i32);
let leather_boots = self.armor[3]
.as_ref()
.is_some_and(|s| &*s.item == "minecraft:leather_boots");
let immune = self
.res
.items()
.item_tags
.get("minecraft:freeze_immune_wearables");
let freeze_immune = self
.armor
.iter()
.flatten()
.any(|s| immune.is_some_and(|t| t.contains(&*s.item)));
let Some(player) = self.player.as_mut() else {
return;
};
player.yaw = self.yaw;
player.pitch = self.pitch;
player.auto_jump_enabled = self.settings.auto_jump;
player.item_use_speed = item_use_speed;
player.respiration = respiration;
player.glider = glider;
player.leather_boots = leather_boots;
player.freeze_immune = freeze_immune;
player.fluids.fast_lava = self.dim == Dim::Nether;
}
fn held_slot(&self) -> usize {
match self.hand {
Hand::Main => self.selected,
@@ -3838,7 +3887,12 @@ impl Game<'_> {
}
self.crack_particle(crack.0, crack.1, state);
let m = self.mining.as_mut().ok_or("mining")?;
if m.progress >= 1.0 {
// ServerPlayerGameMode breaks a player's block at once only when it is instant (START's
// insta-mine); otherwise it waits for the client's STOP_DESTROY_BLOCK
// (`guest_stop_digging`), never breaking it on its own count. Breaking it here would
// take the block from under the player's crack before the player's client predicts the
// break, so it gets neither particles nor sound.
if m.progress >= 1.0 && (self.lan_acting.is_none() || m.ticks == 1) {
let pos = m.pos;
self.mining = None;
self.break_block(pos)?;
@@ -4050,7 +4104,7 @@ impl Game<'_> {
let riding = self.riding.is_some();
let ghast_collisions = self.happy_ghast_player_collisions();
let spin_targets = self.spin_targets();
let glider = self.glider_worn();
self.sync_player_body();
let Some(player) = self.player.as_mut() else {
// A dedicated server has no local player: the world still runs.
if self.options.dedicated.is_some() {
@@ -4082,46 +4136,10 @@ impl Game<'_> {
if !riding {
self.previous_position = player.position;
}
player.yaw = self.yaw;
let spectator = self.mode == horizon_client::command::args::GameMode::Spectator;
player.may_fly = self.creative || spectator;
// LocalPlayer.sendPosition: autoJumpEnabled follows the option.
player.auto_jump_enabled = self.settings.auto_jump;
player.invulnerable = self.creative || spectator;
player.spectator = spectator;
player.respiration = self.armor[0]
.as_ref()
.map_or(0, |s| s.enchantment_level("minecraft:respiration") as i32);
player.pitch = self.pitch;
player.glider = glider;
// LocalPlayer.modifyInput: walking while using an item.
player.item_use_speed = self
.using
.and_then(|(slot, _)| {
if slot == shield::OFFHAND_SLOT {
self.offhand.as_ref()
} else {
self.inventory.get(slot)?.as_ref()
}
})
.and_then(|s| self.res.items().get(&s.item))
.map(|i| i.use_speed);
// PowderSnowBlock.canEntityWalkOnPowderSnow and LivingEntity.canFreeze.
player.leather_boots = self.armor[3]
.as_ref()
.is_some_and(|s| &*s.item == "minecraft:leather_boots");
let immune = self
.res
.items()
.item_tags
.get("minecraft:freeze_immune_wearables");
player.freeze_immune = self
.armor
.iter()
.flatten()
.any(|s| immune.is_some_and(|t| t.contains(&*s.item)));
// The dimension's FAST_LAVA: the Nether's lava pushes harder.
player.fluids.fast_lava = self.dim == Dim::Nether;
player.spin_targets = spin_targets;
let grounded = player.ground.on_ground;
let before = (
@@ -6004,6 +6022,37 @@ impl Game<'_> {
}
true
}
/// `CreativeModeInventoryScreen.keyPressed` on the search tab: a hotbar
/// key over a slot swaps before the search box sees it.
fn search_tab_hotbar_key(&mut self, code: KeyCode) -> bool {
use horizon_client::creative::{Hover, search_key_swaps};
let hotbar_key = HOTBAR_DIGITS.contains(&code);
let numeric = hotbar_key || NUMERIC_KEYS.contains(&code);
if !numeric {
return false;
}
let Some(size) = self
.renderer
.as_ref()
.map(|r| [r.config.width, r.config.height])
else {
return false;
};
let batch = HudBatch::new(size);
let hover = match self.slot_at(&batch, self.cursor.0, self.cursor.1) {
None => Hover::Nothing,
Some(slot) if slot >= Creative::DISPLAY => {
let first = self.creative_screen.first_row(&self.pack.names);
let shown = self.creative_screen.items(&self.pack.names).len();
Hover::Display {
filled: first * 9 + slot - Creative::DISPLAY < shown,
}
}
Some(_) => Hover::Slot,
};
search_key_swaps(numeric, hotbar_key, hover, self.carried.is_some())
&& self.inventory_hotkey(code)
}
/// Number keys, F and Q over a slot of the open menu: SWAP with a hotbar
/// slot or the off hand, THROW one or the whole stack.
fn inventory_hotkey(&mut self, key: KeyCode) -> bool {
@@ -6019,19 +6068,7 @@ impl Game<'_> {
let Some(slot) = self.slot_at(&batch, self.cursor.0, self.cursor.1) else {
return false;
};
let digit = [
KeyCode::Digit1,
KeyCode::Digit2,
KeyCode::Digit3,
KeyCode::Digit4,
KeyCode::Digit5,
KeyCode::Digit6,
KeyCode::Digit7,
KeyCode::Digit8,
KeyCode::Digit9,
]
.iter()
.position(|k| *k == key);
let digit = HOTBAR_DIGITS.iter().position(|k| *k == key);
let done = match (digit, key) {
(Some(n), _) => self.menu_click(Some(slot), n as i32, Input::Swap),
(None, KeyCode::KeyF) => self.menu_click(Some(slot), 40, Input::Swap),
@@ -10342,6 +10379,11 @@ impl Game<'_> {
if (self.screen == Screen::Inventory
|| (self.screen == Screen::Creative && !self.creative_screen.tab().search))
&& self.inventory_hotkey(key) => {}
// The search tab's number keys (scripted presses; the window's
// keys reach search_tab_hotbar_key before the search box).
_ if self.screen == Screen::Creative
&& self.creative_screen.tab().search
&& self.search_tab_hotbar_key(key) => {}
KeyCode::KeyT if self.screen == Screen::Inventory => self.recipe_focus_search(),
KeyCode::KeyT if self.screen == Screen::Playing => self.open_chat(""),
// key.advancements.
@@ -11213,7 +11255,11 @@ impl ApplicationHandler for Game<'_> {
&& event.state == ElementState::Pressed
&& !matches!(event.physical_key, PhysicalKey::Code(KeyCode::Escape)) =>
{
if let Some(shortcut) = self.edit_shortcut(&event) {
if let PhysicalKey::Code(key) = event.physical_key
&& self.search_tab_hotbar_key(key)
{
// The hovered slot took the key (`ignoreTextInput`).
} else if let Some(shortcut) = self.edit_shortcut(&event) {
self.creative_search_shortcut(shortcut);
} else {
let backspace = event.physical_key == PhysicalKey::Code(KeyCode::Backspace);
@@ -11874,6 +11920,7 @@ impl<'a> Game<'a> {
recipe_ui: Default::default(),
mount_menu: Default::default(),
hook: None,
remote_hooks: Vec::new(),
tridents: Vec::new(),
rockets: Vec::new(),
ominous_spawners: Vec::new(),
@@ -12151,6 +12198,33 @@ impl Game<'_> {
}
}
/// `key.hotbar.1` to `key.hotbar.9` in a menu.
const HOTBAR_DIGITS: [KeyCode; 9] = [
KeyCode::Digit1,
KeyCode::Digit2,
KeyCode::Digit3,
KeyCode::Digit4,
KeyCode::Digit5,
KeyCode::Digit6,
KeyCode::Digit7,
KeyCode::Digit8,
KeyCode::Digit9,
];
/// The other keys `InputConstants.Key.getNumericKeyValue` gives a digit.
const NUMERIC_KEYS: [KeyCode; 11] = [
KeyCode::Digit0,
KeyCode::Numpad0,
KeyCode::Numpad1,
KeyCode::Numpad2,
KeyCode::Numpad3,
KeyCode::Numpad4,
KeyCode::Numpad5,
KeyCode::Numpad6,
KeyCode::Numpad7,
KeyCode::Numpad8,
KeyCode::Numpad9,
];
const STAGES: u32 = 10;
const STAGE_LINES: [&str; 10] = [
"Loading menu",
@@ -988,6 +988,7 @@ impl Game<'_> {
"flashes": self.lightning_seen[1], "flash": self.flash});
// Primed TNT, falling blocks, projectiles, tridents and end crystals.
status["projectiles"] = json!(self.projectiles_status());
status["maps"] = json!(self.maps_status());
// The particles made so far, by type.
status["particles"] = json!(self.particles.made());
// The world border this side knows of.
+12 -6
View File
@@ -69,12 +69,18 @@ impl Game<'_> {
let lo = Vec3::new(f.pos[0] - half, f.pos[1], f.pos[2] - half);
let hi = Vec3::new(f.pos[0] + half, f.pos[1] + 0.8, f.pos[2] + half);
let b = horizon_core::geometry::Aabb::new(lo, hi);
if let Some(p) = self.player_view()
&& p.alive
&& p.bounds.intersects(b)
{
self.mob_hits_player_kind(6.0, f.pos, "minecraft:indirect_magic");
}
// Every player in the box, the server's players too.
let pos = f.pos;
let bite = move |g: &mut Self| {
if let Some(p) = g.player_view()
&& p.alive
&& p.bounds.intersects(b)
{
g.mob_hits_player_kind(6.0, pos, "minecraft:indirect_magic");
}
};
bite(self);
self.each_guest_hit(bite);
for m in &mut self.mobs {
let ally = matches!(
m.species(),
+241 -41
View File
@@ -2,6 +2,7 @@
//! bobbing, lure and bite timers, open water, hooking mobs, retrieving the
//! `gameplay/fishing` loot) and `FishingHookRenderer` (bobber and line).
use super::{Game, view_vector};
use horizon_client::lan::{entity::States, hub::Hub};
use horizon_client::{
blocks::Fluid,
collisions::SceneCollisions,
@@ -15,7 +16,10 @@ use horizon_core::{
geometry::{Aabb, Vec3, trig},
random::RandomSource,
};
use std::sync::Arc;
use horizon_protocol::entity_data::{Value, serializer};
use std::{collections::HashMap, sync::Arc};
use super::lan_actions::GuestPlay;
#[derive(Clone, Copy, Debug, PartialEq)]
enum State {
@@ -24,6 +28,8 @@ enum State {
Hooked(u32),
}
pub(super) struct Hook {
/// Its entity id, which a server's players track it under.
id: u32,
position: Vec3,
previous: Vec3,
velocity: Vec3,
@@ -114,7 +120,9 @@ impl Game<'_> {
);
// A spawned hook's start position is its feet: centre the box on the eye.
let start = Vec3::new(start.x, start.y - SIZE / 2.0, start.z);
self.next_entity += 1;
self.hook = Some(Hook {
id: self.next_entity,
position: start,
previous: start,
velocity: v,
@@ -562,12 +570,17 @@ impl Game<'_> {
lerp(h.previous.z, h.position.z),
))
}
/// FishingHookRenderer: the bobber, a camera-facing half-block quad
/// centred on the hook.
/// FishingHookRenderer: the bobbers (this player's and the others' a
/// server tracks), camera-facing half-block quads centred on the hooks.
pub(super) fn fishing_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec<Vertex>) {
let Some(p) = self.hook_position(alpha) else {
let hooks: Vec<glam::DVec3> = self
.hook_position(alpha)
.into_iter()
.chain(self.remote_hook_ends(alpha).into_iter().map(|(h, _)| h))
.collect();
if hooks.is_empty() {
return;
};
}
let Some(r) = self
.gui
.atlas
@@ -577,56 +590,57 @@ impl Game<'_> {
else {
return;
};
let light = self
.world
.light(p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32);
let packed = (u32::from(light >> 4) * 16) | ((u32::from(light & 15) * 16) << 8);
let forward = glam::DVec3::from_array(view_vector(self.yaw, self.pitch));
let right = forward.cross(glam::DVec3::Y).normalize_or_zero();
let up = right.cross(forward).normalize_or_zero();
let s = 0.25;
let corners = [
p - right * s - up * s,
p + right * s - up * s,
p + right * s + up * s,
p - right * s + up * s,
];
let uv = [[r.u0, r.v1], [r.u1, r.v1], [r.u1, r.v0], [r.u0, r.v0]];
for (v, uv) in corners.iter().zip(uv) {
out.push(Vertex {
normal: [0; 4],
pos: (*v - camera).as_vec3().to_array(),
uv,
layer: 0,
color: 0xFFFF_FFFF,
light: packed,
});
for p in hooks {
let light =
self.world
.light(p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32);
let packed = (u32::from(light >> 4) * 16) | ((u32::from(light & 15) * 16) << 8);
let corners = [
p - right * s - up * s,
p + right * s - up * s,
p + right * s + up * s,
p - right * s + up * s,
];
for (v, uv) in corners.iter().zip(uv) {
out.push(Vertex {
normal: [0; 4],
pos: (*v - camera).as_vec3().to_array(),
uv,
layer: 0,
color: 0xFFFF_FFFF,
light: packed,
});
}
}
}
/// FishingHookRenderer: the line, 16 black `lines` segments sagging from
/// a quarter block above the hook to the rod in the player's hand,
/// FishingHookRenderer: each line, 16 black `lines` segments sagging
/// from a quarter block above the hook to the rod in its owner's hand,
/// `width` pixels wide (`Window.getAppropriateLineWidth`).
pub(super) fn fishing_line(&self, alpha: f64, size: [u32; 2]) -> Vec<Line> {
let (Some(hook), Some(hand)) = (
self.hook_position(alpha),
self.rod_hand_position(alpha, size),
) else {
return Vec::new();
};
let offset = (hand - (hook + glam::DVec3::new(0.0, 0.25, 0.0))).as_vec3();
let point = |a: f32| {
let y = offset.y * (a * a + a) * 0.5 + 0.25;
hook + glam::Vec3::new(offset.x * a, y, offset.z * a).as_dvec3()
};
let own = self
.hook_position(alpha)
.zip(self.rod_hand_position(alpha, size));
let width = horizon_client::gfx::outline_width(size[0]);
(0..16)
.map(|i| Line {
let mut lines = Vec::new();
for (hook, hand) in own.into_iter().chain(self.remote_hook_ends(alpha)) {
let offset = (hand - (hook + glam::DVec3::new(0.0, 0.25, 0.0))).as_vec3();
let point = |a: f32| {
let y = offset.y * (a * a + a) * 0.5 + 0.25;
hook + glam::Vec3::new(offset.x * a, y, offset.z * a).as_dvec3()
};
lines.extend((0..16).map(|i| Line {
start: point(i as f32 / 16.0).to_array(),
end: point((i + 1) as f32 / 16.0).to_array(),
color: 0xFF00_0000,
width,
})
.collect()
}));
}
lines
}
/// `FishingHookRenderer.getPlayerHandPos`: on the near plane in first
/// person, beside the body otherwise.
@@ -694,6 +708,20 @@ impl Game<'_> {
}
}
impl Game<'_> {
/// The hooks drawn here, with their owners' ids (0 for this player's own).
pub(super) fn hooks_status(&self) -> Vec<serde_json::Value> {
let at = |p: Vec3| [p.x, p.y, p.z];
let own = self.hook.iter().map(|h| (h.id, 0, h.position));
let others = self
.remote_hooks
.iter()
.map(|h| (h.id, h.owner, h.position));
own.chain(others)
.map(|(id, owner, p)| {
serde_json::json!({"id": id, "kind": "minecraft:fishing_bobber", "owner": owner, "position": at(p)})
})
.collect()
}
/// The hook for `horizon-ctl status`.
pub(super) fn hook_status(&self) -> Option<serde_json::Value> {
let h = self.hook.as_ref()?;
@@ -706,3 +734,175 @@ impl Game<'_> {
}))
}
}
/// A hook a server tracks to this client (`FishingHook.recreateFromPacket`)
/// that another player cast: drawn where the server puts it, its line
/// running to that player's hand.
pub(super) struct RemoteHook {
id: u32,
owner: u32,
position: Vec3,
previous: Vec3,
}
impl Hook {
/// This client's own hook as its server tracks it: drawn, never ticked here.
fn remote(id: u32, at: Vec3) -> Self {
Self {
id,
position: at,
previous: at,
velocity: Vec3::ZERO,
state: State::Flying,
life: 0,
on_ground: false,
nibble: 0,
time_until_lured: 0,
time_until_hooked: 0,
fish_angle: 0.0,
out_of_water: 0,
open_water: true,
luck: 0,
lure: 0,
}
}
/// `FishingHook`'s entity for the players tracking it: the owner's id in
/// its add packet, DATA_HOOKED_ENTITY (the hooked id plus one) and
/// DATA_BITING when they differ from their defaults.
fn track(&self, owner: i32, out: &mut States) {
let p = self.position;
let e = out.add(
self.id as i32,
super::lan::entity_uuid(self.id),
"minecraft:fishing_bobber",
);
e.position = [p.x, p.y, p.z];
e.velocity = [self.velocity.x, self.velocity.y, self.velocity.z];
e.on_ground = self.on_ground;
e.data = owner;
if let State::Hooked(id) = self.state {
e.meta.push((8, serializer::INT, Value::Int(id as i32 + 1)));
}
if self.nibble > 0 {
e.meta.push((9, serializer::BOOLEAN, Value::Bool(true)));
}
}
}
impl Game<'_> {
/// The hooks guests track: the host's and each guest's in the level.
pub(super) fn lan_hook_states(
&self,
host_entity: Option<i32>,
play: &HashMap<u32, GuestPlay>,
hub: &Hub,
out: &mut States,
) {
if let (Some(h), Some(owner)) = (&self.hook, host_entity) {
h.track(owner, out);
}
for g in hub.guests.iter().filter(|g| hub.here(g)) {
if let Some(h) = play.get(&g.conn).and_then(|p| p.hook.as_ref()) {
h.track(g.entity_id, out);
}
}
}
/// `handleAddEntity` for a fishing bobber: this player's own becomes its
/// hook (`Player.fishing`), another player's is drawn on its line to them.
pub(super) fn spawn_remote_hook(&mut self, id: u32, at: Vec3, owner: i32) {
let own = self.remote.as_ref().map(|r| r.entity_id);
if own == Some(owner) {
self.hook = Some(Hook::remote(id, at));
} else {
self.remote_hooks.push(RemoteHook {
id,
owner: owner as u32,
position: at,
previous: at,
});
}
}
/// One tick of interpolation for the hooks a server tracks.
pub(super) fn step_remote_hooks(&mut self, mut step: impl FnMut(u32, Vec3) -> Vec3) {
if self.remote.is_none() {
return;
}
if let Some(h) = self.hook.as_mut() {
h.previous = h.position;
h.position = step(h.id, h.position);
}
for h in &mut self.remote_hooks {
h.previous = h.position;
h.position = step(h.id, h.position);
}
}
/// `FishingHook.onSyncedDataUpdated`: this player's hook is biting
/// (DATA_BITING), which `status` shows as a nibble.
pub(super) fn remote_hook_data(&mut self, id: u32, values: &[(u8, i32, Value)]) {
let Some(h) = self
.hook
.as_mut()
.filter(|h| h.id == id && self.remote.is_some())
else {
return;
};
for (index, _, value) in values {
if let (9, Value::Bool(biting)) = (index, value) {
h.nibble = i32::from(*biting);
}
}
}
pub(super) fn remove_remote_hook(&mut self, id: u32) {
if self.remote.is_some() && self.hook.as_ref().is_some_and(|h| h.id == id) {
self.hook = None;
}
self.remote_hooks.retain(|h| h.id != id);
}
pub(super) fn clear_remote_hooks(&mut self) {
if self.remote.is_some() {
self.hook = None;
}
self.remote_hooks.clear();
}
/// Other players' hooks: the bobber and its line to the owner's hand
/// (`FishingHookRenderer.getPlayerHandPos` in third person), as
/// (hook, hand) this frame.
fn remote_hook_ends(&self, alpha: f64) -> Vec<(glam::DVec3, glam::DVec3)> {
let lerp = |a: Vec3, b: Vec3| {
glam::DVec3::new(
a.x + (b.x - a.x) * alpha,
a.y + (b.y - a.y) * alpha,
a.z + (b.z - a.z) * alpha,
)
};
self.remote_hooks
.iter()
.filter_map(|h| {
let owner = self.mobs.iter().find(|m| m.id == h.owner)?;
let feet = lerp(owner.previous, owner.position);
let body = horizon_client::camera::lerp(
alpha as f32,
owner.previous_body_yaw,
owner.body_yaw,
);
let angle = f64::from(body * (std::f64::consts::PI / 180.0) as f32);
let (sin, cos) = (f64::from(trig::sin(angle)), f64::from(trig::cos(angle)));
// The right arm; a crouching owner's eyes are lower.
let eye = owner.eye_y() - owner.position.y;
let hand = feet
+ glam::DVec3::new(
-cos * 0.35 - sin * 0.8,
eye - 0.45,
-sin * 0.35 + cos * 0.8,
);
Some((lerp(h.previous, h.position), hand))
})
.collect()
}
}
+4 -6
View File
@@ -6,12 +6,10 @@
//! the world's options) with [`Integrated::call`], as vanilla's client calls
//! into its `IntegratedServer`.
//!
//! Opt-in again (`--server-thread` or `HORIZON_SERVER_THREAD=1`) until a
//! server's players reach parity with the in-frame world: on the server
//! thread, signs open no editor, books don't open, a totem doesn't save its
//! holder and death keeps the inventory (#1380, #1366, #1292, #1284 and the
//! other `[server-thread]` issues). LAN guests and dedicated servers use the
//! same code either way.
//! On by default. `--in-frame` (or `--no-server-thread`, or
//! `HORIZON_SERVER_THREAD=0`) runs the world in the frame instead, the
//! escape hatch. LAN guests and dedicated servers use the same code either
//! way.
use super::{
Game, Options, PackResources, Resources, UiResources,
lan::{LanSettings, Owner},
+2
View File
@@ -875,6 +875,7 @@ impl Game<'_> {
.collect();
self.lan_riding(host_entity, &guests, &mut host.hub.riding);
self.lan_entities(host_entity, &host.mob_players, &mut host.hub, &mut states);
self.lan_hook_states(host_entity, &host.play, &host.hub, &mut states);
} else {
states.clear();
}
@@ -1068,6 +1069,7 @@ impl Game<'_> {
}
// A dedicated server has no host player.
self.lan_entities(None, &host.mob_players, &mut host.hub, &mut theirs);
self.lan_hook_states(None, &host.play, &host.hub, &mut theirs);
theirs.as_slice()
} else {
entities
+25 -12
View File
@@ -82,6 +82,8 @@ pub(super) struct GuestPlay {
/// (`LivingEntity.collectEquipmentChanges`).
modifiers: Vec<(String, String)>,
equipped: Option<Vec<Option<ItemStack>>>,
/// The guest's cast fishing hook (`Player.fishing`).
pub(super) hook: Option<super::fishing::Hook>,
}
/// A guest's command waiting for the hub (`LanHost::commands`).
@@ -345,6 +347,7 @@ impl Game<'_> {
std::mem::swap(&mut self.adv.unlocked, &mut g.recipes_unlocked);
std::mem::swap(&mut self.level.recipe_book, &mut g.recipe_book);
std::mem::swap(&mut self.stats, &mut play.stats);
std::mem::swap(&mut self.hook, &mut play.hook);
let adv_loaded = std::mem::replace(&mut self.adv.loaded, true);
let last_inventory = std::mem::replace(&mut self.adv.last_inventory, play.last_inventory);
let death_cause = std::mem::replace(&mut self.ui.death_cause, play.death_cause.take());
@@ -552,6 +555,7 @@ impl Game<'_> {
std::mem::swap(&mut self.adv.unlocked, &mut g.recipes_unlocked);
std::mem::swap(&mut self.level.recipe_book, &mut g.recipe_book);
std::mem::swap(&mut self.stats, &mut play.stats);
std::mem::swap(&mut self.hook, &mut play.hook);
self.adv.loaded = adv_loaded;
play.last_inventory = std::mem::replace(&mut self.adv.last_inventory, last_inventory);
let stat_events = std::mem::take(&mut play.stats.events);
@@ -1055,20 +1059,14 @@ impl Game<'_> {
S::SetBeacon(p) => self.lan_station_beacon(host, conn, p.primary, p.secondary),
S::SelectTrade(p) => self.lan_select_trade(host, conn, p.item),
S::ContainerClose(p) if self.lan_merchant_closed(host, conn, Some(p.container)) => {
let g = &mut host.hub.guests[gi];
if let Some(c) = g.carried.take() {
self.drop_guest_items(host, gi, vec![c]);
}
self.guest_carried_back(host, gi);
}
S::ContainerClose(p)
if self.lan_crafting_closed(host, conn, Some(p.container))
|| self.lan_station_closed(host, conn, Some(p.container))
|| self.lan_mount_closed(host, conn, Some(p.container)) =>
{
let g = &mut host.hub.guests[gi];
if let Some(c) = g.carried.take() {
self.drop_guest_items(host, gi, vec![c]);
}
self.guest_carried_back(host, gi);
}
S::ContainerClick(p) => {
let rules = ItemRules(self.res.items());
@@ -1084,10 +1082,7 @@ impl Game<'_> {
self.guest_container_closed(host, conn);
}
host.hub.container_closed(conn, p.container);
let g = &mut host.hub.guests[gi];
if let Some(c) = g.carried.take() {
self.drop_guest_items(host, gi, vec![c]);
}
self.guest_carried_back(host, gi);
}
S::ChatCommand(c) => self.guest_chat_command(host, conn, &c.command),
S::ChatCommandSigned(p) => self.guest_signed_command(host, conn, p),
@@ -1234,6 +1229,17 @@ impl Game<'_> {
Some(out)
}
/// `AbstractContainerMenu.removed`: what a closing player held on the
/// cursor goes back into their inventory (`placeItemBackInInventory`,
/// dropped only if it doesn't fit), and their client's cursor empties
/// with the inventory it is sent.
fn guest_carried_back(&mut self, host: &mut LanHost, gi: usize) {
if let Some(c) = host.hub.guests[gi].carried.take() {
self.lan_place_back(host, gi, vec![c]);
host.hub.send_inventory(gi);
}
}
pub(super) fn drop_guest_items(&mut self, host: &LanHost, gi: usize, stacks: Vec<ItemStack>) {
let g = &host.hub.guests[gi];
let eye = [
@@ -1720,16 +1726,23 @@ impl Game<'_> {
// PlayerAdvancements.flushDirty.
let sleeping = host.hub.guests[gi].sleeping;
self.as_guest(host, conn, |g| {
g.tick_fishing();
g.tick_maps();
g.count_tick_stats(sleeping);
g.tick_advancements();
g.update_player_attributes();
});
self.lan_map_updates(host, conn);
host.hub.flush_progress(conn);
self.guest_dig_feedback(host, conn);
self.guest_pickups(host, gi);
self.guest_orbs(host, gi);
if host.hub.guests[gi].health <= 0.0 && !host.hub.guests[gi].dead {
self.guest_forget_digging(host, conn);
// FishingHook.shouldStopFishing: its owner is dead.
if let Some(play) = host.play.get_mut(&conn) {
play.hook = None;
}
}
let g = &mut host.hub.guests[gi];
if g.health <= 0.0 && !g.dead {
@@ -78,6 +78,8 @@ pub(super) fn acts_on_player(e: &MobEvent) -> bool {
target: Who::Player,
..
}
| MobEvent::EffectPlayer { .. }
| MobEvent::AxolotlSupportPlayer
)
}
@@ -115,6 +117,25 @@ impl Game<'_> {
views
}
/// Runs `f` as each guest in play here, for what strikes every player in
/// an area (`Level.getEntities`), not only the window's own.
pub(super) fn each_guest_hit(&mut self, mut f: impl FnMut(&mut Self)) {
let Some(mut host) = self.lan.take() else {
return;
};
let conns: Vec<u32> = host
.hub
.guests
.iter()
.filter(|g| host.hub.here(g) && g.loaded && !g.dead)
.map(|g| g.conn)
.collect();
for conn in conns {
self.guest_hit_by(&mut host, conn, &mut f);
}
self.lan = Some(host);
}
/// Mob events aimed at a guest, run as that guest (`guest_hit_by`).
pub(super) fn lan_guest_mob_events(&mut self, events: Vec<(u32, MobEvent)>) {
if events.is_empty() {
+22 -16
View File
@@ -280,11 +280,12 @@ impl Game<'_> {
}
/// `thunderHit` for entities within 3 blocks (up to 9 above).
fn thunder_hit(&mut self, b: &mut Bolt) {
let inside = |p: [f64; 3]| {
(p[0] - b.at[0]).abs() <= 3.0
&& (p[2] - b.at[2]).abs() <= 3.0
&& p[1] >= b.at[1] - 3.0
&& p[1] <= b.at[1] + 9.0
let at = b.at;
let inside = move |p: [f64; 3]| {
(p[0] - at[0]).abs() <= 3.0
&& (p[2] - at[2]).abs() <= 3.0
&& p[1] >= at[1] - 3.0
&& p[1] <= at[1] + 9.0
};
let damage = Damage {
kind: DamageKind::Generic,
@@ -349,19 +350,24 @@ impl Game<'_> {
if !events.is_empty() {
let _ = self.handle_mob_events(events);
}
if let Some(p) = self.player.as_ref().map(|p| p.position)
&& inside([p.x, p.y, p.z])
{
if let Some(p) = self.player.as_mut() {
p.fire_ticks += 1;
if p.fire_ticks == 0
&& let Err(error) = p.ignite_for_ticks(160)
{
self.error = Some(error);
// Every player in the box, the server's players too.
let strike = move |g: &mut Self| {
if let Some(p) = g.player.as_ref().map(|p| p.position)
&& inside([p.x, p.y, p.z])
{
if let Some(p) = g.player.as_mut() {
p.fire_ticks += 1;
if p.fire_ticks == 0
&& let Err(error) = p.ignite_for_ticks(160)
{
g.error = Some(error);
}
}
g.hurt_player_by("minecraft:lightning_bolt", 5.0);
}
self.hurt_player_by("minecraft:lightning_bolt", 5.0);
}
};
strike(self);
self.each_guest_hit(strike);
// Dropped items burn up (ItemEntity health 5), save fire-resistant ones.
self.dropped.retain(|e| {
!inside([e.position.x, e.position.y, e.position.z])
+321 -50
View File
@@ -4,7 +4,7 @@
//! shading, the dithered edge), the player marker, `data/minecraft/maps/<id>.dat` and
//! `maps/last_id.dat`, the 128x128 texture in an atlas slot, the two-handed
//! first-person view and maps in item frames.
use super::Game;
use super::{Game, lan::LanHost};
use horizon_client::{
blocks::{Fluid, MAP_COLORS},
hud::{MAP_SLOTS, Rect},
@@ -14,13 +14,48 @@ use horizon_client::{
use horizon_world::nbt::Tag;
use std::collections::HashMap;
/// A decoration: sprite, map position (-128..127, half pixels) and rotation (0..15).
/// A decoration: sprite, map position (-128..127, half pixels) and rotation
/// (0..15), and the player it marks (an item's own decorations mark none).
#[derive(Clone, Debug, PartialEq)]
pub(super) struct Decoration {
pub sprite: &'static str,
pub x: i8,
pub y: i8,
pub rot: u8,
pub holder: Option<u32>,
}
/// The host among a map's holders (the guests are their connections).
const HOST: u32 = u32::MAX;
/// A player carrying a map, or seeing it framed
/// (`MapItemSavedData.HoldingPlayer`): the column sweep's step, and what
/// changed since the last `ClientboundMapItemDataPacket` it was sent.
struct Holder {
who: u32,
/// The last tick it carried the map, and saw it framed.
carried: i64,
framed: i64,
step: i32,
/// The changed pixels' box (min x, min y, max x, max y).
dirty: Option<[i32; 4]>,
decorations: bool,
tick: u32,
}
impl Holder {
fn new(who: u32) -> Self {
Self {
who,
carried: 0,
framed: 0,
step: 0,
dirty: Some([0, 0, 127, 127]),
decorations: true,
tick: 0,
}
}
/// Still carrying the map, or seeing it framed (frames tick every 10).
fn holds(&self, now: i64) -> bool {
self.carried + 1 >= now || self.framed + 10 >= now
}
}
pub(super) struct MapData {
pub center: [i32; 2],
@@ -31,8 +66,7 @@ pub(super) struct MapData {
pub unlimited: bool,
pub colors: Vec<u8>,
pub decorations: Vec<Decoration>,
/// HoldingPlayer.step for the column sweep.
step: i32,
holders: Vec<Holder>,
/// Changed since the last save / texture upload.
dirty: bool,
texture_dirty: bool,
@@ -51,7 +85,7 @@ impl MapData {
unlimited: false,
colors: vec![0; 128 * 128],
decorations: Vec::new(),
step: 0,
holders: Vec::new(),
dirty: true,
texture_dirty: true,
}
@@ -64,8 +98,128 @@ impl MapData {
self.colors[i] = color;
self.dirty = true;
self.texture_dirty = true;
// setColorsDirty: every holder's next packet carries it.
for h in &mut self.holders {
h.dirty = Some(match h.dirty {
Some([x0, y0, x1, y1]) => [x0.min(x), y0.min(y), x1.max(x), y1.max(y)],
None => [x, y, x, y],
});
}
true
}
/// `tickCarriedBy`'s holder for `who`, added when new.
fn holder(&mut self, who: u32) -> &mut Holder {
let i = match self.holders.iter().position(|h| h.who == who) {
Some(i) => i,
None => {
self.holders.push(Holder::new(who));
self.holders.len() - 1
}
};
&mut self.holders[i]
}
/// The holders that no longer carry the map nor see it framed go, and
/// their markers with them (`tickCarriedBy`'s removeDecoration).
fn drop_holders(&mut self, now: i64) {
self.holders.retain(|h| h.holds(now));
let holders = &self.holders;
let before = self.decorations.len();
self.decorations
.retain(|d| d.holder.is_none_or(|w| holders.iter().any(|h| h.who == w)));
if self.decorations.len() != before {
self.decorations_changed();
}
}
/// setDecorationsDirty.
fn decorations_changed(&mut self) {
for h in &mut self.holders {
h.decorations = true;
}
}
/// `addDecoration` / `removeDecoration` for `holder`'s marker: in place,
/// so that the order (the drawing order) stays.
fn set_marker(&mut self, holder: u32, marker: Option<Decoration>) {
let i = self
.decorations
.iter()
.position(|d| d.holder == Some(holder));
let changed = match (i, marker) {
(Some(i), Some(d)) if self.decorations[i] == d => false,
(Some(i), Some(d)) => {
self.decorations[i] = d;
true
}
(Some(i), None) => {
self.decorations.remove(i);
true
}
(None, Some(d)) => {
self.decorations.push(d);
true
}
(None, None) => false,
};
if changed {
self.decorations_changed();
}
}
/// `HoldingPlayer.nextUpdatePacket` for `who`: the changed pixels, and
/// the decorations (at most every 5th call while they changed).
fn update_packet(
&mut self,
id: i32,
who: u32,
kind: impl Fn(&str) -> Option<i32>,
) -> Option<horizon_protocol::packets::play::MapItemData> {
use horizon_protocol::packets::play::{MapDecoration, MapItemData, MapPatch};
let h = self.holders.iter_mut().find(|h| h.who == who)?;
let patch = h.dirty.take().map(|[x0, y0, x1, y1]| {
let (width, height) = (x1 + 1 - x0, y1 + 1 - y0);
let mut colors = Vec::with_capacity((width * height) as usize);
for y in 0..height {
for x in 0..width {
colors.push(self.colors[(x0 + x + (y0 + y) * 128) as usize]);
}
}
MapPatch {
start_x: x0,
start_y: y0,
width,
height,
colors,
}
});
let decorations = if h.decorations && {
let due = h.tick % 5 == 0;
h.tick += 1;
due
} {
h.decorations = false;
Some(
self.decorations
.iter()
.filter_map(|d| {
Some(MapDecoration {
kind: kind(decoration_type(d.sprite)?)?,
x: d.x,
y: d.y,
rot: d.rot as i8,
name: None,
})
})
.collect(),
)
} else {
None
};
(patch.is_some() || decorations.is_some()).then_some(MapItemData {
map_id: id,
scale: self.scale as i8,
locked: self.locked,
decorations,
patch,
})
}
fn to_nbt(&self) -> Tag {
let flag = |b: bool| Tag::Byte(i8::from(b));
Tag::compound([
@@ -112,7 +266,7 @@ impl MapData {
unlimited: int("unlimitedTracking").unwrap_or(0) != 0,
colors,
decorations: Vec::new(),
step: 0,
holders: Vec::new(),
dirty: false,
texture_dirty: true,
})
@@ -143,36 +297,48 @@ fn packed_rgba(packed: u8) -> [u8; 4] {
pub(super) fn map_id(stack: &ItemStack) -> Option<i32> {
stack.data().and_then(|d| d.map_id)
}
/// `MapDecorationTypes`: the sprite of a decoration type that a
/// `minecraft:map_decorations` entry can name.
/// `MapDecorationTypes` Horizon draws: (type, sprite).
const DECORATION_TYPES: [(&str, &str); 24] = [
("player", "map/decorations/player"),
("frame", "map/decorations/frame"),
("red_marker", "map/decorations/red_marker"),
("blue_marker", "map/decorations/blue_marker"),
("target_x", "map/decorations/target_x"),
("target_point", "map/decorations/target_point"),
("player_off_map", "map/decorations/player_off_map"),
("player_off_limits", "map/decorations/player_off_limits"),
("mansion", "map/decorations/woodland_mansion"),
("monument", "map/decorations/ocean_monument"),
("red_x", "map/decorations/red_x"),
("village_desert", "map/decorations/desert_village"),
("village_plains", "map/decorations/plains_village"),
("village_savanna", "map/decorations/savanna_village"),
("village_snowy", "map/decorations/snowy_village"),
("village_taiga", "map/decorations/taiga_village"),
("jungle_temple", "map/decorations/jungle_temple"),
("swamp_hut", "map/decorations/swamp_hut"),
("trial_chambers", "map/decorations/trial_chambers"),
("abandoned_camp", "map/decorations/abandoned_camp"),
("ancient_city", "map/decorations/ancient_city"),
("desert_pyramid", "map/decorations/desert_pyramid"),
("mineshaft", "map/decorations/mineshaft"),
("ocean_ruin_warm", "map/decorations/warm_ocean_ruins"),
];
/// The sprite of a decoration type that a `minecraft:map_decorations`
/// entry or a server's packet names.
fn decoration_sprite(id: &str) -> Option<&'static str> {
Some(match id.strip_prefix("minecraft:").unwrap_or(id) {
"player" => "map/decorations/player",
"frame" => "map/decorations/frame",
"red_marker" => "map/decorations/red_marker",
"blue_marker" => "map/decorations/blue_marker",
"target_x" => "map/decorations/target_x",
"target_point" => "map/decorations/target_point",
"player_off_map" => "map/decorations/player_off_map",
"player_off_limits" => "map/decorations/player_off_limits",
"mansion" => "map/decorations/woodland_mansion",
"monument" => "map/decorations/ocean_monument",
"red_x" => "map/decorations/red_x",
"village_desert" => "map/decorations/desert_village",
"village_plains" => "map/decorations/plains_village",
"village_savanna" => "map/decorations/savanna_village",
"village_snowy" => "map/decorations/snowy_village",
"village_taiga" => "map/decorations/taiga_village",
"jungle_temple" => "map/decorations/jungle_temple",
"swamp_hut" => "map/decorations/swamp_hut",
"trial_chambers" => "map/decorations/trial_chambers",
"abandoned_camp" => "map/decorations/abandoned_camp",
"ancient_city" => "map/decorations/ancient_city",
"desert_pyramid" => "map/decorations/desert_pyramid",
"mineshaft" => "map/decorations/mineshaft",
"ocean_ruin_warm" => "map/decorations/warm_ocean_ruins",
_ => return None,
})
let name = id.strip_prefix("minecraft:").unwrap_or(id);
DECORATION_TYPES
.iter()
.find(|(n, _)| *n == name)
.map(|(_, sprite)| *sprite)
}
/// The type a decoration's sprite stands for, as its registry names it.
fn decoration_type(sprite: &str) -> Option<&'static str> {
DECORATION_TYPES
.iter()
.find(|(_, s)| *s == sprite)
.map(|(name, _)| *name)
}
/// `minecraft:map_decorations` of a map item: (sprite, x, z, rotation), in
/// the component's order.
@@ -275,12 +441,29 @@ impl Game<'_> {
}
self.maps.data.get_mut(&id)
}
/// `ClientboundMapItemDataPacket.handle`: the server's colours for a map
/// this client does not own (lobby map art, a framed map on a wall).
/// `ClientboundMapItemDataPacket.handle`: the server's colours and
/// decorations for a map (one carried or framed on a server).
pub(super) fn remote_map_item_data(
&mut self,
p: &horizon_protocol::packets::play::MapItemData,
) {
let decorations = p.decorations.as_ref().map(|list| {
let types = self
.remote
.as_ref()
.and_then(|r| r.builtin.get("minecraft:map_decoration_type"));
list.iter()
.filter_map(|d| {
Some(Decoration {
sprite: decoration_sprite(types?.name(d.kind)?)?,
x: d.x,
y: d.y,
rot: (d.rot & 15) as u8,
holder: None,
})
})
.collect()
});
let dimension = self.dimension_id();
let map = self
.maps
@@ -288,6 +471,9 @@ impl Game<'_> {
.entry(p.map_id)
.or_insert_with(|| MapData::fresh(0.0, 0.0, p.scale.max(0) as u8, dimension));
map.locked = p.locked;
if let Some(decorations) = decorations {
map.decorations = decorations;
}
let Some(patch) = &p.patch else {
map.dirty = false;
return;
@@ -566,10 +752,14 @@ impl Game<'_> {
.collect();
let (yaw, dim) = (self.yaw, self.dimension_id());
let (nether, game_time) = (self.dim == super::Dim::Nether, self.world.game_time);
// The guest whose turn it is, else the host.
let me = self.lan_acting.unwrap_or(HOST);
for (id, targets) in carried {
let Some(m) = self.map(id) else { continue };
m.holder(me).carried = game_time;
m.drop_holders(game_time);
// tickCarriedBy: the player marker while tracking in this dimension.
m.decorations.clear();
let mut marker = None;
if m.tracking && m.dimension == dim {
let s = f64::from(1 << m.scale);
let dx = ((p.x - f64::from(m.center[0])) / s) as f32;
@@ -596,18 +786,19 @@ impl Game<'_> {
} else {
None
};
if let Some(sprite) = sprite {
m.decorations.push(Decoration {
sprite,
x: clamp(dx),
y: clamp(dz),
rot,
});
}
marker = sprite.map(|sprite| Decoration {
sprite,
x: clamp(dx),
y: clamp(dz),
rot,
holder: Some(me),
});
}
m.set_marker(me, marker);
// The item's MAP_DECORATIONS (an explorer map's target), added
// after the players as addDecoration would.
let s = (1 << m.scale) as f32;
let mut items: Vec<Decoration> = Vec::new();
for (sprite, x, z, rotation) in targets {
let dx = (x - f64::from(m.center[0])) as f32 / s;
let dz = (z - f64::from(m.center[1])) as f32 / s;
@@ -620,16 +811,95 @@ impl Game<'_> {
x: clamp_map_coordinate(dx),
y: clamp_map_coordinate(dz),
rot: decoration_rotation(nether, game_time, f64::from(rotation)),
holder: None,
};
if !m.decorations.contains(&d) {
m.decorations.push(d);
if !items.contains(&d) {
items.push(d);
}
}
if !m
.decorations
.iter()
.filter(|d| d.holder.is_none())
.eq(items.iter())
{
m.decorations.retain(|d| d.holder.is_some());
m.decorations.extend(items);
m.decorations_changed();
}
}
for id in held {
self.update_map(id);
}
}
/// The maps the player carries, for `status`: how many of their pixels
/// are drawn, and their decorations.
pub(super) fn maps_status(&self) -> Vec<serde_json::Value> {
self.inventory
.iter()
.chain(std::iter::once(&self.offhand))
.flatten()
.filter_map(map_id)
.filter_map(|id| {
let m = self.maps.data.get(&id)?;
Some(serde_json::json!({
"id": id,
"pixels": m.colors.iter().filter(|&&c| c != 0).count(),
"decorations": m.decorations.iter().map(|d| d.sprite).collect::<Vec<_>>(),
}))
})
.collect()
}
/// `ServerPlayer.synchronizeSpecialItemUpdates` for each map the guest
/// carries, and every 10 ticks (`ServerEntity.sendChanges`) for each map
/// framed in the level: a `ClientboundMapItemDataPacket` when something
/// changed since the guest's last one.
pub(super) fn lan_map_updates(&mut self, host: &LanHost, conn: u32) {
let Some(g) = host.hub.guest(conn) else {
return;
};
let mut ids: Vec<i32> = g
.inventory
.iter()
.chain(std::iter::once(&g.offhand))
.flatten()
.filter_map(map_id)
.collect();
let now = self.world.game_time;
if now % 10 == 0 && host.hub.here(g) {
let framed: Vec<i32> = self
.item_frames
.iter()
.filter_map(|f| f.item.as_ref().and_then(map_id))
.collect();
for id in framed {
if let Some(m) = self.map(id) {
m.holder(conn).framed = now;
ids.push(id);
}
}
}
ids.sort_unstable();
ids.dedup();
let kind = |name: &str| {
host.hub.registry_id(
"minecraft:map_decoration_type",
&format!("minecraft:{name}"),
)
};
for id in ids {
if let Some(p) = self
.maps
.data
.get_mut(&id)
.and_then(|m| m.update_packet(id, conn, kind))
{
g.send(&horizon_protocol::packets::play::Clientbound::MapItemData(
p,
));
}
}
}
/// `MapItem.update` for the player holding map `id`.
fn update_map(&mut self, id: i32) {
let dim = self.dimension_id();
@@ -651,8 +921,9 @@ impl Game<'_> {
if nether {
radius /= 2;
}
m.step += 1;
let step = m.step;
let h = m.holder(self.lan_acting.unwrap_or(HOST));
h.step += 1;
let step = h.step;
let mut changes: Vec<(i32, i32, u8)> = Vec::new();
let mut consecutive = false;
for img_x in px - radius + 1..px + radius {
+1 -10
View File
@@ -3139,19 +3139,10 @@ impl Game<'_> {
[player.position.x, player.position.y, player.position.z],
);
let was_flying = player.flying;
player.yaw = self.yaw;
// As the window's own tick has them: the helmet's Respiration
// (decreaseAirSupply) and the dimension's FAST_LAVA, the Nether's
// stronger lava current.
player.respiration = self.armor[0]
.as_ref()
.map_or(0, |s| s.enchantment_level("minecraft:respiration") as i32);
player.fluids.fast_lava = self.dim == Dim::Nether;
let glider = self.glider_worn();
self.sync_player_body();
let Some(player) = self.player.as_mut() else {
return Ok(());
};
player.glider = glider;
let was_gliding = player.fall_flying;
let dead = self.screen == Screen::Dead;
// LivingEntity.isImmobile: a sleeper lies still in the bed.
@@ -88,6 +88,8 @@ impl Game<'_> {
self.end
.add_remote_eye(id, position, [velocity.x, velocity.y, velocity.z])
}
// FishingHook.recreateFromPacket: the owner's id is the data.
"minecraft:fishing_bobber" => self.spawn_remote_hook(id, at, data),
"minecraft:end_crystal" => self.crystals.push(super::dragon::Crystal {
id,
position: at,
@@ -114,6 +116,7 @@ impl Game<'_> {
/// `handleSetEntityData` for these types: what changes how they look.
pub(super) fn remote_projectile_data(&mut self, id: i32, values: &[(u8, i32, Value)]) {
let id = id as u32;
self.remote_hook_data(id, values);
if self.potions.has_thrown(id) {
// ThrowableItemProjectile.DATA_ITEM_STACK: the potion it is.
for (index, _, value) in values {
@@ -205,6 +208,7 @@ impl Game<'_> {
c.position = step(c.id, c.position);
}
self.potions.step_remote_thrown(&mut step);
self.step_remote_hooks(&mut step);
self.end.step_remote_eyes(|id, at| {
let at = step(id, Vec3::new(at[0], at[1], at[2]));
[at.x, at.y, at.z]
@@ -220,6 +224,7 @@ impl Game<'_> {
self.crystals.retain(|c| c.id != id);
self.potions.remove_remote_thrown(id);
self.end.remove_remote_eye(id);
self.remove_remote_hook(id);
}
/// Every one a server sent (a new connection, level or dimension).
@@ -232,6 +237,7 @@ impl Game<'_> {
self.crystals.clear();
self.potions.clear_thrown();
self.end.clear_remote_eyes();
self.clear_remote_hooks();
}
/// Their kind and place, for `status`.
@@ -260,6 +266,7 @@ impl Game<'_> {
for (id, p) in self.end.eye_positions() {
out.push(json!({"id": id, "kind": "minecraft:eye_of_ender", "position": p}));
}
out.extend(self.hooks_status());
out
}
}
+1
View File
@@ -1054,6 +1054,7 @@ impl Game<'_> {
let r = &mut self.world.random;
let bonus = r.triangle(0.0, 0.11485000000000001);
mob.attrs.follow_range += mob.kind.follow_range * bonus;
mob.update_max_visited_nodes();
let _left_handed = r.next_float() < 0.05;
if !self.warden_fits(&mob) {
continue;
+36 -99
View File
@@ -5,34 +5,13 @@ use super::Game;
use horizon_client::{
gossip::{self, GossipType},
items::ItemStack,
mobs::{Mob, Species, spawning, villager},
mobs::{Mob, Species, spawning, villager, villager_brain},
};
use horizon_core::{geometry::Vec3, random::RandomSource};
use horizon_core::geometry::Vec3;
fn block_of(p: Vec3) -> [i32; 3] {
[p.x.floor() as i32, p.y.floor() as i32, p.z.floor() as i32]
}
/// `SpawnUtil.Strategy.LEGACY_IRON_GOLEM`: what a golem will not land on.
fn golem_floor_ok(name: &str) -> bool {
!matches!(
name,
"minecraft:cobweb"
| "minecraft:cactus"
| "minecraft:glass_pane"
| "minecraft:conduit"
| "minecraft:ice"
| "minecraft:tnt"
| "minecraft:glowstone"
| "minecraft:beacon"
| "minecraft:sea_lantern"
| "minecraft:frosted_ice"
| "minecraft:tinted_glass"
| "minecraft:glass"
) && !name.ends_with("_stained_glass_pane")
&& !name.ends_with("_stained_glass")
&& !name.ends_with("leaves")
}
impl Game<'_> {
fn villager_index(&self, id: u32) -> Option<usize> {
self.mobs
@@ -76,88 +55,46 @@ impl Game<'_> {
return;
};
let now = self.world.game_time;
if !villager::ext(&self.mobs[i]).is_some_and(|e| e.wants_golem(now)) {
let Some(near) = villager::golem_summoners(&self.mobs, i, now, needed) else {
return;
}
let at = self.mobs[i].position;
let nearby: Vec<usize> = self
.mobs
.iter()
.enumerate()
.filter(|(_, m)| {
m.species() == Species::Villager
&& m.alive()
&& (m.position.x - at.x).abs() <= 10.0
&& (m.position.y - at.y).abs() <= 10.0
&& (m.position.z - at.z).abs() <= 10.0
})
.map(|(j, _)| j)
.collect();
let wanting = nearby
.iter()
.filter(|j| villager::ext(&self.mobs[**j]).is_some_and(|e| e.wants_golem(now)))
.take(5)
.count();
if wanting < needed {
return;
}
if self.try_spawn_iron_golem(block_of(at)) {
for j in nearby {
villager::ext_mut(&mut self.mobs[j]).golem_until = now + 599;
};
if self.try_spawn_iron_golem(block_of(self.mobs[i].position)) {
for j in near {
villager_brain::golem_detected(&mut self.mobs[j], now);
}
}
}
/// `SpawnUtil.trySpawnMob(IRON_GOLEM, ..., 10 attempts, 8 across, 6 up
/// and down, LEGACY_IRON_GOLEM)`.
/// `SpawnUtil.trySpawnMob(IRON_GOLEM, ...)`: a golem near `start`, with
/// the ambient sound `trySpawnMob` plays.
fn try_spawn_iron_golem(&mut self, start: [i32; 3]) -> bool {
for _ in 0..10 {
let r = &mut self.world.random;
let dx = r.next_int_bound(17).unwrap_or(8) - 8;
let dz = r.next_int_bound(17).unwrap_or(8) - 8;
let (x, z) = (start[0] + dx, start[2] + dz);
let mut y = start[1] + 6;
let mut above = self.world.block(x, y, z);
let mut found = None;
for _ in 0..=12 {
y -= 1;
let here = self.world.block(x, y, z);
let f = self.res.facts().get(here);
let above_f = self.res.facts().get(above);
let air_or_liquid = self.res.facts().is_air(above)
|| above_f.fluid != horizon_client::blocks::Fluid::None;
let solid =
self.res.mob_data().state(here).flags & horizon_client::mobs::data::SOLID != 0
|| f.name.as_ref() == "minecraft:powder_snow";
if golem_floor_ok(&f.name) && air_or_liquid && solid {
found = Some(y + 1);
break;
}
above = here;
}
let Some(y) = found else { continue };
// IronGolem.checkSpawnRules: a floor and three free blocks.
let free = |g: &Self, yy: i32| {
g.res.mob_data().state(g.world.block(x, yy, z)).flags
& horizon_client::mobs::data::VALID_EMPTY_SPAWN
!= 0
};
if !(0..4).all(|k| free(self, y + k)) {
continue;
}
let at = [f64::from(x) + 0.5, f64::from(y), f64::from(z) + 0.5];
if let Some(id) = self.spawn_mob_for("minecraft:iron_golem", at, false, true)
&& let Some(m) = self.mobs.iter_mut().find(|m| m.id == id)
{
let sound = m.kind.sounds[0];
if !sound.is_empty() {
let at = m.center();
self.audio
.play(&format!("minecraft:{sound}"), Some(at), 1.0, 1.0);
}
return true;
}
let Some(kind) = self.res.mob_types().get("minecraft:iron_golem").cloned() else {
return false;
};
let id = self.next_entity + 1;
let mut random = self.world.random.clone();
let golem = villager::summon_golem(
&self.mob_world_base(&[]),
start,
&mut random,
|random, at, yaw| {
let mut m = Mob::new(id, kind.clone(), at, yaw);
villager::finalize_summoned_golem(&mut m, random);
m
},
);
self.world.random = random;
let Some(golem) = golem else {
return false;
};
self.next_entity = id;
let sound = golem.kind.sounds[0];
if !sound.is_empty() {
let at = golem.center();
self.audio
.play(&format!("minecraft:{sound}"), Some(at), 1.0, 1.0);
}
false
self.mobs.push(golem);
true
}
/// `VillagerMakeLove.tryToGiveBirth`: both eat, a free bed within 48
+305 -41
View File
@@ -35,7 +35,7 @@ fn entity_shader() -> String {
mod entity_batch;
mod weather;
use entity_batch::EntityBatch;
pub use entity_batch::WATER_MASK_OVERLAY;
pub use entity_batch::{SHADOW_OVERLAY, WATER_MASK_OVERLAY};
/// Window.getAppropriateLineWidth, in framebuffer pixels.
pub fn outline_width(width: u32) -> f32 {
@@ -159,6 +159,18 @@ struct Globals {
dynamic_lights: [[f32; 4]; crate::dynamic_light::MAX],
}
pub type SectionKey = (i32, i32, i32);
/// The sections a Java pack's shadow map draws ([`Renderer`]'s `shadow`).
#[derive(Default)]
struct ShadowList {
visible: Vec<resident::Visible>,
draws: Vec<[u32; 5]>,
pages: Vec<(u32, Option<u32>)>,
/// How many of `draws` are solid.
solid: u32,
indirect: Option<wgpu::Buffer>,
capacity: u64,
}
struct SectionGpu {
/// Arena page and first vertex in it: solid quads, then translucent ones.
page: u32,
@@ -376,6 +388,7 @@ pub struct Renderer {
entity_pipeline: wgpu::RenderPipeline,
weather: weather::Weather,
crumbling_pipeline: wgpu::RenderPipeline,
shadow_blob_pipeline: wgpu::RenderPipeline,
/// `RenderPipelines.WATER_MASK`: depth writes only, no colour.
water_mask_pipeline: wgpu::RenderPipeline,
cloud_pipeline: wgpu::RenderPipeline,
@@ -479,6 +492,10 @@ pub struct Renderer {
/// built, and their pages.
phase2_draws: Vec<[u32; 5]>,
phase2_pages: Vec<(u32, Option<u32>)>,
/// A Java pack's shadow map (`gfx/java_terrain.rs`): the sections in
/// the light's view, their draws (solid then translucent, instances
/// after the camera's), and the indirect buffer they're uploaded to.
shadow: ShadowList,
/// Each section's solid draws, to group them by arena page.
solid_runs: page_runs::PageRuns,
phase2_runs: page_runs::PageRuns,
@@ -1830,6 +1847,26 @@ impl Renderer {
CRUMBLING_BLEND,
false,
);
// RenderPipelines.ENTITY_SHADOW: translucent, depth test without
// writes. The quads lie on the block tops like vanilla's, but the
// terrain under them snaps to the subpixel grid at other vertices, so
// at a slant their depths differ by up to 1/256 of a pixel's depth
// slope and whole shadows failed the test. The bias covers that and
// the rounding, and stays below the 0.001 a model's feet sit higher
// (1/27 of a pixel's slope at the 16-block shadow range in 720p).
let shadow_blob_pipeline = entity_pipeline(
"Entity shadows",
None,
false,
wgpu::CompareFunction::GreaterEqual,
wgpu::DepthBiasState {
constant: 16,
slope_scale: 0.015,
clamp: 0.0,
},
alpha_blend,
false,
);
let cloud_pipeline = entity_pipeline(
"Clouds",
Some(wgpu::Face::Back),
@@ -2349,6 +2386,7 @@ impl Renderer {
entity_pipeline,
weather,
crumbling_pipeline,
shadow_blob_pipeline,
water_mask_pipeline,
cloud_pipeline,
cloud_mesh: Default::default(),
@@ -2424,6 +2462,7 @@ impl Renderer {
draw_pages: Vec::new(),
phase2_draws: Vec::new(),
phase2_pages: Vec::new(),
shadow: ShadowList::default(),
solid_runs: page_runs::PageRuns::default(),
phase2_runs: page_runs::PageRuns::default(),
block_entities: HashMap::new(),
@@ -2756,11 +2795,26 @@ impl Renderer {
first: u32,
count: u32,
page_group: impl Fn(&mut wgpu::RenderPass<'_>, u32),
) {
let list = (&self.draws[..], &self.draw_pages[..]);
self.draw_list(pass, indirect, list, base, first, count, page_group);
}
/// [`Self::draw_sections_with`] over another list of draws and pages.
#[allow(clippy::too_many_arguments)]
fn draw_list(
&self,
pass: &mut wgpu::RenderPass<'_>,
indirect: &wgpu::Buffer,
(draws, pages): (&[[u32; 5]], &[(u32, Option<u32>)]),
base: u32,
first: u32,
count: u32,
page_group: impl Fn(&mut wgpu::RenderPass<'_>, u32),
) {
let (mut i, end) = (first as usize, (first + count) as usize);
while i < end {
let (page, index_page) = self.draw_pages[i];
let run = self.draw_pages[i..end]
let (page, index_page) = pages[i];
let run = pages[i..end]
.iter()
.take_while(|&&p| p == (page, index_page))
.count();
@@ -2772,52 +2826,91 @@ impl Renderer {
let offset = (i - base as usize) as u64 * 20;
pass.multi_draw_indexed_indirect(indirect, offset, run as u32);
} else {
for d in &self.draws[i..i + run] {
for d in &draws[i..i + run] {
pass.draw_indexed(d[2]..d[2] + d[0], d[3] as i32, d[4]..d[4] + 1);
}
}
i += run;
}
}
/// Horizon's terrain, solid or `translucent`, with a Java pack's
/// geometry pipelines (`java_terrain::DrawTerrain`): the frame's flat
/// draws or its section draws, each page with its group 3.
/// One `layer` of Horizon's terrain with a Java pack's geometry
/// pipelines (`java_terrain::DrawTerrain`): the frame's flat draws or its
/// section draws, each page with its group 3. `draws` are the frame's
/// phase 1 solid draws, all its solid draws and its translucent ones;
/// `culling` tells whether phase 2's come from occlusion culling.
fn draw_java_terrain(
&self,
pass: &mut wgpu::RenderPass<'_>,
translucent: bool,
layer: java_terrain::Layer,
pipelines: &java_terrain::TerrainPipelines,
flat_frame: bool,
draws: [u32; 2],
draws: [u32; 3],
culling: bool,
) {
use java_terrain::Layer;
let page = |pass: &mut wgpu::RenderPass<'_>, page: u32| {
if let Some(Some((_, group))) = self.java_pages.get(page as usize) {
pass.set_bind_group(3, group, &[]);
}
};
if matches!(layer, Layer::ShadowSolid | Layer::ShadowTranslucent) {
let shadow = &self.shadow;
let all = shadow.draws.len() as u32;
let (first, count) = if layer == Layer::ShadowSolid {
(0, shadow.solid)
} else {
(shadow.solid, all - shadow.solid)
};
// Without multi-draw the draws are read from the list.
let indirect = shadow.indirect.as_ref().unwrap_or(&self.indirect);
if count == 0 {
return;
}
pass.set_bind_group(2, pipelines.group, &[]);
pass.set_pipeline(pipelines.instanced);
pass.set_vertex_buffer(1, self.instances.slice(..));
let list = (&shadow.draws[..], &shadow.pages[..]);
self.draw_list(pass, indirect, list, 0, first, count, page);
return;
}
pass.set_bind_group(2, pipelines.group, &[]);
match (self.flat.as_ref().filter(|_| flat_frame), pipelines.flat) {
// Without occlusion culling, phase 1 is every solid call.
(Some(flat), Some(pipeline)) => {
let vertices = |p| self.arena.buffer(p);
pass.set_pipeline(pipeline);
let calls = if translucent {
&flat.calls[flat.solid_calls..]
} else {
&flat.calls[..flat.solid_calls]
};
flat.draw(pass, calls, |p| self.arena.buffer(p), page);
match layer {
Layer::Solid => {
flat.draw(pass, &flat.calls[..flat.phase1_calls], vertices, page)
}
Layer::Revealed if culling => flat.draw_phase2(pass, vertices, page),
Layer::Revealed => {}
Layer::Translucent => {
flat.draw(pass, &flat.calls[flat.solid_calls..], vertices, page)
}
// Drawn from the shadow list, above.
Layer::ShadowSolid | Layer::ShadowTranslucent => {}
}
}
(Some(_), None) => {}
(None, _) => {
let [phase1, solid, translucent_draws] = draws;
let cull = self.cull.as_ref().filter(|_| culling);
let (indirect, base, first, count) = match (layer, cull) {
(Layer::Solid, Some(_)) => (&self.indirect, 0, 0, phase1),
(Layer::Solid, None) => (&self.indirect, 0, 0, solid),
(Layer::Revealed, Some(c)) => (&c.phase2, phase1, phase1, solid - phase1),
(Layer::Revealed, None) => return,
(Layer::Translucent, _) => (&self.indirect, 0, solid, translucent_draws),
(Layer::ShadowSolid | Layer::ShadowTranslucent, _) => return,
};
if count == 0 {
return;
}
pass.set_pipeline(pipelines.instanced);
pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
pass.set_vertex_buffer(1, self.instances.slice(..));
let [solid, translucent_draws] = draws;
let (first, count) = if translucent {
(solid, translucent_draws)
} else {
(0, solid)
};
self.draw_sections_with(pass, &self.indirect, 0, first, count, page);
self.draw_sections_with(pass, indirect, base, first, count, page);
}
}
}
@@ -3388,8 +3481,59 @@ impl Renderer {
visible_lods.sort_unstable_by_key(|v| (v.distance, v.key));
}
self.drawn_sections = visible.len() + visible_lods.len();
if self.drawn_sections as u64 > self.instance_capacity {
self.instance_capacity = (self.drawn_sections as u64).next_power_of_two();
// A Java pack's shadow map: the sections in the light's orthographic
// box, whatever the camera sees (Iris turns cave culling off too).
let mut shadow_visible = std::mem::take(&mut self.shadow.visible);
shadow_visible.clear();
let shadow_view = match &self.pack {
Some(Pack::Java(j)) if !frame.title && self.java_table.is_some() => j.shadow_view(
frame.shader.dimension,
&java_stages::JavaFrame {
eye_light: frame.shader.eye_light,
sun_angle: frame.sky.sun_angle,
moon_angle: frame.sky.moon_angle,
},
camera.as_vec3(),
),
_ => None,
};
if let Some((light_view, [half, near, far])) = shadow_view {
// Inside when `plane · (p, 1) >= 0`: |x|, |y| <= half and the
// eye depth between the near and far planes (GL looks down -z).
let (x, y, z) = (light_view.row(0), light_view.row(1), light_view.row(2));
let planes = [
Vec4::W * half - x,
Vec4::W * half + x,
Vec4::W * half - y,
Vec4::W * half + y,
-z - Vec4::W * near,
z + Vec4::W * far,
];
// Toward the light: the light's view looks down its -z.
let light = z.truncate().normalize_or_zero();
let casts = |k: SectionKey| {
let min = DVec3::new(
f64::from(k.0 * 16),
f64::from(crate::chunk::MIN_Y + k.1 * 16),
f64::from(k.2 * 16),
) - camera;
let min = min.as_vec3();
view.casts_into(min, min + Vec3::splat(16.0), light)
};
crate::spans::time("shadow visibility", || {
self.sections.visible(
camera,
(frame.detail_distance / 16.0) as i32,
&Frustum { planes },
casts,
|_, _| false,
&mut shadow_visible,
)
});
}
let instances = self.drawn_sections + shadow_visible.len();
if instances as u64 > self.instance_capacity {
self.instance_capacity = (instances as u64).next_power_of_two();
self.instances = self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Section origins"),
size: self.instance_capacity * 16,
@@ -3404,8 +3548,63 @@ impl Renderer {
visible
.iter()
.map(|v| section_instance(v.origin))
.chain(visible_lods.iter().map(|v| lod::instance(v.origin))),
.chain(visible_lods.iter().map(|v| lod::instance(v.origin)))
.chain(shadow_visible.iter().map(|v| section_instance(v.origin))),
);
// The shadow map's draws: every solid quad (no face is culled), then
// the translucent ones in the order the camera's sort left them.
let shadow = &mut self.shadow;
shadow.draws.clear();
shadow.pages.clear();
for pass in [false, true] {
for (j, v) in shadow_visible.iter().enumerate() {
let s = self.sections.get(v.slot);
let instance = (self.drawn_sections + j) as u32;
match (pass, s.sorted_indices) {
(false, _) if s.solid > 0 => {
shadow
.draws
.push([s.solid * 6, 1, 0, s.start as u32, instance]);
shadow.pages.push((s.page, None));
}
(true, Some((index_page, index_start))) if s.translucent > 0 => {
let first = s.start + u64::from(s.solid) * 4;
shadow.draws.push([
s.translucent * 6,
1,
index_start as u32,
first as u32,
instance,
]);
shadow.pages.push((s.page, Some(index_page)));
}
_ => {}
}
}
if !pass {
shadow.solid = shadow.draws.len() as u32;
}
}
if self.multi_draw && !shadow.draws.is_empty() {
if shadow.draws.len() as u64 > shadow.capacity || shadow.indirect.is_none() {
shadow.capacity = (shadow.draws.len() as u64).next_power_of_two();
shadow.indirect = Some(self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Java shader pack shadow draws"),
size: shadow.capacity * 20,
usage: wgpu::BufferUsages::INDIRECT | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
}));
}
if let Some(indirect) = &shadow.indirect {
self.uploads.buffer(
&mut encoder,
indirect,
0,
bytemuck::cast_slice(&shadow.draws),
);
}
}
shadow.visible = shadow_visible;
if !self.origins.is_empty() {
self.uploads.buffer(
&mut encoder,
@@ -3423,8 +3622,8 @@ impl Renderer {
.inverse()
.transform_point3(Vec3::ZERO);
// A Java pack that draws the terrain (`gfx/java_terrain.rs`): the
// world pass leaves it out, and occlusion culling (which tests
// against its depth) is off.
// world pass leaves it out, and occlusion culling tests against the
// pack's depth (`Cull::test_gl`).
let java_terrain = !frame.title
&& self.java_table.is_some()
&& matches!(&self.pack, Some(Pack::Java(j)) if j.draws_terrain(frame.shader.dimension));
@@ -3435,11 +3634,7 @@ impl Renderer {
.cull
.as_mut()
.filter(|c| {
self.cull_on
&& !frame.title
&& self.multi_draw
&& self.section_draws >= c.min_draws
&& !java_terrain
self.cull_on && !frame.title && self.multi_draw && self.section_draws >= c.min_draws
})
.and_then(|cull| cull.begin(&self.device).then_some(cull));
self.phase2_draws.clear();
@@ -3670,6 +3865,7 @@ impl Renderer {
crumbling_quads,
translucent_crumbling_quads,
water_mask_quads,
shadow_quads,
] = self.entity_batch.update(
frame.entities,
frame.additive,
@@ -3677,8 +3873,11 @@ impl Renderer {
frame.see_through,
);
let weather_quads = frame.weather.len() as u32 / 4;
let world_quads =
entity_quads + crumbling_quads + translucent_crumbling_quads + water_mask_quads;
let world_quads = entity_quads
+ crumbling_quads
+ translucent_crumbling_quads
+ water_mask_quads
+ shadow_quads;
let cloud_quads = if let Some(input) = &frame.clouds {
let (rebuilt, uniform) =
crate::spans::time("clouds", || self.cloud_mesh.prepare(input));
@@ -4084,7 +4283,7 @@ impl Renderer {
);
pass.set_bind_group(0, &self.group, &[]);
pass.set_pipeline(&flat.solid);
flat.draw_phase2(&mut pass, vertices);
flat.draw_phase2(&mut pass, vertices, |_, _| {});
}
None => flat.draw(
&mut pass,
@@ -4151,6 +4350,17 @@ impl Renderer {
pass.draw_indexed(0..crumbling_quads * 6, (entity_quads * 4) as i32, 0..1);
pass.set_bind_group(0, &self.group, &[]);
}
if shadow_quads > 0 {
pass.set_pipeline(&self.shadow_blob_pipeline);
pass.set_bind_group(0, &self.entity_group, &[]);
pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
pass.draw_indexed(
0..shadow_quads * 6,
((world_quads - shadow_quads) * 4) as i32,
0..1,
);
pass.set_bind_group(0, &self.group, &[]);
}
// BoatRenderer's water patch (RenderTypes.waterMask): depth only,
// before translucent terrain, so no water shows inside the boat.
if water_mask_quads > 0 {
@@ -4308,11 +4518,21 @@ impl Renderer {
&& let Some(mut stages) = self.pack.take()
{
// The pack's terrain programs draw with the frame's draws.
let draws = [solid_draws, translucent_draws];
let draws = [phase1_draws, solid_draws, translucent_draws];
let draw = |render: &mut wgpu::RenderPass<'_>,
translucent: bool,
layer: java_terrain::Layer,
pipelines: &java_terrain::TerrainPipelines| {
self.draw_java_terrain(render, translucent, pipelines, flat_frame, draws);
self.draw_java_terrain(render, layer, pipelines, flat_frame, draws, culling);
};
let cull = self.cull.as_ref().filter(|_| culling && solid_draws > 0);
let occlusion = |encoder: &mut wgpu::CommandEncoder, depth: &wgpu::TextureView| {
if let Some(cull) = cull {
cull.test_gl(&self.device, encoder, depth);
// The flat path's phase 2: the calls the test saw.
if let Some(flat) = self.flat.as_ref().filter(|_| flat_frame) {
flat.flatten_phase2(encoder);
}
}
};
let world = java_terrain::JavaWorld {
sprites: &self.sprite_textures,
@@ -4321,6 +4541,9 @@ impl Renderer {
animated: &self.animated,
lightmap: &self.lightmap_view,
draw: &draw,
occlusion: cull
.is_some()
.then_some(&occlusion as &java_terrain::OcclusionTest),
};
let output = match &mut stages {
Pack::Horizon(stages) => stages.run(
@@ -4664,6 +4887,22 @@ impl Frustum {
p.truncate().dot(v) + p.w < 0.0
})
}
/// Whether the camera-relative box `min..max`, lit from the direction
/// `light` (toward the light), can cast a shadow inside: its shadow is
/// the box swept away from the light, which stays outside a plane the
/// box is outside of unless the sweep crosses it (Iris's advanced
/// shadow culling, conservatively).
pub fn casts_into(&self, min: Vec3, max: Vec3, light: Vec3) -> bool {
!self.planes.iter().any(|p| {
let v = Vec3::new(
if p.x >= 0.0 { max.x } else { min.x },
if p.y >= 0.0 { max.y } else { min.y },
if p.z >= 0.0 { max.z } else { min.z },
);
p.truncate().dot(v) + p.w < 0.0 && p.truncate().dot(light) >= 0.0
})
}
/// Whether the camera-relative box `min..max` is entirely inside. Then
/// `intersects` accepts every box within it: each plane's distance only
/// grows from this box's nearest corner to the inner box's farthest, and
@@ -4770,6 +5009,31 @@ fn frustum(m: Mat4) -> [Vec4; 6] {
#[cfg(test)]
mod tests {
#[test]
fn shadow_casters_are_the_boxes_whose_shadow_can_reach_the_view() {
use glam::Vec3;
// Looking north (-z) from the origin, level.
let m = super::world_projection(70.0, 16.0 / 9.0, 256.0)
* crate::camera::view_matrix(180.0, 0.0);
let view = super::Frustum {
planes: super::frustum(m),
};
let cube =
|x: f32, y: f32, z: f32| (Vec3::new(x, y, z), Vec3::new(x + 16.0, y + 16.0, z + 16.0));
let noon = Vec3::Y;
// In view: casts.
let (min, max) = cube(-8.0, -8.0, -64.0);
assert!(view.intersects(min, max) && view.casts_into(min, max, noon));
// Far above the view, the sun overhead: its shadow falls into it.
let (min, max) = cube(-8.0, 200.0, -64.0);
assert!(!view.intersects(min, max) && view.casts_into(min, max, noon));
// Behind the camera: its shadow falls straight down, behind it too.
let (min, max) = cube(-8.0, -8.0, 32.0);
assert!(!view.casts_into(min, max, noon));
// The same box with a low sun behind the camera (south): it does.
assert!(view.casts_into(min, max, Vec3::new(0.0, 0.2, 1.0).normalize()));
}
#[test]
fn surface_is_8_bit_and_not_srgb() {
use super::surface_format;
@@ -4826,14 +5090,14 @@ mod tests {
normal: [0; 4],
}; 4]
};
let entities: Vec<_> = [(0, 0), (4, 1), (11, 2), (7, 3), (4, 4), (12, 7)]
let entities: Vec<_> = [(0, 0), (14, 9), (4, 1), (11, 2), (7, 3), (4, 4), (12, 7)]
.into_iter()
.flat_map(|(layer, id)| quad(layer, id))
.collect();
let mut batch = super::EntityBatch::default();
let counts = batch.update(&entities, &quad(3, 5), &quad(0, 6), &quad(0, 8));
let vertices = &batch.combined;
assert_eq!(counts, [4, 1, 1, 0]);
assert_eq!(counts, [4, 1, 1, 0, 1]);
assert_eq!(
vertices
.as_chunks::<4>()
@@ -4841,7 +5105,7 @@ mod tests {
.iter()
.map(|q| q[0].light)
.collect::<Vec<_>>(),
[0, 1, 3, 4, 2, 7, 5, 6, 8]
[0, 1, 3, 4, 2, 7, 9, 5, 6, 8]
);
}
#[test]
+122 -44
View File
@@ -108,6 +108,14 @@ fn fs_box_early(in: Box) -> @location(0) vec4<f32> {
see(in.test);
return vec4(0.0);
}
// fs_box_early against a Java shader pack's depth (`vs_box_gl`), in a pass
// without colour targets.
@fragment
@early_depth_test(force)
fn fs_box_early_depth(in: Box) {
see(in.test);
}
";
/// The test's depth texture binding (`InShader`), for the view it was made with.
@@ -118,6 +126,8 @@ struct DepthGroup {
pub struct Cull {
pipeline: wgpu::RenderPipeline,
/// [`Self::test_gl`]'s: a depth-only pass in OpenGL's layout.
gl_pipeline: wgpu::RenderPipeline,
layout: wgpu::BindGroupLayout,
group: Option<Group>,
depth_test: DepthTest,
@@ -261,53 +271,76 @@ impl Cull {
bind_group_layouts: &[Some(&layout), depth_layout.as_ref()],
..Default::default()
});
// In the shader: no colour target, and phase 1's depth attached read
// only (a pass needs an attachment), its test left to the shader.
let (fragment_entry, targets, depth_compare) = match depth_test {
DepthTest::Early => (
"fs_box_early",
&[Some(wgpu::ColorTargetState {
format: color,
blend: None,
write_mask: wgpu::ColorWrites::empty(),
})][..],
wgpu::CompareFunction::GreaterEqual,
),
DepthTest::InShader => ("fs_box", &[][..], wgpu::CompareFunction::Always),
// `gl`: a Java shader pack's depth (`test_gl`), in OpenGL's layout
// (y flipped, and with it the faces' winding; 0 near), without a
// colour target. In the shader (`InShader`): no colour target, and
// the depth attached read only (a pass needs an attachment), its
// test left to the shader.
let pipeline = |label, gl: bool| {
let color_target = [Some(wgpu::ColorTargetState {
format: color,
blend: None,
write_mask: wgpu::ColorWrites::empty(),
})];
let (fragment_entry, targets, depth_compare) = match (depth_test, gl) {
(DepthTest::Early, false) => (
"fs_box_early",
&color_target[..],
wgpu::CompareFunction::GreaterEqual,
),
(DepthTest::Early, true) => (
"fs_box_early_depth",
&[][..],
wgpu::CompareFunction::LessEqual,
),
(DepthTest::InShader, false) => ("fs_box", &[][..], wgpu::CompareFunction::Always),
(DepthTest::InShader, true) => {
("fs_box_gl", &[][..], wgpu::CompareFunction::Always)
}
};
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some(label),
layout: Some(&pipeline_layout),
vertex: wgpu::VertexState {
module: &module,
entry_point: Some(if gl { "vs_box_gl" } else { "vs_box" }),
compilation_options: Default::default(),
buffers: &[],
},
primitive: wgpu::PrimitiveState {
cull_mode: Some(wgpu::Face::Back),
front_face: if gl {
wgpu::FrontFace::Cw
} else {
wgpu::FrontFace::Ccw
},
..Default::default()
},
// The pass's depth test (reversed in the world pass, OpenGL's
// in a Java pack's), without writes.
depth_stencil: Some(wgpu::DepthStencilState {
format: wgpu::TextureFormat::Depth32Float,
depth_write_enabled: Some(false),
depth_compare: Some(depth_compare),
stencil: Default::default(),
bias: Default::default(),
}),
multisample: Default::default(),
fragment: Some(wgpu::FragmentState {
module: &module,
entry_point: Some(fragment_entry),
compilation_options: Default::default(),
targets,
}),
multiview_mask: None,
cache: None,
})
};
let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("Section culling"),
layout: Some(&pipeline_layout),
vertex: wgpu::VertexState {
module: &module,
entry_point: Some("vs_box"),
compilation_options: Default::default(),
buffers: &[],
},
primitive: wgpu::PrimitiveState {
cull_mode: Some(wgpu::Face::Back),
..Default::default()
},
// The world pass's reversed depth test, without writes.
depth_stencil: Some(wgpu::DepthStencilState {
format: wgpu::TextureFormat::Depth32Float,
depth_write_enabled: Some(false),
depth_compare: Some(depth_compare),
stencil: Default::default(),
bias: Default::default(),
}),
multisample: Default::default(),
fragment: Some(wgpu::FragmentState {
module: &module,
entry_point: Some(fragment_entry),
compilation_options: Default::default(),
targets,
}),
multiview_mask: None,
cache: None,
});
let gl_pipeline = pipeline("Section culling, OpenGL layout", true);
let pipeline = pipeline("Section culling", false);
Self {
pipeline,
gl_pipeline,
layout,
group: None,
depth_test,
@@ -553,6 +586,51 @@ impl Cull {
pass.draw(0..36, 0..self.test_data.len() as u32);
}
/// [`Self::test`] for a Java shader pack that draws the terrain
/// (`gfx/java_stages.rs`): in a pass of its own against `depth`, the
/// pack's depth after phase 1 in OpenGL's layout (y up, 0 near), attached
/// read only, and also read by the shader where the test runs there
/// (`InShader`).
pub fn test_gl(
&self,
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
depth: &wgpu::TextureView,
) {
let Some(Group { group, .. }) = &self.group else {
return;
};
if self.test_data.is_empty() {
return;
}
let depth_group = self.depth_layout.as_ref().map(|layout| {
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Section culling depth, Java shader pack"),
layout,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(depth),
}],
})
});
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Section culling, Java shader pack"),
color_attachments: &[],
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: depth,
depth_ops: None,
stencil_ops: None,
}),
..Default::default()
});
pass.set_pipeline(&self.gl_pipeline);
pass.set_bind_group(0, group, &[]);
if let Some(depth) = &depth_group {
pass.set_bind_group(1, depth, &[]);
}
pass.draw(0..36, 0..self.test_data.len() as u32);
}
/// After the world passes: copy the results for reading back, when a
/// readback buffer is free.
pub fn end(&mut self, device: &wgpu::Device, encoder: &mut wgpu::CommandEncoder) {
+22
View File
@@ -52,6 +52,10 @@ fn corner(origin: vec3<f32>, c: u32) -> vec3<f32> {
// section fail the depth test against the final depth, which is only nearer.
@vertex
fn vs_box(@builtin(vertex_index) v: u32, @builtin(instance_index) t: u32) -> Box {
return box_vertex(v, t);
}
fn box_vertex(v: u32, t: u32) -> Box {
let origin = origins[tests[t].x].xyz;
var out: Box;
out.test = t;
@@ -86,6 +90,15 @@ fn vs_box(@builtin(vertex_index) v: u32, @builtin(instance_index) t: u32) -> Box
return out;
}
// The same box in OpenGL's layout, for a Java shader pack's terrain depth
// (gfx/java_stages.rs): y flipped, depth from 0 near to 1 far.
@vertex
fn vs_box_gl(@builtin(vertex_index) v: u32, @builtin(instance_index) t: u32) -> Box {
var out = box_vertex(v, t);
out.position = vec4(out.position.x, -out.position.y, out.position.w - out.position.z, out.position.w);
return out;
}
// The box is seen at this fragment: store the stamp, and give its phase 2
// draws their instance.
fn see(t: u32) {
@@ -111,3 +124,12 @@ fn fs_box(in: Box) {
see(in.test);
}
}
// fs_box against a Java shader pack's depth in OpenGL's layout (`vs_box_gl`):
// less or equal passing.
@fragment
fn fs_box_gl(in: Box) {
if in.position.z <= textureLoad(depth, vec2<u32>(in.position.xy), 0) {
see(in.test);
}
}
+10 -5
View File
@@ -2,11 +2,14 @@
use super::Vertex;
/// Entity materials by a quad's overlay (`Vertex::layer`), in draw order:
/// ordinary entities, breaking cracks (11), translucent breaking cracks (12)
/// and the boat water mask (13, `RenderPipelines.WATER_MASK`).
const MATERIALS: usize = 4;
/// ordinary entities, breaking cracks (11), translucent breaking cracks (12),
/// the boat water mask (13, `RenderPipelines.WATER_MASK`) and entity shadows
/// (14, `RenderPipelines.ENTITY_SHADOW`).
const MATERIALS: usize = 5;
/// The overlay of depth-only quads that hide water (`RenderTypes.waterMask`).
pub const WATER_MASK_OVERLAY: u32 = 13;
/// The overlay of entity shadow quads (`RenderTypes.entityShadow`).
pub const SHADOW_OVERLAY: u32 = 14;
#[derive(Default)]
pub(super) struct EntityBatch {
@@ -37,6 +40,7 @@ impl EntityBatch {
11 => 1,
12 => 2,
WATER_MASK_OVERLAY => 3,
SHADOW_OVERLAY => 4,
_ => 0,
};
self.buckets[material][counts[material]] = index;
@@ -88,12 +92,13 @@ mod tests {
) -> (Vec<Vertex>, [u32; MATERIALS]) {
let mut combined = Vec::with_capacity(entities.len() + additive.len() + hand.len());
let mut counts = [0; MATERIALS];
for (i, layer) in [0, 11, 12, 13].into_iter().enumerate() {
for (i, layer) in [0, 11, 12, 13, 14].into_iter().enumerate() {
for quad in entities.as_chunks::<4>().0 {
let material = match quad[0].layer {
11 => 11,
12 => 12,
13 => 13,
14 => 14,
_ => 0,
};
if material == layer {
@@ -113,7 +118,7 @@ mod tests {
pos: [index as f32, 2.0, 3.0],
uv: [index as f32, 5.0],
layer: if mixed {
[7, 11, 12, 4, 13, 0][index / 4 % 6]
[7, 11, 14, 12, 4, 13, 0][index / 4 % 7]
} else {
0
},
+4 -1
View File
@@ -663,11 +663,13 @@ impl Flat {
pass.draw_indexed(call.first..call.first + call.count, 0, 0..1);
}
}
/// Draws phase 2's calls, as `flatten_phase2` left them.
/// Draws phase 2's calls, as `flatten_phase2` left them; `page` as in
/// [`Self::draw`].
pub fn draw_phase2<'a>(
&self,
pass: &mut wgpu::RenderPass<'_>,
vertices: impl Fn(u32) -> &'a wgpu::Buffer,
page: impl Fn(&mut wgpu::RenderPass<'_>, u32),
) {
pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
for (k, call) in self.calls[self.phase1_calls..self.solid_calls]
@@ -675,6 +677,7 @@ impl Flat {
.enumerate()
{
self.bind_page(pass, call.page, &vertices);
page(pass, call.page);
pass.draw_indexed_indirect(&self.phase2_calls, k as u64 * 20);
}
}
+635 -51
View File
@@ -15,7 +15,7 @@
//! into the pack's targets right after, against the world's depth, and its
//! `gbuffers_water` draws the translucent terrain after `deferred`, as in
//! Iris. `depthtex1` and `depthtex2` then hold the depth before it.
use super::java_terrain::{Atlas, JavaWorld, TerrainPipelines};
use super::java_terrain::{Atlas, JavaWorld, Layer, TerrainPipelines};
use super::pack_stages::{FrameUniform, noise, rgba_view};
use crate::java_pack::{JavaFolder, JavaPasses, NOISE_KEY, blend_state, pass_blends, texture_key};
use crate::shader_pack::Rgba;
@@ -176,6 +176,19 @@ struct Views<'a> {
depth_solid: &'a wgpu::TextureView,
atlas: Option<&'a wgpu::TextureView>,
lightmap: Option<&'a wgpu::TextureView>,
shadow: Option<&'a ShadowViews>,
}
/// The shadow map's textures, as the passes read them.
struct ShadowViews {
/// `shadowtex0` and `shadowtex1` for comparisons (`Depth32Float`).
depth: wgpu::TextureView,
depth_solid: wgpu::TextureView,
/// The same as plain floats, for `sampler2D` reads (`R32Float`).
float: wgpu::TextureView,
float_solid: wgpu::TextureView,
/// `shadowcolor<N>`, for the targets the shadow programs write.
colors: Vec<Option<wgpu::TextureView>>,
}
/// A colour target's two sides.
@@ -199,10 +212,15 @@ enum Source {
/// before translucent water.
DepthSolid,
Noise,
/// `shadowtex*`: no shadow map yet, so a far depth (nothing in shadow);
/// also Distant Horizons' and Voxy's depth, as without those mods.
Shadow,
/// Anything else (`shadowcolor*`, custom textures): white or black.
/// `shadowtex0` (with translucent terrain) or `shadowtex1` (without):
/// the shadow map when the pack draws one, else a far depth (nothing in
/// shadow).
ShadowDepth(u32),
/// `shadowcolor<N>`: the shadow map's colour target, else white.
ShadowColor(u32),
/// Distant Horizons' and Voxy's depth: far, as without those mods.
Far,
/// Anything else (custom textures): white or black.
Blank(bool),
/// In geometry programs: the block atlas (`gtexture`), the lightmap,
/// and a flat normal map for `normals` (sprites have no LabPBR maps).
@@ -221,9 +239,13 @@ fn source(name: &str, geometry: bool) -> Source {
"depthtex0" | "gdepthtex" => Source::Depth,
"depthtex1" | "depthtex2" => Source::DepthSolid,
"noisetex" => Source::Noise,
"shadowtex0" | "shadowtex1" | "shadow" | "watershadow" => Source::Shadow,
n if n.starts_with("dhDepthTex") || n.starts_with("vxDepthTex") => Source::Shadow,
n if n.starts_with("shadowcolor") => Source::Blank(true),
"shadowtex0" | "shadow" | "watershadow" => Source::ShadowDepth(0),
"shadowtex1" => Source::ShadowDepth(1),
n if n.starts_with("dhDepthTex") || n.starts_with("vxDepthTex") => Source::Far,
"shadowcolor" => Source::ShadowColor(0),
n if let Some(i) = n.strip_prefix("shadowcolor").and_then(|i| i.parse().ok()) => {
Source::ShadowColor(i)
}
n => target_index(n).map_or(Source::Blank(false), Source::Target),
}
}
@@ -263,6 +285,8 @@ struct PassGpu {
/// them), and the targets written on their alternate side.
flat_pipeline: Option<wgpu::RenderPipeline>,
geometry: Option<BTreeSet<u32>>,
/// A shadow program: the light's matrices, `shadowcolor` targets.
shadow: bool,
}
/// What a pass draws into.
@@ -279,6 +303,8 @@ struct GeometrySetup<'a> {
/// Each draw buffer's blending.
blends: &'a [Option<wgpu::BlendState>],
layouts: &'a GeometryLayouts<'a>,
/// A shadow program: no face culling (Iris's `ShadowRenderer`).
shadow: bool,
}
/// The renderer's bind group layouts a geometry program's pipelines use:
@@ -294,6 +320,19 @@ struct FolderGeometry {
terrain: PassGpu,
water: Option<PassGpu>,
translucent_at: usize,
/// Its shadow programs, when it has some and they compile.
shadow: Option<FolderShadow>,
}
/// A folder's shadow map: its programs over the solid and translucent
/// terrain, its `shadowcolor` targets, and where it runs.
struct FolderShadow {
solid: PassGpu,
water: Option<PassGpu>,
/// Per `shadowcolor` target: its format and clear colour.
targets: Vec<(wgpu::TextureFormat, Option<wgpu::Color>)>,
/// How many passes run before it (`begin*`).
at: usize,
}
/// What every pass of the pack shares.
@@ -328,6 +367,7 @@ struct Bound {
/// Per pass, then `final`.
groups: Vec<wgpu::BindGroup>,
geometry: Option<BoundGeometry>,
shadow: Option<BoundShadow>,
world_in: (wgpu::RenderPipeline, wgpu::BindGroup),
/// The world's target, and whether the world goes to its alternate side.
world_target: u32,
@@ -340,6 +380,25 @@ struct Bound {
_blank: Vec<wgpu::Texture>,
}
/// The shadow map's textures and its programs' groups.
struct BoundShadow {
views: ShadowViews,
/// The depth buffer the shadow programs draw with (`shadowtex0`), and
/// its copy before translucent terrain (`shadowtex1`).
depth: wgpu::Texture,
depth_solid: wgpu::Texture,
/// The `shadowcolor` targets cleared each frame, with their colour,
/// and those cleared only when made (kept between frames).
clears: Vec<(wgpu::TextureView, wgpu::Color)>,
initial: Vec<(wgpu::TextureView, wgpu::Color)>,
solid: wgpu::BindGroup,
water: Option<wgpu::BindGroup>,
/// `depth` for `depth_out` into the float copies.
out_group: wgpu::BindGroup,
/// A pass reads the depth as plain floats: the copies are made.
float_reads: bool,
}
/// What a folder's geometry programs draw with at one size.
struct BoundGeometry {
/// The depth buffer the geometry tests against: the world's, then the
@@ -471,6 +530,24 @@ impl JavaStages {
})
}
/// Where the pack's shadow map looks this frame in `dimension`, when
/// it draws one: its view of camera-relative positions (`camera` is the
/// camera's position), and its half width, near and far planes, for
/// the renderer to pick the sections it draws.
pub fn shadow_view(
&self,
dimension: i8,
world: &JavaFrame,
camera: Vec3,
) -> Option<(Mat4, [f32; 3])> {
let index = self.folder_for[(dimension.clamp(-1, 1) + 1) as usize].unwrap_or(0);
let folder = self.folders.get(index)?;
folder.geometry.as_ref()?.shadow.as_ref()?;
let d = folder.directives;
let (view, _) = shadow_matrices(&d, shadow_angle(world), camera);
Some((view, [d.shadow.distance, d.shadow.near, d.shadow.far]))
}
/// Whether the pack draws the terrain in `dimension` (0 overworld, -1
/// the Nether, 1 the End): the renderer then leaves it out of the world
/// and gives `run` a [`JavaWorld`].
@@ -509,12 +586,13 @@ impl JavaStages {
self.atlas = Atlas::new(device, queue, w);
self.bound = None;
}
if self.bound.as_ref().is_none_or(|b| {
let fresh = self.bound.as_ref().is_none_or(|b| {
b.folder != folder
|| b.size != size
|| b.post_generation != post.generation()
|| b.geometry.is_some() != terrain.is_some()
}) {
});
if fresh {
self.bound = Some(self.bind(device, queue, folder, color, depth, size, post, terrain));
}
let now = std::time::Instant::now();
@@ -530,6 +608,8 @@ impl JavaStages {
self.previous,
);
inputs.set_world(&world, directives.sun_path_rotation);
(inputs.shadow_view, inputs.shadow_projection) =
shadow_matrices(&directives, inputs.shadow_angle, inputs.camera);
if let Some(atlas) = &self.atlas {
inputs.atlas_size = atlas.size().map(|v| v as f32);
}
@@ -575,7 +655,14 @@ impl JavaStages {
let translucent_at = geometry.map_or(usize::MAX, |((g, _), _)| {
g.translucent_at.min(folder.passes.len())
});
let shadow = geometry
.and_then(|((g, b), w)| Some((g.shadow.as_ref()?, bound.shadow.as_ref()?, b, w)));
for i in 0..=folder.passes.len() {
if let Some((sh, b, g, w)) = shadow
&& i == sh.at.min(folder.passes.len())
{
draw_shadow(queue, encoder, sh, b, g, &inputs, w, fresh);
}
if i == world_at {
world_in(encoder, bound);
if let Some(((g, b), w)) = geometry {
@@ -632,6 +719,151 @@ impl JavaStages {
&bound.output
}
/// The shadow map's textures at the folder's `shadowMapResolution`,
/// and its programs' groups.
#[allow(clippy::too_many_arguments)]
fn bind_shadow(
&self,
device: &wgpu::Device,
queue: &wgpu::Queue,
folder: &Folder,
shadow: &FolderShadow,
targets: &BTreeMap<u32, Target>,
world: Option<&JavaWorld>,
blank: &mut Vec<wgpu::Texture>,
) -> BoundShadow {
let side = folder
.directives
.shadow
.resolution
.clamp(1, device.limits().max_texture_dimension_2d);
let texture = |label, format, usage| {
device.create_texture(&wgpu::TextureDescriptor {
label: Some(label),
size: wgpu::Extent3d {
width: side,
height: side,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage,
view_formats: &[],
})
};
use wgpu::TextureUsages as U;
let depth = texture(
"Java shader pack shadow depth",
wgpu::TextureFormat::Depth32Float,
U::RENDER_ATTACHMENT | U::TEXTURE_BINDING | U::COPY_SRC,
);
let depth_solid = texture(
"Java shader pack shadow depth before translucent terrain",
wgpu::TextureFormat::Depth32Float,
U::TEXTURE_BINDING | U::COPY_DST,
);
let float = |label| {
texture(
label,
wgpu::TextureFormat::R32Float,
U::RENDER_ATTACHMENT | U::TEXTURE_BINDING,
)
.create_view(&Default::default())
};
// The colour targets the shadow programs write or a pass reads.
let passes = folder.passes.iter().chain(&folder.final_pass).chain(
folder
.geometry
.iter()
.flat_map(|g| std::iter::once(&g.terrain).chain(&g.water)),
);
let mut used: BTreeSet<u32> = shadow
.solid
.draw_buffers
.iter()
.chain(shadow.water.iter().flat_map(|w| &w.draw_buffers))
.copied()
.collect();
let mut float_reads = false;
for s in passes.clone().flat_map(|p| &p.samplers) {
match s.source {
Source::ShadowColor(i) => {
used.insert(i);
}
Source::ShadowDepth(_) if !s.compare => float_reads = true,
_ => {}
}
}
let mut colors = Vec::new();
let mut clears = Vec::new();
let mut initial = Vec::new();
for (i, &(format, clear)) in shadow.targets.iter().enumerate() {
if !used.contains(&(i as u32)) {
colors.push(None);
continue;
}
let view = texture(
"Java shader pack shadowcolor",
format,
U::RENDER_ATTACHMENT | U::TEXTURE_BINDING,
)
.create_view(&Default::default());
match clear {
Some(color) => clears.push((view.clone(), color)),
// Kept between frames: white to start with, as Iris's.
None => initial.push((view.clone(), wgpu::Color::WHITE)),
}
colors.push(Some(view));
}
let views = ShadowViews {
depth: depth.create_view(&Default::default()),
depth_solid: depth_solid.create_view(&Default::default()),
float: float("Java shader pack shadowtex0"),
float_solid: float("Java shader pack shadowtex1"),
colors,
};
// The shadow programs read neither the shadow map nor the size of
// the world's depth.
let unused = texture(
"Java shader pack shadow pass depth",
wgpu::TextureFormat::R32Float,
U::TEXTURE_BINDING,
)
.create_view(&Default::default());
let pass_views = Views {
depth: &unused,
depth_solid: &unused,
atlas: self.atlas.as_ref().map(|a| &a.view),
lightmap: world.map(|w| w.lightmap),
shadow: None,
};
let mut bind =
|pass: &PassGpu| pass.bind(device, queue, targets, &pass_views, &self.common, blank);
let solid = bind(&shadow.solid);
let water = shadow.water.as_ref().map(&mut bind);
let out_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Java shader pack shadow depth"),
layout: &self.common.depth_layout,
entries: &[wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(&views.depth),
}],
});
BoundShadow {
views,
depth,
depth_solid,
clears,
initial,
solid,
water,
out_group,
float_reads,
}
}
#[allow(clippy::too_many_arguments)]
fn bind(
&self,
@@ -740,13 +972,17 @@ impl JavaStages {
size,
)
.create_view(&Default::default());
let mut blank = Vec::new();
let shadow = geometry
.and_then(|g| g.shadow.as_ref())
.map(|sh| self.bind_shadow(device, queue, folder, sh, &targets, world, &mut blank));
let views = Views {
depth: &depth,
depth_solid: &depth_solid,
atlas: self.atlas.as_ref().map(|a| &a.view),
lightmap: world.map(|w| w.lightmap),
shadow: shadow.as_ref().map(|s| &s.views),
};
let mut blank = Vec::new();
let groups = all
.clone()
.map(|pass| pass.bind(device, queue, &targets, &views, &self.common, &mut blank))
@@ -887,6 +1123,7 @@ impl JavaStages {
depth_solid,
groups,
geometry,
shadow,
world_in: (world_pipeline, world_group),
world_target: folder.world_target,
world_alt: plan.flipped_after_prepare.contains(&folder.world_target),
@@ -918,6 +1155,7 @@ fn folder_geometry(
flat_vertex: g.variants.first().unwrap_or(&g.program.vertex),
blends,
layouts,
shadow: false,
}),
)
};
@@ -931,11 +1169,15 @@ fn folder_geometry(
terrain,
water,
translucent_at: plan.translucent_at,
shadow: None,
})
});
let error = pollster::block_on(scope.pop());
match (made, error) {
(Ok(geometry), None) => Some(geometry),
(Ok(mut geometry), None) => {
geometry.shadow = folder_shadow(device, plan, layouts);
Some(geometry)
}
(Err(e), _) => {
log::warn!("Horizon: shader pack {}: {e}", terrain.program.pass.program);
None
@@ -947,6 +1189,210 @@ fn folder_geometry(
}
}
/// A folder's shadow programs on the GPU, or `None` (with a warning: the
/// pack then reads a shadow map with nothing in shadow) when wgpu refuses
/// them.
fn folder_shadow(
device: &wgpu::Device,
plan: &JavaFolder,
layouts: &GeometryLayouts,
) -> Option<FolderShadow> {
let solid = plan.shadow.as_ref()?;
let formats: Vec<wgpu::TextureFormat> = plan
.shadow_targets
.iter()
.map(|t| target_format(&t.format, false))
.collect();
// Instanced draws only: the flat draws hold what the camera sees.
let layouts = GeometryLayouts {
flat: None,
page: layouts.page,
};
let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
let gpu = |g: &GeometryProgram, blends: &[Option<wgpu::BlendState>]| {
PassGpu::new(
device,
&g.program,
&formats,
Output::Geometry(GeometrySetup {
flat_vertex: &g.program.vertex,
blends,
layouts: &layouts,
shadow: true,
}),
)
};
let made = gpu(solid, &plan.shadow_blends).and_then(|solid_gpu| {
let water = plan
.shadow_water
.as_ref()
.map(|w| gpu(w, &plan.shadow_water_blends))
.transpose()?;
Ok((solid_gpu, water))
});
let error = pollster::block_on(scope.pop());
let warn = |e: &dyn std::fmt::Display| {
log::warn!("Horizon: shader pack {}: {e}", solid.program.pass.program);
};
match (made, error) {
(Ok((solid_gpu, water)), None) => Some(FolderShadow {
solid: solid_gpu,
water,
targets: plan
.shadow_targets
.iter()
.zip(&formats)
.map(|(t, &format)| {
let clear = t.clear.then(|| {
let [r, g, b, a] = t.clear_color.unwrap_or([1.0; 4]);
wgpu::Color {
r: r.into(),
g: g.into(),
b: b.into(),
a: a.into(),
}
});
(format, clear)
})
.collect(),
at: plan.shadow_at,
}),
(Err(e), _) => {
warn(&e);
None
}
(_, Some(e)) => {
warn(&e);
None
}
}
}
/// The shadow map: Horizon's terrain from the light with the pack's
/// shadow programs, solid then translucent (`ShadowRenderer`), with the
/// depth before translucent terrain kept for `shadowtex1`.
#[allow(clippy::too_many_arguments)]
fn draw_shadow(
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
shadow: &FolderShadow,
b: &BoundShadow,
geometry: &BoundGeometry,
inputs: &Inputs,
world: &JavaWorld,
fresh: bool,
) {
if fresh {
for (view, color) in &b.initial {
clear_view(encoder, view, *color);
}
}
for (view, color) in &b.clears {
clear_view(encoder, view, *color);
}
let draw = |encoder: &mut wgpu::CommandEncoder,
pass: &PassGpu,
group: &wgpu::BindGroup,
layer: Layer,
first: bool| {
pass.write_uniforms(queue, inputs);
let attachments: Vec<Option<wgpu::RenderPassColorAttachment>> = pass
.draw_buffers
.iter()
.map(|&i| {
let view = b.views.colors.get(i as usize)?.as_ref()?;
Some(color_attachment(view, None))
})
.collect();
let mut render = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some(&pass.program),
color_attachments: &attachments,
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &b.views.depth,
depth_ops: Some(wgpu::Operations {
load: if first {
wgpu::LoadOp::Clear(1.0)
} else {
wgpu::LoadOp::Load
},
store: wgpu::StoreOp::Store,
}),
stencil_ops: None,
}),
..Default::default()
});
(world.draw)(
&mut render,
layer,
&TerrainPipelines {
instanced: &pass.pipeline,
flat: None,
group,
},
);
};
let float_out = |encoder: &mut wgpu::CommandEncoder, solid: bool| {
if !b.float_reads {
return;
}
let mut attachments = vec![Some(color_attachment(&b.views.float, None))];
if solid {
attachments.push(Some(color_attachment(&b.views.float_solid, None)));
}
let mut render = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Java shader pack shadow depth"),
color_attachments: &attachments,
..Default::default()
});
render.set_pipeline(if solid {
&geometry.out_both
} else {
&geometry.out
});
render.set_bind_group(0, &b.out_group, &[]);
render.draw(0..3, 0..1);
};
draw(encoder, &shadow.solid, &b.solid, Layer::ShadowSolid, true);
encoder.copy_texture_to_texture(
b.depth.as_image_copy(),
b.depth_solid.as_image_copy(),
b.depth.size(),
);
float_out(encoder, true);
if let (Some(pass), Some(group)) = (&shadow.water, &b.water) {
draw(encoder, pass, group, Layer::ShadowTranslucent, false);
float_out(encoder, false);
}
}
/// Iris's `shadowModelView` and `shadowProjection` (`ShadowMatrices`):
/// the light's view of camera-relative positions, snapped to the pack's
/// `shadowIntervalSize` as the camera moves, and an orthographic
/// projection `shadowDistance` wide each way of the camera.
pub fn shadow_matrices(directives: &Directives, shadow_angle: f32, camera: Vec3) -> (Mat4, Mat4) {
let sky = if shadow_angle < 0.25 {
shadow_angle + 0.75
} else {
shadow_angle - 0.25
};
let mut view = Mat4::from_rotation_x(90f32.to_radians())
* Mat4::from_rotation_z((sky * -360.0).to_radians())
* Mat4::from_rotation_x(directives.sun_path_rotation.to_radians());
let d = &directives.shadow;
if d.interval != 0.0 {
// Java's `%` keeps the dividend's sign, as Rust's does.
let offset = Vec3::new(
camera.x % d.interval,
camera.y % d.interval,
camera.z % d.interval,
) - Vec3::splat(d.interval / 2.0);
view *= Mat4::from_translation(offset);
}
let h = d.distance;
let projection = Mat4::orthographic_rh_gl(-h, h, -h, h, d.near, d.far);
(view, projection)
}
fn world_in(encoder: &mut wgpu::CommandEncoder, bound: &Bound) {
let target = &bound.targets[&bound.world_target];
let side = if bound.world_alt {
@@ -1286,7 +1732,10 @@ impl PassGpu {
)),
)
}
(false, Source::Depth | Source::DepthSolid | Source::Shadow) => (
(
false,
Source::Depth | Source::DepthSolid | Source::ShadowDepth(_) | Source::Far,
) => (
wgpu::TextureSampleType::Float { filterable: false },
Some(false),
),
@@ -1477,6 +1926,7 @@ impl PassGpu {
scale: program.pass.scale.clamp(0.0, 1.0),
flat_pipeline: None,
geometry: None,
shadow: false,
})
}
@@ -1559,9 +2009,10 @@ impl PassGpu {
compilation_options: Default::default(),
buffers: &buffers,
},
// The y flip into GL's layout turns the faces around.
// The y flip into GL's layout turns the faces around. The
// shadow map culls none (a mountain's back casts shadows).
primitive: wgpu::PrimitiveState {
cull_mode: Some(wgpu::Face::Back),
cull_mode: (!setup.shadow).then_some(wgpu::Face::Back),
front_face: wgpu::FrontFace::Cw,
..Default::default()
},
@@ -1619,6 +2070,7 @@ impl PassGpu {
scale: 1.0,
flat_pipeline,
geometry: Some(flipped),
shadow: setup.shadow,
})
}
@@ -1642,11 +2094,34 @@ impl PassGpu {
.get(&texture_key(&self.program, &s.name))
})
.flatten();
let shadow = textures
.shadow
.filter(|_| s.dimension == wgpu::TextureViewDimension::D2);
let view = if let Some(custom) = custom {
custom.clone()
} else {
match (s.compare, s.source) {
(true, Source::ShadowDepth(i)) if let Some(sh) = shadow => {
if i == 0 {
sh.depth.clone()
} else {
sh.depth_solid.clone()
}
}
(true, _) => blank_view(device, queue, blank, s, BlankKind::FarDepth),
(false, Source::ShadowDepth(i)) if let Some(sh) = shadow => {
if i == 0 {
sh.float.clone()
} else {
sh.float_solid.clone()
}
}
(false, Source::ShadowColor(i))
if let Some(view) =
shadow.and_then(|sh| sh.colors.get(i as usize)?.as_ref()) =>
{
view.clone()
}
(false, Source::Target(i)) if s.dimension == wgpu::TextureViewDimension::D2 => {
match targets.get(&i) {
Some(t) if self.reads_alt.contains(&i) => t.alt_view.clone(),
@@ -1677,7 +2152,12 @@ impl PassGpu {
(false, Source::FlatNormal) => {
blank_view(device, queue, blank, s, BlankKind::FlatNormal)
}
(false, Source::Shadow) => blank_view(device, queue, blank, s, BlankKind::Far),
(false, Source::ShadowDepth(_) | Source::Far) => {
blank_view(device, queue, blank, s, BlankKind::Far)
}
(false, Source::ShadowColor(_)) => {
blank_view(device, queue, blank, s, BlankKind::Color(true))
}
(false, Source::Noise) if s.dimension == wgpu::TextureViewDimension::D2 => {
common.noise.clone()
}
@@ -1697,7 +2177,10 @@ impl PassGpu {
(true, _) => &common.compare,
_ if s.signed.is_some() => &common.nearest,
(false, Source::Noise) => &common.repeat,
(false, Source::Depth | Source::DepthSolid | Source::Shadow) => &common.nearest,
(
false,
Source::Depth | Source::DepthSolid | Source::ShadowDepth(_) | Source::Far,
) => &common.nearest,
(false, Source::Atlas) => &common.atlas,
(false, Source::Target(i)) => {
match targets.get(&i).map(|t| sample_type(t.format)) {
@@ -1746,7 +2229,12 @@ impl PassGpu {
};
let mut bytes = vec![0u8; *block_size as usize];
for (name, slots) in &self.uniforms {
if let Some(values) = inputs.value(name, self.geometry.is_some()) {
let values = if self.shadow {
inputs.shadow(name).or_else(|| inputs.value(name, true))
} else {
inputs.value(name, self.geometry.is_some())
};
if let Some(values) = values {
for (&(offset, int), value) in slots.iter().zip(values) {
let at = offset as usize..offset as usize + 4;
bytes[at].copy_from_slice(&if int {
@@ -1797,28 +2285,38 @@ impl PassGpu {
Some(color_attachment(side, None))
})
.collect();
let mut render = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some(&self.program),
color_attachments: &attachments,
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: depth,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Load,
store: wgpu::StoreOp::Store,
let pipelines = TerrainPipelines {
instanced: &self.pipeline,
flat: self.flat_pipeline.as_ref(),
group,
};
let draw = |encoder: &mut wgpu::CommandEncoder, layer| {
let mut render = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some(&self.program),
color_attachments: &attachments,
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: depth,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Load,
store: wgpu::StoreOp::Store,
}),
stencil_ops: None,
}),
stencil_ops: None,
}),
..Default::default()
});
(world.draw)(
&mut render,
translucent,
&TerrainPipelines {
instanced: &self.pipeline,
flat: self.flat_pipeline.as_ref(),
group,
},
);
..Default::default()
});
(world.draw)(&mut render, layer, &pipelines);
};
if translucent {
draw(encoder, Layer::Translucent);
return;
}
draw(encoder, Layer::Solid);
// Occlusion culling: the sections left out, tested against what
// phase 1 drew, then the ones in sight.
if let Some(test) = world.occlusion {
test(encoder, depth);
draw(encoder, Layer::Revealed);
}
}
/// Draw into the targets of `draw_buffers`, on the side it doesn't read.
@@ -2114,6 +2612,19 @@ struct Inputs {
custom: HashMap<String, Vec<f32>>,
/// `atlasSize`, in geometry programs.
atlas_size: [f32; 2],
/// `shadowModelView` and `shadowProjection` ([`shadow_matrices`]).
shadow_view: Mat4,
shadow_projection: Mat4,
}
/// `shadowAngle`: the sun's angle by day, the moon's by night, 0..1.
fn shadow_angle(world: &JavaFrame) -> f32 {
let sun = celestial_angle(world.sun_angle);
if sun < 180.0 {
sun / 360.0
} else {
celestial_angle(world.moon_angle) / 360.0
}
}
/// `CelestialUniforms.getSunAngle`: the body's angle plus 90, in 0..360
@@ -2170,6 +2681,8 @@ impl Inputs {
is_day: true,
custom: HashMap::new(),
atlas_size: [0.0; 2],
shadow_view: Mat4::IDENTITY,
shadow_projection: Mat4::IDENTITY,
};
out.set_world(&JavaFrame::default(), 0.0);
out
@@ -2195,11 +2708,7 @@ impl Inputs {
let sun = celestial_angle(world.sun_angle);
self.is_day = sun < 180.0;
self.sun_angle = sun / 360.0;
self.shadow_angle = if self.is_day {
sun
} else {
celestial_angle(world.moon_angle)
} / 360.0;
self.shadow_angle = shadow_angle(world);
}
/// The value of uniform `name`, as its scalars in order: Iris's own,
@@ -2249,6 +2758,26 @@ impl Inputs {
})
}
/// The uniforms whose value differs in shadow programs: the light's
/// matrices instead of the camera's.
fn shadow(&self, name: &str) -> Option<Vec<f32>> {
let mat = |m: Mat4| m.to_cols_array().to_vec();
let (view, projection) = (self.shadow_view, self.shadow_projection);
Some(match name {
"iris_ModelViewMatrix" | "modelViewMatrix" => mat(view),
"iris_ModelViewMatrixInverse" | "modelViewMatrixInverse" => mat(view.inverse()),
"iris_ProjectionMatrix" | "projectionMatrix" => mat(projection),
"iris_ProjectionMatrixInverse" | "projectionMatrixInverse" => mat(projection.inverse()),
"iris_ModelViewProjectionMatrix" => mat(projection * view),
"iris_NormalMatrix" | "normalMatrix" => Mat3::from_mat4(view)
.inverse()
.transpose()
.to_cols_array()
.to_vec(),
_ => return None,
})
}
/// The value of Iris uniform `name`; `None` for one Horizon doesn't
/// provide.
fn builtin(&self, name: &str) -> Option<Vec<f32>> {
@@ -2312,10 +2841,10 @@ impl Inputs {
"iris_ProjectionMatrixInverse" => mat(screen.inverse()),
"iris_TextureMatrix" => (0..8).flat_map(|_| mat(Mat4::IDENTITY)).collect(),
"iris_NormalMatrix" => Mat3::IDENTITY.to_cols_array().to_vec(),
"shadowModelView"
| "shadowModelViewInverse"
| "shadowProjection"
| "shadowProjectionInverse" => mat(Mat4::IDENTITY),
"shadowModelView" => mat(self.shadow_view),
"shadowModelViewInverse" => mat(self.shadow_view.inverse()),
"shadowProjection" => mat(self.shadow_projection),
"shadowProjectionInverse" => mat(self.shadow_projection.inverse()),
_ => return None,
})
}
@@ -2353,14 +2882,69 @@ mod tests {
);
}
#[test]
fn shadow_matrices_are_iris_s() {
use horizon_shaderpack::pipeline::ShadowDirectives;
let close = |a: Mat4, b: Mat4| {
for (x, y) in a.to_cols_array().iter().zip(b.to_cols_array()) {
assert!((x - y).abs() < 1e-5, "{a} != {b}");
}
};
// ShadowMatrices.Tests: shadowDistance 32, planes 0.05 and 256.
let directives = Directives {
shadow: ShadowDirectives {
distance: 32.0,
near: 0.05,
far: 256.0,
interval: 0.0,
..ShadowDirectives::default()
},
..Directives::default()
};
let (view, projection) = shadow_matrices(&directives, 0.25, Vec3::ZERO);
close(
projection,
Mat4::from_cols_array(&[
0.03125,
0.0,
0.0,
0.0,
0.0,
0.03125,
0.0,
0.0,
0.0,
0.0,
-0.007_814_026,
0.0,
0.0,
0.0,
-1.000_390_6,
1.0,
]),
);
// Noon: the light looks straight down (up is toward it, +z).
assert!((view.transform_vector3(Vec3::Y) - Vec3::Z).length() < 1e-5);
// Snapped to the interval: x 5.5 % 2 = 1.5 further than 0 % 2.
let directives = Directives::default();
let (snapped, _) = shadow_matrices(&directives, 0.25, Vec3::new(5.5, 0.0, 0.0));
let (plain, _) = shadow_matrices(&directives, 0.25, Vec3::ZERO);
close(
snapped,
plain * Mat4::from_translation(Vec3::new(1.5, 0.0, 0.0)),
);
}
#[test]
fn samplers_read_what_iris_binds() {
assert_eq!(source("colortex4", false), Source::Target(4));
assert_eq!(source("gaux1", false), Source::Target(4));
assert_eq!(source("gdepthtex", false), Source::Depth);
assert_eq!(source("shadowtex1", false), Source::Shadow);
assert_eq!(source("dhDepthTex0", false), Source::Shadow);
assert_eq!(source("shadowcolor0", false), Source::Blank(true));
assert_eq!(source("shadowtex1", false), Source::ShadowDepth(1));
assert_eq!(source("shadow", false), Source::ShadowDepth(0));
assert_eq!(source("dhDepthTex0", false), Source::Far);
assert_eq!(source("shadowcolor1", false), Source::ShadowColor(1));
assert_eq!(source("shadowcolor", false), Source::ShadowColor(0));
assert_eq!(source("cloudTexture", false), Source::Blank(false));
// Before translucent terrain; geometry programs' own textures.
assert_eq!(source("depthtex1", false), Source::DepthSolid);
+25 -3
View File
@@ -204,9 +204,29 @@ pub fn page_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout {
})
}
/// Draws Horizon's terrain with a pack's pipelines: the solid layer or the
/// translucent one. Set by the renderer, which owns the sections.
pub type DrawTerrain<'a> = dyn Fn(&mut wgpu::RenderPass<'_>, bool, &TerrainPipelines<'_>) + 'a;
/// Which of Horizon's terrain draws a pack's program draws.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Layer {
/// The solid sections: all of them, or with occlusion culling
/// ([`JavaWorld::occlusion`]) the ones the last test saw (phase 1).
Solid,
/// With occlusion culling, the solid sections the test after phase 1
/// found in sight (phase 2).
Revealed,
Translucent,
/// The shadow map's sections ([`super::Renderer`]'s shadow list), solid
/// then translucent.
ShadowSolid,
ShadowTranslucent,
}
/// Draws Horizon's terrain with a pack's pipelines. Set by the renderer,
/// which owns the sections.
pub type DrawTerrain<'a> = dyn Fn(&mut wgpu::RenderPass<'_>, Layer, &TerrainPipelines<'_>) + 'a;
/// Occlusion culling's test between [`Layer::Solid`] and
/// [`Layer::Revealed`], against the pack's depth (OpenGL's layout).
pub type OcclusionTest<'a> = dyn Fn(&mut wgpu::CommandEncoder, &wgpu::TextureView) + 'a;
/// What the renderer binds to draw with a pack's geometry program: the
/// pipeline of its draw path and the pack's group (group 2). Group 1 is the
@@ -229,6 +249,8 @@ pub struct JavaWorld<'a> {
pub animated: &'a [(u32, u32)],
pub lightmap: &'a wgpu::TextureView,
pub draw: &'a DrawTerrain<'a>,
/// Set when the frame culls solid sections by occlusion.
pub occlusion: Option<&'a OcclusionTest<'a>>,
}
const ATLAS: &str = r#"
+46 -6
View File
@@ -48,6 +48,16 @@ pub struct JavaFolder {
/// Each draw buffer's blending in `terrain` and `water`.
pub terrain_blends: Vec<Option<wgpu::BlendState>>,
pub water_blends: Vec<Option<wgpu::BlendState>>,
/// The shadow map's programs over Horizon's solid and translucent
/// terrain (instanced draws only), drawn after `begin*`, into
/// `shadowcolor` targets set by `shadow_targets`.
pub shadow: Option<GeometryProgram>,
pub shadow_water: Option<GeometryProgram>,
pub shadow_targets: Vec<TargetSettings>,
pub shadow_blends: Vec<Option<wgpu::BlendState>>,
pub shadow_water_blends: Vec<Option<wgpu::BlendState>>,
/// How many of `passes` run before the shadow map (`begin*`).
pub shadow_at: usize,
}
/// The key of `texture.noise` (`noisetex`) in [`JavaPasses::custom_textures`].
@@ -160,9 +170,14 @@ pub fn load(
}
// A geometry program that doesn't translate leaves that terrain to
// Horizon, with a warning.
let geometry = |pass: &Option<horizon_shaderpack::pipeline::Pass>, alpha_test| {
let geometry_with = |pass: &Option<horizon_shaderpack::pipeline::Pass>,
alpha_test,
flat: &[bool]| {
let pass = pass.as_ref()?;
let glues = [false, true].map(|flat| crate::gfx::java_terrain::glue(flat, alpha_test));
let glues: Vec<_> = flat
.iter()
.map(|&flat| crate::gfx::java_terrain::glue(flat, alpha_test))
.collect();
match pack.compile_geometry(pass, &plan.targets, &values, &env, &properties, &glues) {
Ok(program) => Some(program),
Err(e) => {
@@ -171,9 +186,20 @@ pub fn load(
}
}
};
let geometry = |pass: &Option<horizon_shaderpack::pipeline::Pass>, alpha_test| {
geometry_with(pass, alpha_test, &[false, true])
};
// Iris's alpha test of cutout terrain (`AlphaTests.ONE_TENTH_ALPHA`).
let terrain = geometry(&plan.terrain, Some(0.1));
let water = terrain.as_ref().and_then(|_| geometry(&plan.water, None));
// The shadow map draws only with the pack's terrain, and only from
// instanced draws (the flat draws hold what the camera sees).
let shadow = terrain
.as_ref()
.and_then(|_| geometry_with(&plan.shadow, Some(0.1), &[false]));
let shadow_water = shadow
.as_ref()
.and_then(|_| geometry_with(&plan.shadow_water, None, &[false]));
let translucent_at = early.clone().count() + plan.deferred.len();
let blends = |g: &Option<GeometryProgram>, default| {
g.as_ref().map_or_else(Vec::new, |g| {
@@ -181,6 +207,9 @@ pub fn load(
})
};
let terrain_blends = blends(&terrain, None);
// Iris's shadow programs don't blend (`BlendModeOverride.OFF`).
let shadow_blends = blends(&shadow, None);
let shadow_water_blends = blends(&shadow_water, None);
// Vanilla's translucent blending (`BlendFunction.TRANSLUCENT`).
let water_blends = blends(
&water,
@@ -213,6 +242,12 @@ pub fn load(
flipped_after_translucent: plan.flipped_after_translucent,
terrain_blends,
water_blends,
shadow,
shadow_water,
shadow_targets: plan.shadow_targets,
shadow_blends,
shadow_water_blends,
shadow_at: plan.begin.len(),
});
}
if folders.is_empty() {
@@ -359,10 +394,13 @@ mod tests {
.folders
.iter()
.flat_map(|f| f.passes.iter().chain(&f.final_pass));
let geometry = pack
.folders
.iter()
.flat_map(|f| f.terrain.iter().chain(&f.water));
let geometry = pack.folders.iter().flat_map(|f| {
f.terrain
.iter()
.chain(&f.water)
.chain(&f.shadow)
.chain(&f.shadow_water)
});
passes
.flat_map(|p| [(p, &p.vertex, "vsh"), (p, &p.fragment, "fsh")])
.chain(geometry.flat_map(|g| {
@@ -414,6 +452,8 @@ mod tests {
.terrain
.iter()
.chain(&f.water)
.chain(&f.shadow)
.chain(&f.shadow_water)
.map(|g| g.program.pass.program.as_str())
.collect();
format!("{} {n} passes, terrain {geometry:?}", f.folder)
+2
View File
@@ -1608,6 +1608,8 @@ impl Mob {
| Species::Fox
| Species::Panda
);
// The PathNavigation constructor: the base follow range.
mob.ai.nav.max_visited_nodes = (mob.kind.follow_range * 16.0).floor() as i32;
ai::register(&mut mob);
mob
}
+1 -1
View File
@@ -26,7 +26,7 @@ pub fn register(m: &mut Mob) {
};
m.ai.nav.kind = NavKind::Flying;
// FlyingPathNavigation.setRequiredPathLength(48).
m.ai.nav.required_path_length = 48.0;
m.set_required_path_length(48.0);
let g = &mut m.ai.goals;
g.add(0, Panic::new(2.5));
g.add(1, Fetch);
+1 -1
View File
@@ -138,7 +138,7 @@ pub fn register(m: &mut Mob) {
};
m.ai.nav.kind = NavKind::Flying;
m.ai.nav.can_open_doors = false;
m.ai.nav.required_path_length = 48.0;
m.set_required_path_length(48.0);
m.set_malus(PathType::Fire, -1.0);
m.set_malus(PathType::Water, -1.0);
m.set_malus(PathType::WaterBorder, 16.0);
@@ -26,7 +26,7 @@ pub const DROPPING_NO_ITEM: u8 = 4;
pub const WEATHER: [&str; 4] = ["unaffected", "exposed", "weathered", "oxidized"];
pub fn register(m: &mut Mob) {
m.ai.nav.required_path_length = 48.0;
m.set_required_path_length(48.0);
m.ai.nav.can_open_doors = true;
m.persistent = true;
// nextWeatheringTick starts unset (-1); waxed is -2.
@@ -464,6 +464,7 @@ pub fn finalize_spawn(m: &mut Mob, lr: &mut LegacyRandom) {
let bonus = lr.triangle(0.0, 0.114_850_000_000_000_01);
// ADD_MULTIPLIED_BASE on the base value.
m.attrs.follow_range += m.kind.follow_range * bonus;
m.update_max_visited_nodes();
let _left_handed = lr.next_float() < 0.05;
}
fn wrap_degrees(angle: f32) -> f32 {
+4 -1
View File
@@ -559,7 +559,10 @@ fn refresh(m: &mut Mob, a: Attr) {
match a {
Attr::MaxHealth => m.attrs.max_health = value(m, a) as f32,
Attr::MovementSpeed => m.attrs.speed = base_with_modifiers(m, a),
Attr::FollowRange => m.attrs.follow_range = value(m, a),
Attr::FollowRange => {
m.attrs.follow_range = value(m, a);
m.update_max_visited_nodes();
}
Attr::AttackDamage => m.attrs.attack_damage = value(m, a) as f32,
Attr::KnockbackResistance => m.attrs.knockback_resistance = value(m, a),
Attr::SpawnReinforcements => m.attrs.spawn_reinforcements = value(m, a),
@@ -39,6 +39,10 @@ fn setup(m: &mut Mob, baby: bool) {
m.ai.look.wanted = [0.0; 3];
m.ai.look.cooldown = 0;
m.extra.counter2 = 0;
// The new navigation's PathNavigation constructor.
m.ai.nav.required_path_length = 16.0;
m.ai.nav.max_visited_nodes =
(super::finalize::base_value(m, super::finalize::Attr::FollowRange) * 16.0).floor() as i32;
if baby {
m.ai.look.kind = LookKind::Default;
m.ai.mov.kind = MoveKind::Flying {
@@ -48,7 +52,7 @@ fn setup(m: &mut Mob, baby: bool) {
// BabyFlyingPathNavigation.
m.ai.nav.kind = NavKind::Flying;
m.ai.nav.can_float = true;
m.ai.nav.required_path_length = 48.0;
m.set_required_path_length(48.0);
return;
}
if was == 1 {
+1 -1
View File
@@ -50,7 +50,7 @@ pub fn is_illager(s: &Seen) -> bool {
)
}
pub fn register(m: &mut Mob) {
m.ai.nav.required_path_length = 40.0;
m.set_required_path_length(40.0);
let tempt = m.kind.tempt.clone();
let trader = is_trader(m);
if trader {
+17 -2
View File
@@ -37,7 +37,11 @@ pub struct Navigation {
reach_range: i32,
pub max_visited_multiplier: f32,
pub stuck: bool,
/// Set through [`Mob::set_required_path_length`].
pub required_path_length: f32,
/// `PathFinder.maxVisitedNodes`: the base follow range times 16 when the
/// navigation is made, then [`Mob::update_max_visited_nodes`].
pub max_visited_nodes: i32,
pub can_float: bool,
pub can_open_doors: bool,
pub can_pass_doors: bool,
@@ -68,6 +72,7 @@ impl Default for Navigation {
max_visited_multiplier: 1.0,
stuck: false,
required_path_length: 16.0,
max_visited_nodes: 256,
can_float: false,
can_open_doors: false,
can_pass_doors: true,
@@ -147,6 +152,16 @@ impl Mob {
fn max_path_length(&self) -> f32 {
(self.attrs.follow_range as f32).max(self.ai.nav.required_path_length)
}
/// `PathNavigation.updatePathfinderMaxVisitedNodes`: after a follow range
/// change and a new required path length.
pub fn update_max_visited_nodes(&mut self) {
self.ai.nav.max_visited_nodes = (self.max_path_length() * 16.0).floor() as i32;
}
/// `PathNavigation.setRequiredPathLength`.
pub fn set_required_path_length(&mut self, length: f32) {
self.ai.nav.required_path_length = length;
self.update_max_visited_nodes();
}
fn can_update_path(&self) -> bool {
match self.ai.nav.kind {
NavKind::Ground | NavKind::WallClimber => self.on_ground || self.is_in_liquid(),
@@ -237,8 +252,8 @@ impl Mob {
return Some(path.clone());
}
let pm = self.path_mob();
let max_visited = ((self.attrs.follow_range * 16.0).floor() as f32
* self.ai.nav.max_visited_multiplier) as i32;
let max_visited =
(self.ai.nav.max_visited_nodes as f32 * self.ai.nav.max_visited_multiplier) as i32;
let finder = Finder::new(w, &pm, self.ai.nav.evaluator());
let path = finder.find(targets, max_len, reach, max_visited);
if let Some(p) = &path {
+139 -1
View File
@@ -46,7 +46,7 @@ pub fn register(m: &mut Mob) {
// Villager's constructor: its brain does everything, it has no goals.
m.ai.nav.can_open_doors = true;
m.ai.nav.can_float = true;
m.ai.nav.required_path_length = 48.0;
m.set_required_path_length(48.0);
}
/// `LivingEntity.addParticlesAroundSelf`: five particles about the body.
@@ -614,6 +614,144 @@ pub fn meet(
gossiped: ready,
}
}
/// `Villager.spawnGolemIfNeeded` up to the spawn: villager `i` wants a golem
/// and so do at least `needed` of the villagers whose boxes meet its own grown
/// by 10 blocks. Returns all of those villagers: once the golem stands, they
/// remember it ([`super::villager_brain::golem_detected`]).
pub fn golem_summoners(mobs: &[Mob], i: usize, now: i64, needed: usize) -> Option<Vec<usize>> {
if !ext(&mobs[i]).is_some_and(|e| e.wants_golem(now)) {
return None;
}
let area = mobs[i]
.bounds()
.inflate(horizon_core::geometry::Vec3::new(10.0, 10.0, 10.0));
let near: Vec<usize> = mobs
.iter()
.enumerate()
.filter(|(_, m)| {
m.species() == Species::Villager && !m.removed && m.bounds().intersects(area)
})
.map(|(j, _)| j)
.collect();
let wanting = near
.iter()
.filter(|&&j| ext(&mobs[j]).is_some_and(|e| e.wants_golem(now)))
.take(5)
.count();
(wanting >= needed).then_some(near)
}
/// `SpawnUtil.Strategy.LEGACY_IRON_GOLEM`'s refused floors.
fn golem_floor_ok(name: &str) -> bool {
!matches!(
name,
"minecraft:cobweb"
| "minecraft:cactus"
| "minecraft:glass_pane"
| "minecraft:conduit"
| "minecraft:ice"
| "minecraft:tnt"
| "minecraft:glowstone"
| "minecraft:beacon"
| "minecraft:sea_lantern"
| "minecraft:frosted_ice"
| "minecraft:tinted_glass"
| "minecraft:glass"
) && !name.ends_with("_stained_glass_pane")
&& !name.ends_with("_stained_glass")
&& !name.ends_with("leaves")
}
/// One attempt of `SpawnUtil.trySpawnMob(IRON_GOLEM, ..., 8 across, 6 up and
/// down, LEGACY_IRON_GOLEM)`: a column drawn near `start`, searched down from
/// 6 above for a solid floor (or powder snow) under air or a liquid block.
/// Returns the block the golem would stand in.
fn golem_attempt<L: super::spawn_rules::SpawnLevel>(
l: &L,
start: [i32; 3],
random: &mut impl RandomSource,
) -> Option<[i32; 3]> {
let dx = random.next_int_bound(17).unwrap_or(8) - 8;
let dz = random.next_int_bound(17).unwrap_or(8) - 8;
let (x, z) = (start[0] + dx, start[2] + dz);
let name = |y: i32| -> &str { &l.facts().get(l.state(x, y, z)).name };
let mut y = start[1] + 6;
let mut above = l.state(x, y, z);
for _ in 0..=12 {
y -= 1;
let here = l.state(x, y, z);
let above_name = &*l.facts().get(above).name;
// BlockState.liquid(): a water or lava block (not a waterlogged one).
let open = l.facts().is_air(above)
|| above_name == "minecraft:water"
|| above_name == "minecraft:lava";
let solid = l.mob_data().state(here).flags & super::data::SOLID != 0
|| name(y) == "minecraft:powder_snow";
if golem_floor_ok(name(y)) && open && solid {
return Some([x, y + 1, z]);
}
above = here;
}
None
}
/// `IronGolem.checkSpawnObstruction`: a floor with a full top face, its feet
/// free whatever fluid is there, and the two blocks above free.
fn golem_fits<L: super::spawn_rules::SpawnLevel>(l: &L, [x, y, z]: [i32; 3]) -> bool {
use super::spawn_rules::is_valid_empty_spawn;
// entityCanStandOn: Block.isFaceFull(collision shape, UP).
let floor = l.mob_data().state(l.state(x, y - 1, z));
let stands = floor.flags & super::data::STURDY_TOP != 0 && floor.top >= 1.0;
// isValidEmptySpawnBlock with Fluids.EMPTY: open water is free too.
let feet = is_valid_empty_spawn(Species::IronGolem, l, x, y, z)
|| &*l.facts().get(l.state(x, y, z)).name == "minecraft:water";
stands
&& feet
&& is_valid_empty_spawn(Species::IronGolem, l, x, y + 1, z)
&& is_valid_empty_spawn(Species::IronGolem, l, x, y + 2, z)
}
/// `SpawnUtil.trySpawnMob(IRON_GOLEM, MOB_SUMMONED, level, start, 10, 8, 6,
/// LEGACY_IRON_GOLEM, false)`: up to ten columns tried. In each spot found
/// `create` makes the golem (`EntityType.create`: the yaw drawn here, then its
/// `finalizeSpawn` draws, see [`finalize_summoned_golem`]); it is kept only
/// when `IronGolem.checkSpawnObstruction` passes, and discarded otherwise.
pub fn summon_golem<L: super::spawn_rules::SpawnLevel, R: RandomSource, T>(
l: &L,
start: [i32; 3],
random: &mut R,
mut create: impl FnMut(&mut R, horizon_core::geometry::Vec3, f32) -> T,
) -> Option<T> {
for _ in 0..10 {
let Some([x, y, z]) = golem_attempt(l, start, random) else {
continue;
};
// Mth.wrapDegrees(nextFloat() * 360).
let mut yaw = random.next_float() * 360.0;
if yaw >= 180.0 {
yaw -= 360.0;
}
let at =
horizon_core::geometry::Vec3::new(f64::from(x) + 0.5, f64::from(y), f64::from(z) + 0.5);
let golem = create(random, at, yaw);
if golem_fits(l, [x, y, z]) {
return Some(golem);
}
}
None
}
/// `Mob.finalizeSpawn` for a summoned iron golem, from the level's random:
/// the follow range spawn bonus and left-handedness.
pub fn finalize_summoned_golem(m: &mut Mob, random: &mut impl RandomSource) {
use super::finalize::{Attr, Op, add_modifier, has_modifier};
if !has_modifier(m, Attr::FollowRange, "minecraft:random_spawn_bonus") {
let bonus = random.triangle(0.0, 0.114_850_000_000_000_01);
add_modifier(
m,
Attr::FollowRange,
"minecraft:random_spawn_bonus",
bonus,
Op::AddMultipliedBase,
);
}
m.extra.left_handed = random.next_float() < 0.05;
}
/// `PoiManager.take(HOME, ..., 48)`: the nearest bed head not `claimed`
/// (`free_head`: a bed head that is not occupied).
pub fn take_vacant_bed(
@@ -779,6 +779,14 @@ fn sense_golem(m: &mut Mob, w: &MobWorld) {
}
}
/// `GolemSensor.golemDetected`: a golem was summoned near this villager;
/// for 599 ticks it wants no other.
pub fn golem_detected(m: &mut Mob, now: i64) {
mem(m).golem_detected_recently.set_ttl(true, 599);
// What `sync` derives from the memory.
super::villager::ext_mut(m).golem_until = now + 599 + 1;
}
// ---- Behaviours ---------------------------------------------------------
/// The POI types villagers use.
+51 -2
View File
@@ -103,7 +103,10 @@ pub fn shadow(
let v = |wz: f64| (-((wz - pos.z) as f32) / 2.0 / radius + 0.5).clamp(0.0, 1.0);
let a = (alpha * 255.0) as u32;
let color = a << 24 | 0x00FF_FFFF;
let top = f64::from(y) + 0.001;
// ShadowFeatureRenderer: relativeY + shapeBelow.minY, the block top
// itself. A model's feet sit 0.001 above it (LivingEntityRenderer's
// translate(0, -1.501, 0)), so a lifted shadow fights with them.
let top = f64::from(y);
for (wx, wz) in [(bx0, bz0), (bx0, bz1), (bx1, bz1), (bx1, bz0)] {
let p = DVec3::new(wx, top, wz) - camera;
out.push(Vertex {
@@ -113,7 +116,7 @@ pub fn shadow(
sprite.u0 + (sprite.u1 - sprite.u0) * u(wx),
sprite.v0 + (sprite.v1 - sprite.v0) * v(wz),
],
layer: 0,
layer: crate::gfx::SHADOW_OVERLAY,
color,
light: 240 | 240 << 8,
});
@@ -127,6 +130,52 @@ pub fn shadow(
mod tests {
use super::*;
#[test]
fn shadows_lie_on_the_block_top_under_model_feet() {
use crate::chunk::Chunk;
use horizon_world::level::data;
use std::{path::PathBuf, sync::Arc};
let root = std::env::var_os("HORIZON_RESOURCES")
.map(PathBuf::from)
.unwrap_or_else(|| {
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION)
});
if !root.join("gameplay-facts.json").exists() {
eprintln!("skipping resource-backed shadow check: {}", root.display());
return;
}
let registry = data::load_registry(&root).unwrap();
let facts = BlockFacts::load(&root, &registry).unwrap();
let stone = registry.default_state("minecraft:stone").unwrap();
let mut world = World::new(facts.air, 0);
world.chunks.insert((0, 0), Arc::new(Chunk::empty(0, 0)));
for x in 0..16 {
for z in 0..16 {
world.set(x, 63, z, stone).unwrap();
}
}
let (camera, pos) = (DVec3::new(8.5, 66.0, 4.0), DVec3::new(8.5, 64.0, 8.5));
let mut out = Vec::new();
let sprite = Rect {
u0: 0.0,
v0: 0.0,
u1: 1.0,
v1: 1.0,
w: 16,
h: 16,
};
shadow(
&world, &facts, sprite, camera, pos, 0.3, 1.0, 0.0, 0, &mut out,
);
assert_eq!(out.len(), 4);
let feet = (pos.y + (1.501 - 24.0 / 16.0) - camera.y) as f32;
for v in &out {
assert_eq!(v.pos[1], (pos.y - camera.y) as f32);
assert!(v.pos[1] < feet);
}
}
#[test]
fn vanilla_radii() {
assert_eq!(shadow_params("minecraft:zombie"), (0.5, 1.0));
assert_eq!(shadow_params("minecraft:item"), (0.15, 0.75));
+2 -2
View File
@@ -17,7 +17,7 @@ pub mod pyjson;
mod sounds;
mod survival;
pub use sounds::{fonts, panorama, sounds};
pub use sounds::{fonts, packs, panorama, sounds};
use pyjson::Value;
use sha2::Digest;
@@ -692,7 +692,7 @@ fn steps(
}
// The JAR holds only gray 1x1 panorama placeholders and an empty Unifont
// include. Import the indexed ones afterwards, including on reruns that just
// include, and none of the built-in packs. Import the indexed ones afterwards, including on reruns that just
// extracted the JAR again. They are optional when preparing from
// already-imported JARs.
sounds::optional_assets(repo, minecraft, run.log);
+8 -2
View File
@@ -19,6 +19,7 @@ Usage: horizon-prepare [--prepare] [--server-jar PATH] [--minecraft-dir PATH] [-
horizon-prepare sounds [--minecraft-dir PATH] [--root PATH]
horizon-prepare panorama [--minecraft-dir PATH] [--root PATH]
horizon-prepare fonts [--minecraft-dir PATH] [--root PATH]
horizon-prepare packs [--minecraft-dir PATH] [--root PATH]
--prepare Import the pinned game files from your own copy first
--server-jar PATH The pinned server jar you downloaded yourself
@@ -34,7 +35,8 @@ The resources go to <root>/.local/horizon-client/<version>; pass that to horizon
horizon-prepare panorama repairs the classic menu background in existing resources without Java.
horizon-prepare fonts adds the GNU Unifont glyphs (characters the bitmap fonts lack) the same way.
Full preparation also imports both after extracting the client JAR's placeholders.
horizon-prepare packs adds the built-in Programmer Art and High Contrast resource packs the same way.
Full preparation also imports all three after extracting the client JAR's placeholders.
horizon-prepare sounds copies the pinned version's sounds (about 380 MB) from the official
launcher's asset store into the same folder, checking every file. It is optional: without it the
@@ -66,7 +68,8 @@ fn main() -> ExitCode {
};
let mut root = None;
let mut args = std::env::args_os().skip(1).peekable();
let assets = args.next_if(|a| a == "sounds" || a == "panorama" || a == "fonts");
let assets =
args.next_if(|a| matches!(a.to_str(), Some("sounds" | "panorama" | "fonts" | "packs")));
while let Some(arg) = args.next() {
let text = arg.to_string_lossy().into_owned();
let (flag, inline) = match text.split_once('=') {
@@ -132,6 +135,9 @@ fn main() -> ExitCode {
Some("fonts") => {
horizon_prepare::fonts(&options.root, options.minecraft_dir.as_deref(), &log)
}
Some("packs") => {
horizon_prepare::packs(&options.root, options.minecraft_dir.as_deref(), &log)
}
_ => horizon_prepare::prepare(&options, &log),
};
match result {
+80 -12
View File
@@ -1,5 +1,5 @@
//! The pinned version's sounds and title panorama from the player's own official
//! launcher install, each object checked against the asset index's SHA-1, copied into
//! The pinned version's sounds, title panorama, Unifont glyphs and built-in resource packs
//! from the player's own official launcher install, each object checked against the asset index's SHA-1, copied into
//! `.local/horizon-client/<version>/assets` where the game reads them (tools/fetch_sounds.py and
//! the tools/lab.py functions it called). Nothing is downloaded.
@@ -124,6 +124,11 @@ pub(crate) fn optional_assets(root: &Path, minecraft: Option<&Path>, log: Log) {
"Unifont glyphs not imported: {error}; run horizon-prepare fonts later"
));
}
if let Err(error) = packs(root, minecraft, log) {
log(&format!(
"Programmer Art and High Contrast not imported: {error}; run horizon-prepare packs later"
));
}
}
const PANORAMA: [&str; 7] = [
@@ -145,6 +150,30 @@ const UNIFONT: [&str; 2] = [
"minecraft/font/unifont.zip",
];
/// Adds the built-in Programmer Art and High Contrast packs, which only the asset index holds
/// (`BuiltInPackSource.populatePackList` lists `minecraft:resourcepacks` of the vanilla pack).
/// Packs made to sit on Programmer Art, like Golden Days, show the default textures without it.
/// Also usable on prepared resources without Java.
pub fn packs(root: &Path, minecraft: Option<&Path>, log: Log) -> Result<PathBuf, String> {
copy_assets(
root,
minecraft,
log,
is_built_in_pack,
"Built-in pack",
&BUILT_IN_PACKS,
)
}
const BUILT_IN_PACKS: [&str; 2] = [
"minecraft/resourcepacks/programmer_art.zip",
"minecraft/resourcepacks/high_contrast.zip",
];
fn is_built_in_pack(name: &str) -> bool {
name.starts_with("minecraft/resourcepacks/")
}
/// The fonts only the asset index holds (the JAR has the bitmap fonts).
fn is_font(name: &str) -> bool {
name.starts_with("minecraft/font/")
@@ -228,11 +257,13 @@ mod tests {
crate::hex(&sha1::Sha1::digest(data))
}
/// Where the fixture's panorama objects start.
const FIRST_FACE: usize = 6;
/// Where the fixture's built-in packs and panorama objects start.
const FIRST_PACK: usize = 6;
const FIRST_FACE: usize = 8;
/// A Horizon folder and an official launcher directory holding version `9.9` with
/// sounds, a language file and the full title panorama in its asset store.
/// sounds, a language file, Unifont, the built-in packs and the full title panorama in its
/// asset store.
struct Fixture {
dir: PathBuf,
root: PathBuf,
@@ -263,6 +294,8 @@ mod tests {
b"{\"providers\": [{\"type\": \"unihex\"}]}".to_vec(),
),
(UNIFONT[1], b"PK unifont".to_vec()),
(BUILT_IN_PACKS[0], b"PK programmer art".to_vec()),
(BUILT_IN_PACKS[1], b"PK high contrast".to_vec()),
];
for &name in panorama {
// Distinct object bytes let the test catch swapped faces too.
@@ -499,15 +532,25 @@ mod tests {
lines[0],
format!("Title panorama not imported: {error}; run horizon-prepare panorama later")
);
// The fonts come on their own when only a panorama face is missing.
// The fonts and packs come on their own when only a panorama face is missing.
match missing {
"last-object" => assert_eq!(lines[1], "Font assets ready: 2 files, 0.0 MB"),
_ => assert!(
lines[1].starts_with("Unifont glyphs not imported: "),
"{lines:?}"
"last-object" => assert_eq!(
lines[1..],
[
"Font assets ready: 2 files, 0.0 MB",
"Built-in pack assets ready: 2 files, 0.0 MB"
]
),
_ => {
assert!(lines[1].starts_with("Unifont glyphs not imported: "));
assert!(
lines[2].starts_with("Programmer Art and High Contrast not imported: ")
&& lines[2].ends_with("; run horizon-prepare packs later"),
"{lines:?}"
);
}
}
assert_eq!(lines.len(), 2);
assert_eq!(lines.len(), 3);
for name in PANORAMA {
assert_eq!(fs::read(target.join(name)).unwrap(), b"jar placeholder");
}
@@ -528,7 +571,7 @@ mod tests {
lines.borrow_mut().push(l.to_string())
});
assert_eq!(done.unwrap(), target);
for (name, data) in &f.objects[4..FIRST_FACE] {
for (name, data) in &f.objects[4..FIRST_PACK] {
assert_eq!(&fs::read(target.join("assets").join(name)).unwrap(), data);
}
assert_eq!(*lines.borrow(), ["Font assets ready: 2 files, 0.0 MB"]);
@@ -536,6 +579,31 @@ mod tests {
assert!(!target.join("assets/minecraft/textures").exists());
}
/// Golden Days is made to sit on Programmer Art, which the client JAR lacks: the asset
/// index has it, where `BuiltInPackSource` lists `minecraft:resourcepacks`.
#[test]
fn packs_add_programmer_art_and_high_contrast_where_the_pack_list_finds_them() {
let f = Fixture::new("packs");
let target = f.root.join(".local/horizon-client/9.9");
let lines = std::cell::RefCell::new(Vec::new());
let done = packs(&f.root, Some(&f.minecraft), &|l| {
lines.borrow_mut().push(l.to_string())
});
assert_eq!(done.unwrap(), target);
for (name, data) in &f.objects[FIRST_PACK..FIRST_FACE] {
assert_eq!(&fs::read(target.join("assets").join(name)).unwrap(), data);
}
assert!(target
.join("assets/minecraft/resourcepacks/programmer_art.zip")
.is_file());
assert_eq!(
*lines.borrow(),
["Built-in pack assets ready: 2 files, 0.0 MB"]
);
assert!(!target.join("assets/minecraft/sounds.json").exists());
assert!(!target.join("assets/minecraft/font").exists());
}
#[test]
fn the_index_must_hold_the_sounds() {
let f = Fixture::new("index");
+5
View File
@@ -17,5 +17,10 @@ sha1 = "0.10"
# Secure chat: SHA256withRSA message signatures.
sha2 = "0.10"
# Its own name, not `probe`: Cargo copies every crate's examples into one target/<profile>/examples.
[[example]]
name = "protocol_probe"
path = "examples/probe.rs"
[lints]
workspace = true
+1 -1
View File
@@ -2,7 +2,7 @@
//! seconds, reporting packet counts and any decode failures. A differential
//! check of the codecs against a real vanilla server:
//!
//! cargo run -p horizon-protocol --example probe -- 127.0.0.1:25565 [seconds] [registries.json]
//! cargo run -p horizon-protocol --example protocol_probe -- 127.0.0.1:25565 [seconds] [registries.json]
use horizon_protocol::{
PROTOCOL_VERSION, State,
connection::Connection,
+134
View File
@@ -333,6 +333,74 @@ pub struct Passes {
/// The program its translucent terrain is drawn with
/// ([`WATER_PROGRAMS`]), after `deferred`.
pub water: Option<Pass>,
/// The programs the shadow map's solid and translucent terrain are
/// drawn with ([`SHADOW_PROGRAMS`], [`SHADOW_WATER_PROGRAMS`]), after
/// `begin`. Their draw buffers are `shadowcolor` targets.
pub shadow: Option<Pass>,
pub shadow_water: Option<Pass>,
/// `shadowcolor0..7`: white and cleared each frame unless the pack
/// says otherwise.
pub shadow_targets: Vec<TargetSettings>,
}
/// The programs Iris draws the shadow map's solid terrain with. Horizon's
/// solid layer holds cutout blocks too, so `shadow_cutout` (with its alpha
/// test) comes first.
pub const SHADOW_PROGRAMS: &[&str] = &["shadow_cutout", "shadow", "shadow_solid"];
/// The programs Iris draws the shadow map's translucent terrain with.
pub const SHADOW_WATER_PROGRAMS: &[&str] = &["shadow_water", "shadow"];
/// How many `shadowcolor` targets Iris has.
pub const MAX_SHADOW_COLOR_BUFFERS: u32 = 8;
/// `shadowcolor<N>Format`, `Clear` and `ClearColor` from `fragments`.
pub fn shadow_target_settings<'a>(
fragments: impl IntoIterator<Item = &'a str>,
) -> Vec<TargetSettings> {
let mut targets = vec![
TargetSettings {
clear_color: Some([1.0; 4]),
..TargetSettings::default()
};
MAX_SHADOW_COLOR_BUFFERS as usize
];
let key = |key: &str, suffix: &str| {
let i: u32 = key
.strip_prefix("shadowcolor")?
.strip_suffix(suffix)?
.parse()
.ok()?;
(i < MAX_SHADOW_COLOR_BUFFERS).then_some(i as usize)
};
for fragment in fragments {
for c in const_directives(fragment) {
match c.ty {
"int" => {
if let Some(i) = key(&c.key, "Format") {
let format = c.value.to_uppercase();
if TEXTURE_FORMATS.contains(&format.as_str()) {
targets[i].format = format;
}
}
}
"bool" => {
if let (Some(i), Ok(clear)) = (key(&c.key, "Clear"), c.value.parse()) {
targets[i].clear = clear;
}
}
"vec4" => {
if let (Some(i), Some(color)) =
(key(&c.key, "ClearColor"), parse_vec4(&c.value))
{
targets[i].clear_color = Some(color);
}
}
_ => {}
}
}
}
targets
}
/// The programs Iris draws solid terrain with, the first the pack has
@@ -368,6 +436,8 @@ pub struct Directives {
pub wetness_half_life: f32,
/// `drynessHalflife`, tenths of a second: `wetness` smoothing when dry.
pub dryness_half_life: f32,
/// The shadow map's directives.
pub shadow: ShadowDirectives,
}
impl Default for Directives {
@@ -377,6 +447,35 @@ impl Default for Directives {
eye_brightness_half_life: 10.0,
wetness_half_life: 600.0,
dryness_half_life: 200.0,
shadow: ShadowDirectives::default(),
}
}
}
/// The shadow map's `const` directives (`PackShadowDirectives`), with
/// Iris's defaults.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ShadowDirectives {
/// `shadowMapResolution`: the shadow targets' width and height.
pub resolution: u32,
/// `shadowDistance`: half the side of the orthographic projection.
pub distance: f32,
/// `shadowNearPlane` and `shadowFarPlane` (`ShadowMatrices.NEAR`/`FAR`).
pub near: f32,
pub far: f32,
/// `shadowIntervalSize`: the light's view snaps to a grid this size as
/// the camera moves, so shadows don't shimmer.
pub interval: f32,
}
impl Default for ShadowDirectives {
fn default() -> Self {
Self {
resolution: 1024,
distance: 160.0,
near: -100.05,
far: 156.0,
interval: 2.0,
}
}
}
@@ -392,6 +491,13 @@ impl Directives {
match (c.ty, c.key.as_str(), value) {
("float", "sunPathRotation", Ok(v)) => out.sun_path_rotation = v,
("float", "eyeBrightnessHalflife", Ok(v)) => out.eye_brightness_half_life = v,
("int", "shadowMapResolution", Ok(v)) if v >= 1.0 => {
out.shadow.resolution = v as u32;
}
("float", "shadowDistance", Ok(v)) => out.shadow.distance = v,
("float", "shadowNearPlane", Ok(v)) => out.shadow.near = v,
("float", "shadowFarPlane", Ok(v)) => out.shadow.far = v,
("float", "shadowIntervalSize", Ok(v)) => out.shadow.interval = v,
("float", "wetnessHalflife", Ok(v)) => out.wetness_half_life = v,
("float", "drynessHalflife", Ok(v)) => out.dryness_half_life = v,
_ => {}
@@ -517,6 +623,7 @@ impl JavaPack {
}
let mut out = Passes {
targets: target_settings(sources.iter().map(String::as_str), properties),
shadow_targets: shadow_target_settings(sources.iter().map(String::as_str)),
directives: Directives::read(sources.iter().map(String::as_str)),
..Passes::default()
};
@@ -559,6 +666,7 @@ impl JavaPack {
};
let mut flipped = BTreeSet::new();
out.begin = run(&groups[0], "begin_pre", &mut flipped)?;
let flipped_after_begin = flipped.clone();
out.prepare = run(&groups[1], "prepare_pre", &mut flipped)?;
out.flipped_after_prepare = flipped.clone();
// Iris's fallbacks for terrain (`ProgramFallbackResolver`).
@@ -598,6 +706,8 @@ impl JavaPack {
};
out.terrain = geometry(TERRAIN_PROGRAMS, &out.flipped_after_prepare)?;
out.water = geometry(WATER_PROGRAMS, &out.flipped_after_translucent)?;
out.shadow = geometry(SHADOW_PROGRAMS, &flipped_after_begin)?;
out.shadow_water = geometry(SHADOW_WATER_PROGRAMS, &flipped_after_begin)?;
if exists("final") {
let prog = path("final");
let (blend, buffer_blends) = resolve_blends(&prog);
@@ -902,6 +1012,30 @@ mod tests {
assert_eq!(d.dryness_half_life, 200.0, "the default");
}
#[test]
fn shadow_directives_and_targets() {
let text = "\
const int shadowMapResolution = 2048;
const float shadowDistance = 128.0;
const float shadowIntervalSize = 3.0;
const bool shadowcolor0Clear = false;
const int shadowcolor1Format = RGBA16;
const vec4 shadowcolor1ClearColor = vec4(0.0, 0.0, 0.0, 0.0);
";
let d = Directives::read([text]);
assert_eq!(d.shadow.resolution, 2048);
assert_eq!(d.shadow.distance, 128.0);
assert_eq!(d.shadow.interval, 3.0);
assert_eq!(d.shadow.near, ShadowDirectives::default().near);
let targets = shadow_target_settings([text]);
assert!(!targets[0].clear);
assert_eq!(targets[1].format, "RGBA16");
assert_eq!(targets[1].clear_color, Some([0.0; 4]));
// Iris clears the others to white.
assert_eq!(targets[2].clear_color, Some([1.0; 4]));
assert!(targets[2].clear);
}
#[test]
fn const_directives_and_target_settings() {
let text = "\
+5
View File
@@ -25,5 +25,10 @@ path = "src/main.rs"
name = "horizon-worldgen-parity"
path = "src/bin/worldgen_parity.rs"
# Its own name, not `probe`: Cargo copies every crate's examples into one target/<profile>/examples.
[[example]]
name = "world_probe"
path = "examples/probe/main.rs"
[lints]
workspace = true
@@ -32,7 +32,7 @@ pub fn main(names: &[&str], run: fn(&str) -> Option<ExitCode>) -> ExitCode {
let name = std::env::args().nth(1).unwrap_or_default();
run(&name).unwrap_or_else(|| {
eprintln!(
"usage: probe <name> [arguments...]\nprobes: {}",
"usage: world_probe <name> [arguments...]\nprobes: {}",
names.join(" ")
);
ExitCode::from(2)
+2 -2
View File
@@ -53,7 +53,7 @@ Start the client.
- `--world`: Open or create this world (a folder under saves) at once
- `--creative`: Creative mode for a new world
- `--join`: Join a friend's world with its invite code
- `--arg`: An extra argument for the game, passed through as-is (repeatable), for example --server-thread
- `--arg`: An extra argument for the game, passed through as-is (repeatable), for example --in-frame
MCP: `play`, then the `game_*` tools.
@@ -143,7 +143,7 @@ MCP: `settings`.
## `horizon-launcher game-args`
Show or set the extra arguments the game starts with (for example --server-thread); quotes group a word with spaces in it.
Show or set the extra arguments the game starts with (for example --in-frame); quotes group a word with spaces in it.
horizon-launcher game-args [ARGS]
+1 -1
View File
@@ -26,7 +26,7 @@ Vanilla oracle runs are reused as well. `tools/parity_shim.py` stands in for `ja
Probes build into `.local/parity-target/` with release optimisation but no LTO and 16 codegen units. On ludodesktop that rebuilds every `horizon-world` probe in 3 seconds after a one-line change, against 122 seconds with the release profile. Rust gives these settings identical results (no fast-math; overflow checks as in release), and the full harness suite passes under them. Probes that harnesses build in the dev profile get `opt-level = 3` too, keeping their overflow checks and debug assertions. Harnesses must locate binaries through `cargo metadata` or `lab.cargo_target()`, never a hard-coded `target/`.
The probes of `horizon-world` and of `horizon-client` are one binary per crate, `cargo build --release -p <crate> --example probe`: a harness runs `probe <name> [arguments]`, and `<name>` is a module in `crates/<crate>/examples/probe/` (add it to the `mod` list and the `probes!` list in its `main.rs`; read arguments with `crate::args()` or `crate::args_os()`, which drop the name). Code several probes share goes in `examples/probe/support/` or a module of its own. Linking one binary instead of ~250 examples is most of what a probe build used to cost. The runner counts only the probes a harness ran, the probes and support modules they name, their own subdirectories and `dispatch.rs` as its dependencies, not `main.rs`, which only lists the probes: editing one probe reruns only its harnesses, and adding one reruns none.
The probes of `horizon-world` and of `horizon-client` are one binary per crate, `world_probe` and `client_probe` (`cargo build --release -p horizon-world --example world_probe`): a harness runs `world_probe <name> [arguments]`, and `<name>` is a module in `crates/<crate>/examples/probe/` (add it to the `mod` list and the `probes!` list in its `main.rs`; read arguments with `crate::args()` or `crate::args_os()`, which drop the name). Code several probes share goes in `examples/probe/support/` or a module of its own. Linking one binary instead of ~250 examples is most of what a probe build used to cost. Each crate's probe has its own target name (set in its `Cargo.toml`, `protocol_probe` too): Cargo copies every crate's examples into one `<profile>/examples/` directory, and with one shared name a harness could run the binary another harness had just copied there. The runner counts only the probes a harness ran, the probes and support modules they name, their own subdirectories and `dispatch.rs` as its dependencies, not `main.rs`, which only lists the probes: editing one probe reruns only its harnesses, and adding one reruns none.
Passes are shared between worktrees. A harness's key depends only on the content of its dependencies, not on where they are, so every pass is also written to `parity-shared/` beside the shared vanilla data (`PARITY_SHARED` overrides it). A worktree whose files match those a harness passed with, in any worktree, counts that pass without running the harness: after merging the integration branch, an agent's gate only runs the harnesses its own changes affect.
+2 -1
View File
@@ -7,7 +7,8 @@ screen (the same screen as vanilla's) or in game, and every loader reloads from
## How it works
`packs.rs` finds the packs (`FolderRepositorySource`: folders and zips, plus the built-in Programmer Art and High
Contrast), reads `pack.mcmeta` (format range, overlays, filters) and builds one overlay directory that layers the
Contrast, which only the asset index holds: preparation copies them, `horizon-prepare packs` repairs older resources),
reads `pack.mcmeta` (format range, overlays, filters) and builds one overlay directory that layers the
selected packs over the prepared vanilla resources, later packs winning. Files vanilla reads as a resource *stack*
(language files, `sounds.json`, font definitions, atlas definitions) are merged layer by layer as vanilla merges them.
Every loader then reads that one tree; `game/packs.rs` (`reload_packs`) reloads all of them in game, as
+3 -4
View File
@@ -26,10 +26,9 @@ the other dimensions' levels as `Parked` values and swaps one into place (`enter
The packets of a guest are read in its own level's pass (`Hub::tick_level`), so its actions and
commands run with its level in place.
The window's own game (single player's default, `--no-server-thread`, `HORIZON_SERVER_THREAD=0`, and the
command harness) keeps one level, which follows its player (`enter_dimension`). LAN guests of a world run
that way stay in the host's dimension. It is the default again only until the server thread reaches parity
(`--server-thread` or `HORIZON_SERVER_THREAD=1` opts in), so it gets no multi-level work.
The window's own game (`--in-frame`, `--no-server-thread`, `HORIZON_SERVER_THREAD=0`, and the command
harness) keeps one level, which follows its player (`enter_dimension`). LAN guests of a world run that way
stay in the host's dimension. That mode is the escape hatch, so it gets no multi-level work.
## One code path for both
+39 -13
View File
@@ -25,7 +25,8 @@ Both are off by default. With no pack selected the renderer draws exactly what i
| Java shader packs: full-screen passes drawn (`java_pack.rs`, `gfx/java_stages.rs`: `begin`, `prepare`, `deferred*`, `composite*`, `final` over Horizon's world) | first slice: BSL and Complementary run (below); `depthtex1`/`depthtex2` before translucent geometry, `blend.*`, PNG `texture.<stage>.*` and `texture.noise` |
| Java shader packs: custom uniforms (`horizon_shaderpack::uniforms`), `sunPathRotation`, `clouds`/`sun`/`moon`, eye light, `wetness` | done for the full-screen passes (below) |
| Java shader packs: `gbuffers_terrain`, `gbuffers_water` (`gfx/java_terrain.rs`: Horizon's terrain fed to the pack's programs) | first slice: MakeUp Ultra Fast, Chocapic13' and BSL draw their own terrain and water (below) |
| Java shader packs: other `gbuffers_*`, `shadow`, `.dat` and resource-location textures, images, compute | planned |
| Java shader packs: `shadow` programs (`gfx/java_stages.rs`: the shadow map from Horizon's terrain) | first slice: terrain shadows for MakeUp Ultra Fast, Chocapic13' and BSL (below) |
| Java shader packs: other `gbuffers_*`, entity shadows, `shadowcomp`, `.dat` and resource-location textures, images, compute | planned |
## How the renderer draws a frame today
@@ -416,6 +417,30 @@ sprite arrays (animated sprites copied in each frame), `lightmap` is Horizon's l
and fragments under alpha 0.1 are discarded (`alphaTestRef`). `RGBA16` targets are 16-bit unorm where the GPU can
render them (Chocapic13' packs its G-buffer into them; half floats broke it).
Occlusion culling works as in Horizon's world pass where the GPU has it: the pack's terrain program draws the
sections the last test saw, the boxes of the others are tested against that depth (in OpenGL's layout, in a pass of
their own since the pack's targets vary; on Metal the test reads the depth in the shader, as Horizon's does), and the
pack's program then draws the ones in sight, flat draws included.
When the pack has a `shadow` program (`shadow_cutout`, `shadow` or `shadow_solid` for the solid layer, which holds
cutout blocks; `shadow_water` or `shadow` for the translucent one), it draws a shadow map after `begin*`, as Iris's
`ShadowRenderer`:
- the light's matrices are Iris's `ShadowMatrices`: `shadowModelView` turns camera-relative positions toward the sun
(the moon at night) with the pack's `sunPathRotation`, snapped to `shadowIntervalSize`; `shadowProjection` is
orthographic, `shadowDistance` each way, between `shadowNearPlane` and `shadowFarPlane` (Iris's defaults when the
pack sets none); the shadow programs get them as `gl_ModelViewMatrix` and `gl_ProjectionMatrix`;
- the renderer draws every section inside that box whose shadow can reach the camera's view (the box swept away
from the light against the view's planes, as Iris's advanced shadow culling), from its own list (cave culling is
off as in Iris, and no face is culled), solid then translucent, instanced draws only;
- `shadowtex0` holds all of it, `shadowtex1` the depth before translucent terrain; both are bound as depth textures
for `sampler2DShadow` (linear comparison, Iris's hardware filtering) and as float copies for `sampler2D` reads;
- `shadowcolor0..7` are `shadowMapResolution` square in their `shadowcolor<N>Format`, cleared each frame to
`shadowcolor<N>ClearColor` (white by default) unless `shadowcolor<N>Clear` is false.
A shadow program that doesn't translate or that wgpu refuses leaves the pack without its shadow map, with a warning:
the terrain programs still run and every `shadowtex` reads as far (nothing in shadow).
What makes Horizon look like OpenGL to the pack:
- **Layout.** The translator ends every vertex shader by flipping `gl_Position.y` and moving depth from `[-w, w]` to
@@ -447,14 +472,15 @@ What makes Horizon look like OpenGL to the pack:
Measured on the Mac mini (M4 Pro) with the packs' default options: BSL v10.1.8 and Complementary Reimagined r5.9.3
grade and light Horizon's world as their post-processing would. Sildur's Vibrant v2.02 draws only its sky: its
`deferred` reads the albedo `gbuffers_*` write to `colortex4` (not checked again since the terrain programs run).
Without the other `gbuffers_*` and `shadow`, no pack has its shadows or sky look yet; Distant Horizons' and Voxy's
depth read as far. Horizon's world goes into the target the pack's `gbuffers_terrain` (or the program Iris falls back
to) draws to first: `colortex0` for most packs, `colortex1` for MakeUp. Not supported yet: images and compute (`.csh`;
a pack that needs them doesn't load), mipmapped targets (`colortexNMipmapEnabled` is read but ignored), `.dat` and
resource-location custom textures (PNG files in the pack only); shadow matrices are identity. With the pack's terrain:
entities, the sky, the hand, weather and clouds are still Horizon's (in that first target only), GPU occlusion culling
is off, block ids come from sprite names rather than block states, distant (LOD) terrain doesn't repeat its textures,
and only the overworld has been checked.
Without the other `gbuffers_*`, no pack has its own sky yet, and only terrain casts shadows; Distant Horizons' and
Voxy's depth read as far. Horizon's world goes into the target the pack's `gbuffers_terrain` (or the program Iris falls
back to) draws to first: `colortex0` for most packs, `colortex1` for MakeUp. Not supported yet: images and compute
(`.csh`; a pack that needs them doesn't load), mipmapped targets (`colortexNMipmapEnabled` is read but ignored), `.dat`
and resource-location custom textures (PNG files in the pack only), `shadowcomp` passes, `shadowMapFov` (a perspective
shadow map), `shadow.culling` and `shadowDistanceRenderMul` (the box above is the only bound). With the pack's terrain:
entities, the sky, the hand, weather and clouds are still Horizon's (in that first target only), block ids come from
sprite names rather than block states, distant (LOD) terrain doesn't repeat its textures, and only the overworld has
been checked.
### Compatibility
@@ -462,8 +488,8 @@ Tested on 2026-10-22 on the Mac mini (M4 Pro, Metal) with each pack's default op
the authors' pages (dev-only test inputs, kept outside the repository). "Loads" means every pass the pack enables for
the overworld, Nether and End is preprocessed, translated and validated, as the game does when the pack is picked
(`java_pack::tests::real_packs_load` with `HORIZON_TEST_SHADERPACKS`); "drawn" means it was also picked in the game
and screenshotted. Full-screen passes, `gbuffers_terrain` and `gbuffers_water` run (above); no pack has its own
shadows, entities or sky yet.
and screenshotted. Full-screen passes, `gbuffers_terrain`, `gbuffers_water` and the terrain's shadow map run
(above); no pack has its own entities or sky yet.
| Pack | Version | Result | First thing that stops it |
| --- | --- | --- | --- |
@@ -519,7 +545,7 @@ What the translator does for these packs, as Iris (JCPP and its GLSL transformer
into Iris's attributes (`mc_Entity` from `block.properties`, `mc_midTexCoord`, `at_tangent`, lightmap), a second
set of terrain pipelines writing the pack's render targets.
5. **Entities, block entities, hand, weather, clouds, particles** `gbuffers_*`.
6. **Shadow pass**: terrain and entities from the sun into `shadowtex0/1` and `shadowcolor0/1`, culled from the
light's view, with the pack's distortion.
6. **Shadow pass** (terrain done, above): entities and block entities from the sun into `shadowtex0/1` and
`shadowcolor0/1`, culled from the light's view, with the pack's distortion; `shadowcomp`.
7. **The rest**: custom textures, compute programs and images, per-dimension
folders, `entity.properties`/`item.properties`.
@@ -761,12 +761,14 @@ public final class VanillaMobAiOracle {
level.tickBlockEntities();
} else if (!heartPositions.isEmpty()) level.tickBlockEntities();
managerTick.invoke(manager);
// Villagers the tick spawned (babies) and a heart's creakings tick from the next
// one, in the order they were added, with a seeded random of their own. Other
// newcomers (animal babies, dropped items) are left out, as the probe leaves them.
// Villagers the tick spawned (babies), the iron golems they summoned and a heart's
// creakings tick from the next one, in the order they were added, with a seeded
// random of their own. Other newcomers (animal babies, dropped items) are left out,
// as the probe leaves them.
List<Entity> fresh = new ArrayList<>();
for (Entity e : level.getAllEntities())
if (!LABELS.containsKey(e) && (e instanceof Villager || e instanceof net.minecraft.world.entity.animal.bee.Bee || created.contains(e))) fresh.add(e);
if (!LABELS.containsKey(e) && (e instanceof Villager || e instanceof net.minecraft.world.entity.animal.bee.Bee
|| e instanceof net.minecraft.world.entity.animal.golem.IronGolem || created.contains(e))) fresh.add(e);
fresh.sort(java.util.Comparator.comparingInt(Entity::getId));
for (Entity e : fresh) {
int index = ENTS.size();
+36 -1
View File
@@ -50,7 +50,8 @@ class ParityRunnerTests(unittest.TestCase):
])
def test_a_probe_binary_depends_only_on_the_probes_it_ran(self):
commands = [["/t/release/examples/probe", "a_fixture", "/dir"], ["cargo", "run", "--example", "probe", "--", "b_fixture"]]
commands = [["/t/release/examples/world_probe", "a_fixture", "/dir"],
["cargo", "run", "-p", "horizon-client", "--example", "client_probe", "--", "b_fixture"]]
self.assertEqual(parity.probes_run(commands), {"a_fixture", "b_fixture"})
with tempfile.TemporaryDirectory() as temp, mock.patch.object(parity, "ROOT", Path(temp)):
probe = Path(temp, "crates/w/examples/probe")
@@ -67,6 +68,40 @@ class ParityRunnerTests(unittest.TestCase):
["crates/w/src/lib.rs", *paths[:2], *paths[3:6], paths[8]])
self.assertEqual(parity.only_probes_run(paths, set()), paths)
def test_probe_names_are_each_crates_own_target(self):
self.assertEqual(parity.probes_run([
["C:/t/debug/examples/client_probe.exe", "a_fixture"],
["cargo", "run", "--release", "--example=world_probe", "--", "b_fixture", "x"],
["/t/release/examples/probe", "old_fixture"], # the shared name before 2026-10-24
["cargo", "run", "--example", "probe", "--", "old_fixture"],
["/t/release/examples/mod_port_probe", "not_a_fixture"],
["cargo", "run", "--example", "mod_port_probe", "--", "not_a_fixture"],
["cargo", "build", "--example", "world_probe"],
]), {"a_fixture", "b_fixture"})
def test_records_of_the_shared_probe_name_build_their_crates_probe(self):
record = {"dependencies": ["crates/horizon-world/examples/probe/a_fixture.rs", "crates/horizon-world/src/lib.rs"],
"artifacts": [["example", "probe", "release", ["-p", "horizon-client"], True],
["example", "probe", "release"], # no selection: the crate of its probe sources
["example", "probe", "release", ["-p", "horizon-core", "-p", "horizon-world"], True],
["bin", "horizon-world", "release", ["-p", "horizon-world"], False]]}
artifacts = parity.recorded_artifacts(record)
self.assertEqual(artifacts, [["example", "client_probe", "release", ["-p", "horizon-client"], True],
["example", "world_probe", "release"],
["example", "world_probe", "release", ["-p", "horizon-core", "-p", "horizon-world"], True],
["bin", "horizon-world", "release", ["-p", "horizon-world"], False]])
packages = {("example", "client_probe"): "horizon-client", ("example", "world_probe"): "horizon-world",
("bin", "horizon-world"): "horizon-world"}
self.assertEqual(parity.prebuild_commands(artifacts, packages), [
["cargo", "build", "--locked", "--profile", "release", "-p", "horizon-client", "--example", "client_probe"],
["cargo", "build", "--locked", "--profile", "release", "-p", "horizon-core", "-p", "horizon-world",
"--example", "world_probe"],
["cargo", "build", "--locked", "--profile", "release", "-p", "horizon-world", "--bin", "horizon-world"],
["cargo", "build", "--locked", "--profile", "release", "-p", "horizon-world", "--example", "world_probe"],
])
self.assertEqual(parity.recorded_artifacts({"artifacts": [["example", "probe", "release"]]}),
[["example", "probe", "release"]]) # no crate to tell: left to its harness
def test_java_sources_include_classes_pulled_from_the_sourcepath(self):
with tempfile.TemporaryDirectory() as temp:
sources, classes = Path(temp, "src"), Path(temp, "classes")
+2 -2
View File
@@ -65,9 +65,9 @@ def run_harness(name, oracle, example, inputs_text, extra_sources=(), java_args=
dependencies = os.pathsep.join(map(str, [jars['client'], *libraries]))
run(['javac', '--release', lock['minecraft']['java_major'], '-proc:none', '-sourcepath', lab.ROOT / 'mods/horizon/src/test/java',
'-cp', dependencies, '-d', classes, oracle_path], 'compile-java')
run(['cargo', 'build', '--locked', '-p', 'horizon-client', '--example', 'probe'], 'compile-rust')
run(['cargo', 'build', '--locked', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--locked', '--no-deps', '--format-version', '1'], cwd=lab.ROOT))
binary = Path(metadata['target_directory']) / 'debug/examples' / ('probe.exe' if os.name == 'nt' else 'probe')
binary = Path(metadata['target_directory']) / 'debug/examples' / ('client_probe.exe' if os.name == 'nt' else 'client_probe')
run([binary, example, *rust_args, inputs, build / 'rust.txt'], 'rust')
env = dict(os.environ, ALSOFT_DRIVERS='null')
run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies, f'dev.horizonlab.parity.{oracle}', *java_args, inputs, build / 'client.txt'],
+1 -1
View File
@@ -133,7 +133,7 @@ def execute(name, cases, args, facts, origin_of=None):
'-cp', dependencies, '-d', str(classes), str(java_root / 'dev/horizonlab/parity/VanillaBlockUpdateOracle.java')])
run(['java', '-Xmx2G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaBlockUpdateOracle',
str(resources), str(work / 'cases.jsonl'), str(work / 'native.txt')])
run(['cargo', 'run', '-q', '--release', '-p', 'horizon-world', '--example', 'probe', '--',
run(['cargo', 'run', '-q', '--release', '-p', 'horizon-world', '--example', 'world_probe', '--',
'block_update_fixture', str(resources), str(work / 'cases.jsonl'), str(work / 'rust.txt')], cwd=lab.ROOT, env={**os.environ, 'CARGO_BUILD_JOBS': '3'})
ignore = tuple(prefix + ' ' for prefix in args.ignore.split(',') if prefix)
native = split_cases((work / 'native.txt').read_text(), ignore)
+2 -1
View File
@@ -50,7 +50,8 @@ def cargo_example(package, example, *args, profile=None):
command = ['cargo', 'run', '-q', '-j3']
if profile:
command += ['--profile', profile]
command += ['-p', package, '--example', 'probe', '--', example, *map(str, args)]
probe = package.removeprefix('horizon-') + '_probe' # each crate's probe example: client_probe, world_probe
command += ['-p', package, '--example', probe, '--', example, *map(str, args)]
subprocess.run(command, check=True, cwd=lab.ROOT)
+366
View File
@@ -210,6 +210,18 @@ address. The script then checks, from both sides, what a guest's game used to ge
- wind: the host and the guest each throw a wind charge at their feet: the server's burst
launches them about six blocks up (the push in ClientboundExplodePacket) and they land
unhurt (#1386).
- fishing: the host and the guest each cast a fishing rod: the hook stays out on the server and
both sides draw it and it reels back in from the ground, and in open water a fish
bites and reeling in catches it (#1348).
- maps: the host and the guest each make a map and hold it: their client draws the terrain
around them and their marker, from the server's map data (#1382).
- body: the host and the guest each walk while drawing a bow (slowed), stand on powder snow
with leather boots (held up) and without (sinking), and sprint-swim looking down
(diving): their own client decides it (#1278, #1296, #1303).
- strikes: a bolt strikes the host and the guest standing in water and hurts them, and a cave
spider's bite poisons them (#1480, #1484).
- cursor: the host and the guest each close their inventory with a stack on the cursor: it
goes back into their inventory, none is thrown and the cursor is empty (#1283).
Each check is reported on its own (a failing one doesn't stop the others) and the screenshots of
both sides go to --out (host-*.png, guest-*.png).
@@ -4927,5 +4939,359 @@ CHECKS += ['wind']
CHECK_FNS.update(wind=check_wind)
def bobbers(game):
"""The fishing bobbers this side draws, as (owner) ids: 0 for its own player's."""
return [q.get('owner') for q in game('status')['projectiles'] if q['kind'] == 'minecraft:fishing_bobber']
def check_fishing(host, guest, out):
"""FishingHook for each player, on the server: a cast hook stays out (ticked by the server and
tracked to the clients as a fishing bobber under its owner), lands on the ground and reels back
in; cast into open water with Lure III, a fish bites and reeling in
during the bite catches it for 1 (#1348)."""
hx, hy, hz = (int(v // 1) for v in pos_of(host))
host('command', command='weather clear')
seen = {}
try:
for game, other, dz in ((host, guest, -5), (guest, host, 5)):
x, z = hx, hz + dz
host('command', command=f'fill {x - 1} {hy - 1} {z - 1} {x + 14} {hy - 1} {z + 1} minecraft:stone')
host('command', command=f'fill {x - 1} {hy} {z - 1} {x + 14} {hy + 4} {z + 1} minecraft:air')
game('command', command='gamemode survival')
game('command', command='clear @s')
game('command', command='item replace entity @s weapon.mainhand with minecraft:fishing_rod')
game('command', command=f'tp @s {x + 0.5} {hy} {z + 0.5} -90 0')
game.wait(10)
# On the ground: the floor four blocks ahead.
game.raw('look-at', f'{x + 4.5:.2f}', f'{hy:.2f}', f'{z + 0.5:.2f}')
game.raw('use-item')
game.wait(40)
s = {'own': bobbers(game), 'other': bobbers(other)}
game.shot(out, 'fishing-cast')
game.raw('use-item')
game.wait(10)
s['reeled'] = {'own': bobbers(game), 'damage': (game('state').get('held') or {}).get('damage')}
# Open water: a pool 7x7 and 3 deep, ahead.
host('command', command=f'fill {x + 3} {hy - 3} {z - 3} {x + 9} {hy - 1} {z + 3} minecraft:water')
game('command', command='item replace entity @s weapon.mainhand with minecraft:fishing_rod[enchantments={lure:3}]')
game.wait(10)
game.raw('look-at', f'{x + 6.5:.2f}', f'{hy - 1:.2f}', f'{z + 0.5:.2f}')
game.raw('use-item')
bit = None
for t in range(0, 900, 5):
game.wait(5)
if (game('status').get('fishing') or {}).get('nibble', 0) > 0:
bit = t
break
game.raw('use-item')
game.wait(40)
counts = game.raw('inventory')['counts']
s['caught'] = {'bit': bit is not None,
'damage': (game('state').get('held') or {}).get('damage'),
'items': sum(counts.values()) - 1}
game.shot(out, 'fishing-caught')
host('command', command=f'fill {x + 3} {hy - 3} {z - 3} {x + 9} {hy - 2} {z + 3} minecraft:stone')
host('command', command=f'fill {x + 3} {hy - 1} {z - 3} {x + 9} {hy - 1} {z + 3} minecraft:stone')
seen[game.name] = s
finally:
host('command', command='kill @e[type=minecraft:item]')
for game in (host, guest):
game('command', command='clear @s')
face_each_other(host, guest)
for name, s in seen.items():
other = guest if name == 'host' else host
assert s['own'] == [0], f'{name}: {seen}'
# The in-frame host draws only its own hook.
if other is guest or SERVER_THREAD:
assert len(s['other']) == 1 and s['other'][0] != 0, f'{name}: {seen}'
# FishingHook.retrieve costs 2 on the ground, but a resting hook's onGround
# alternates every tick on the server (Entity.move with no vertical motion
# clears it, the next tick's gravity sets it again): 2 or nothing.
assert s['reeled']['own'] == [] and s['reeled']['damage'] in (None, 0, 2), f'{name}: {seen}'
assert s['caught']['bit'] and s['caught']['damage'] == 1 and s['caught']['items'] >= 1, f'{name}: {seen}'
return seen
CHECKS += ['fishing']
CHECK_FNS.update(fishing=check_fishing)
def check_maps(host, guest, out):
"""MapItem.update for each player, on the server: a map the player makes and holds reveals the
terrain around them and shows their marker, which reach their client in
ClientboundMapItemDataPacket (#1382)."""
seen = {}
try:
for game in (host, guest):
game('command', command='gamemode survival')
game('command', command='clear @s')
game('command', command='item replace entity @s weapon.mainhand with minecraft:map')
x, y, z = pos_of(game)
game.raw('look-at', f'{x + 5:.2f}', f'{y + 1.6:.2f}', f'{z:.2f}')
game.wait(5)
game.raw('use-item')
# 16 ticks sweep every column once; the marker goes out every 5th tick.
game.wait(60)
maps = game('status').get('maps', [])
game.raw('look-at', f'{x + 1:.2f}', f'{y:.2f}', f'{z:.2f}')
game.wait(5)
game.shot(out, 'maps-held')
seen[game.name] = [{'pixels': m['pixels'], 'decorations': m['decorations']} for m in maps]
finally:
for game in (host, guest):
game('command', command='clear @s')
face_each_other(host, guest)
for name, maps in seen.items():
# Revealed out to the server's view distance, at least a 32-block disk.
assert len(maps) == 1 and maps[0]['pixels'] > 3000, f'{name}: {seen}'
assert maps[0]['decorations'] == ['map/decorations/player'], f'{name}: {seen}'
return seen
CHECKS += ['maps']
CHECK_FNS.update(maps=check_maps)
def check_body(host, guest, out):
"""What each player's own client decides for its body (#1278, #1303, #1296): walking while
drawing a bow is slowed to a fifth (LocalPlayer.modifyInput), sprint-swimming follows the look
down (Player.travel's look angle) and leather boots hold on powder snow
(PowderSnowBlock.canEntityWalkOnPowderSnow)."""
hx, hy, hz = (int(v // 1) for v in pos_of(host))
seen = {}
def walked(game, x, z, use):
game('command', command=f'tp @s {x + 0.5} {hy} {z + 0.5} -90 0')
game.wait(10)
if use:
game.raw('mouse', 'right', 'down')
game.wait(5)
a = pos_of(game)
game.raw('move', 'forward', '0.8')
game.wait(10)
b = pos_of(game)
game.raw('mouse', 'right', 'up')
game.wait(5)
return round(math.dist((a[0], a[2]), (b[0], b[2])), 2)
try:
for game, dz in ((host, -4), (guest, 4)):
x, z = hx, hz + dz
host('command', command=f'fill {x - 1} {hy - 1} {z - 1} {x + 10} {hy - 1} {z + 1} minecraft:stone')
host('command', command=f'fill {x - 1} {hy} {z - 1} {x + 10} {hy + 3} {z + 1} minecraft:air')
game('command', command='gamemode survival')
game('command', command='clear @s')
game('command', command='effect clear @s')
s = {'walk': walked(game, x, z, False)}
game('command', command='item replace entity @s weapon.mainhand with minecraft:bow')
game('command', command='give @s minecraft:arrow 4')
game.wait(5)
s['drawing'] = walked(game, x, z, True)
game('command', command='clear @s')
# Powder snow under the feet: leather boots stand on it, bare feet sink.
host('command', command=f'setblock {x + 3} {hy - 1} {z} minecraft:powder_snow')
for boots in ('leather_boots', 'air'):
game('command', command=f'item replace entity @s armor.feet with minecraft:{boots}')
game('command', command=f'tp @s {x + 3.5} {hy} {z + 0.5} -90 0')
game.wait(30)
s[boots] = round(pos_of(game)[1] - hy, 2)
host('command', command=f'setblock {x + 3} {hy - 1} {z} minecraft:stone')
# Deep water: sprint-swimming while looking down dives.
wx, wz = x, z + 2 * (1 if dz > 0 else -1) * 3
host('command', command=f'fill {wx - 1} {hy - 14} {wz - 2} {wx + 12} {hy + 2} {wz + 2} minecraft:stone')
host('command', command=f'fill {wx} {hy - 13} {wz - 1} {wx + 11} {hy - 1} {wz + 1} minecraft:water')
game.wait(10)
game('command', command=f'tp @s {wx + 1.5} {hy - 6} {wz + 0.5} -90 60')
game.wait(10)
a = pos_of(game)
game.raw('move', 'forward', '1.5', '--sprint')
game.wait(5)
s['dive'] = round(pos_of(game)[1] - a[1], 2)
game('command', command=f'tp @s {x + 0.5} {hy} {z + 0.5} -90 0')
game.wait(5)
host('command', command=f'fill {wx - 1} {hy - 14} {wz - 2} {wx + 12} {hy + 2} {wz + 2} minecraft:air')
host('command', command=f'fill {wx - 1} {hy - 14} {wz - 2} {wx + 12} {hy - 1} {wz + 2} minecraft:stone')
game.shot(out, 'body')
seen[game.name] = s
finally:
for game in (host, guest):
back_to_game(game)
game.raw('mouse', 'right', 'up')
game('command', command='clear @s')
face_each_other(host, guest)
for name, s in seen.items():
assert s['walk'] > 2.5 and s['drawing'] < s['walk'] * 0.4, f'{name} drawing a bow: {seen}'
assert s['leather_boots'] > -0.01 and s['air'] < -0.5, f'{name} powder snow: {seen}'
assert s['dive'] < -2, f'{name} sprint-swimming down: {seen}'
return seen
CHECKS += ['body']
CHECK_FNS.update(body=check_body)
def check_strikes(host, guest, out):
"""What a mob or the sky does to every player in reach, the server's players too (#1480,
#1484): a bolt striking a player standing in water costs them health (Entity.thunderHit), and
a cave spider's bite poisons them (CaveSpider.doHurtTarget on Normal)."""
hx, hy, hz = (int(v // 1) for v in pos_of(host))
seen = {}
try:
host('command', command='difficulty normal')
host('command', command='time set 18000')
for game, dz in ((host, -5), (guest, 5)):
x, z = hx, hz + dz
host('command', command=f'fill {x - 3} {hy - 1} {z - 3} {x + 3} {hy + 3} {z + 3} minecraft:stone')
host('command', command=f'fill {x - 2} {hy} {z - 2} {x + 2} {hy + 3} {z + 2} minecraft:air')
host('command', command=f'fill {x - 2} {hy} {z - 2} {x + 2} {hy} {z + 2} minecraft:water')
game('command', command='gamemode survival')
game('command', command='clear @s')
game('command', command='effect clear @s')
game('command', command='effect give @s minecraft:instant_health 1 5')
game('command', command=f'tp @s {x + 0.5} {hy} {z + 0.5}')
game.wait(20)
before = game('state')['player'].get('health')
game('command', command=f'summon minecraft:lightning_bolt {x + 0.5} {hy} {z + 0.5}')
game.wait(20)
s = {'bolt': (before, game('state')['player'].get('health'))}
host('command', command=f'summon minecraft:cave_spider {x + 1.5} {hy} {z + 0.5}')
poisoned = False
for _ in range(40):
game.wait(5)
if 'poison' in effect_ids(game):
poisoned = True
break
s['poisoned'] = poisoned
s['bitten'] = game('state')['player'].get('health')
host('command', command='kill @e[type=minecraft:cave_spider]')
game.wait(5)
game.shot(out, 'strikes')
host('command', command=f'fill {x - 3} {hy - 1} {z - 3} {x + 3} {hy + 3} {z + 3} minecraft:air')
host('command', command=f'fill {x - 3} {hy - 1} {z - 3} {x + 3} {hy - 1} {z + 3} minecraft:stone')
seen[game.name] = s
finally:
host('command', command='kill @e[type=minecraft:cave_spider]')
host('command', command='time set day')
for game in (host, guest):
back_to_game(game)
game('command', command='effect clear @s')
game('command', command='effect give @s minecraft:instant_health 1 5')
face_each_other(host, guest)
for name, s in seen.items():
a, b = s['bolt']
assert a is not None and b is not None and a - b >= 3, f'{name} struck by lightning: {seen}'
assert s['poisoned'], f'{name} bitten by a cave spider: {seen}'
return seen
CHECKS += ['strikes']
CHECK_FNS.update(strikes=check_strikes)
def check_cursor(host, guest, out):
"""Closing the inventory with a stack on the cursor puts it back into the player's inventory
(AbstractContainerMenu.removed, placeItemBackInInventory) and empties the cursor, for each
player: nothing is thrown out and no copy stays on the cursor (#1283)."""
seen = {}
try:
for game in (host, guest):
game('command', command='clear @s')
host('command', command='kill @e[type=minecraft:item]')
game('command', command='item replace entity @s hotbar.0 with minecraft:diamond 7')
game.wait(10)
game.raw('open-inventory')
game.raw('wait-for', 'screen', 'inventory', '--timeout', 10)
game.raw('click-slot', 0)
game.wait(5)
held = (game('inventory').get('carried') or {}).get('count')
game.raw('key', 'esc', 'tap')
game.wait(40)
inv = game('inventory')
seen[game.name] = {'held': held, 'carried': inv.get('carried'),
'client': inv['counts'].get('minecraft:diamond', 0),
'server': server_count(game, 'diamond'),
'thrown': len(game.raw('entities', 8, 'minecraft:item')['entities'])}
finally:
for game in (host, guest):
back_to_game(game)
game('command', command='clear @s')
host('command', command='kill @e[type=minecraft:item]')
for name, s in seen.items():
assert s == {'held': 7, 'carried': None, 'client': 7, 'server': 7, 'thrown': 0}, f'{name}: {seen}'
return seen
CHECKS += ['cursor']
CHECK_FNS.update(cursor=check_cursor)
def check_digging(host, guest, out):
"""The server breaks a block a player digs only once that player's client is done
(ServerPlayerGameMode: STOP_DESTROY_BLOCK, or the delayed destroy), never on its own count, so
the player's client always breaks it first, with its particles and sound. The guest holds
attack across a wall of six oak logs with a copper axe and hears each one break; then it digs
stone with a wooden pickaxe and its game stalls for a second halfway: the stone is still there
on both sides when it resumes, and the guest's own crack finishes it."""
gx, gy, gz = (int(v // 1) for v in pos_of(guest))
x, y, z = gx + 3, gy, gz + 4
heard = lambda sound: guest('status')['heard'].get(sound, 0)
at = lambda b: (f'{b[0] + 0.02:.2f}', f'{b[1] + 0.5:.2f}', f'{b[2] + 0.5:.2f}')
guest('command', command='gamemode survival')
guest('command', command='item replace entity @s weapon.mainhand with minecraft:copper_axe')
host('command', command=f'fill {x - 2} {y - 1} {z - 2} {x + 4} {y + 3} {z + 2} minecraft:air')
host('command', command=f'fill {x - 2} {y - 1} {z - 2} {x + 4} {y - 1} {z + 2} minecraft:stone')
host('command', command=f'fill {x + 2} {y} {z - 1} {x + 2} {y + 1} {z + 1} minecraft:oak_log')
guest('command', command=f'tp @s {x + 0.5} {y} {z + 0.5}')
guest.wait(30)
logs = [(x + 2, y + dy, z + dz) for dz in (-1, 0, 1) for dy in (0, 1)]
before = heard('minecraft:block.wood.break')
guest.raw('look-at', *at(logs[0]))
guest.raw('mouse', 'left', 'down')
left = list(logs)
deadline = time.time() + 20
while left and time.time() < deadline:
if guest.raw('block', *left[0]).get('block') != 'minecraft:oak_log':
left.pop(0)
if left:
guest.raw('look-at', *at(left[0]))
guest.raw('mouse', 'left', 'up')
guest.wait(10)
seen = {'logs_left': left, 'log_breaks_heard': heard('minecraft:block.wood.break') - before}
# Stone with a wooden pickaxe: 23 ticks. The guest stalls for a second after about 8.
stone = (x + 2, y, z)
guest('command', command='item replace entity @s weapon.mainhand with minecraft:wooden_pickaxe')
host('command', command=f'setblock {stone[0]} {stone[1]} {stone[2]} minecraft:stone')
guest.wait(10)
before = heard('minecraft:block.stone.break')
guest.raw('look-at', *at(stone))
guest.raw('mouse', 'left', 'down')
time.sleep(0.4)
os.kill(guest.pid, signal.SIGSTOP)
try:
time.sleep(1.0)
finally:
os.kill(guest.pid, signal.SIGCONT)
resumed = {'guest': guest.raw('block', *stone).get('block'), 'server': host.raw('block', *stone).get('block'),
'mining': guest('state').get('mining')}
# Let go once it breaks: past it the crosshair reaches the floor.
deadline = time.time() + 5
while guest.raw('block', *stone).get('block') == 'minecraft:stone' and time.time() < deadline:
pass
guest.raw('mouse', 'left', 'up')
guest.wait(10)
seen.update(resumed=resumed, stone_after=host.raw('block', *stone).get('block'),
stone_breaks_heard=heard('minecraft:block.stone.break') - before)
guest.shot(out, 'digging')
assert not left and seen['log_breaks_heard'] == 6, f'the server broke logs before the guest did: {seen}'
assert resumed['guest'] == resumed['server'] == 'minecraft:stone', f'the server broke the stone while the guest stalled: {seen}'
assert seen['stone_after'] == 'minecraft:air' and seen['stone_breaks_heard'] == 1, f'the guest did not break the stone: {seen}'
return seen
CHECKS += ['digging']
CHECK_FNS.update(digging=check_digging)
if __name__ == '__main__':
main()
+2 -2
View File
@@ -32,12 +32,12 @@ def compile_oracle(build, oracle_name, jars, libraries, java_major):
def build_probe(build, example):
"""Build the horizon-client probe binary; returns the command that runs probe `example`."""
run_logged(['cargo', 'build', '--locked', '-p', 'horizon-client', '--example', 'probe'],
run_logged(['cargo', 'build', '--locked', '-p', 'horizon-client', '--example', 'client_probe'],
build, 'compile-rust-' + example, env=dict(os.environ, CARGO_BUILD_JOBS='3'))
import json
metadata = json.loads(subprocess.check_output(
['cargo', 'metadata', '--locked', '--no-deps', '--format-version', '1'], cwd=lab.ROOT))
return [Path(metadata['target_directory']) / 'debug/examples/probe', example]
return [Path(metadata['target_directory']) / 'debug/examples/client_probe', example]
def java_run(build, classes, dependencies, main_class, args, name, jvm=()):
+29 -7
View File
@@ -466,22 +466,44 @@ def narrow_rust_sources(sources, scope):
PROBE_SOURCE = re.compile(r"/examples/probe/(?:(support)/)?(\w+)\.rs$")
# Each crate's probe example (crates/<crate>/examples/probe) and its target name. Until 2026-10-24 they were all
# `probe`, and Cargo copies every crate's examples into one <profile>/examples/: a harness could run the binary
# another harness had just copied there.
PROBE_TARGETS = {"horizon-client": "client_probe", "horizon-protocol": "protocol_probe", "horizon-world": "world_probe"}
OLD_PROBE_SOURCE = re.compile(r"crates/([\w-]+)/examples/probe[/.]")
def probes_run(commands):
"""The probes a harness ran through a crate's probe binary: `probe <name> ...`, or
`cargo run --example probe -- <name> ...`."""
"""The probes a harness ran through a crate's probe binary: `world_probe <name> ...`, or
`cargo run --example world_probe -- <name> ...`."""
names = set()
for arguments in commands:
program = Path(arguments[0]).name if arguments else ""
if program in ("probe", "probe.exe") and len(arguments) > 1:
program = Path(arguments[0]).name.removesuffix(".exe") if arguments else ""
if program in PROBE_TARGETS.values() and len(arguments) > 1:
names.add(arguments[1])
elif program == "cargo" and "--" in arguments and "probe" in arguments[:arguments.index("--")] \
and len(arguments) > arguments.index("--") + 1:
elif program == "cargo" and "--" in arguments and len(arguments) > arguments.index("--") + 1 \
and any(kind == "example" and name in PROBE_TARGETS.values() for kind, name, *_ in artifacts_of(arguments)):
names.add(arguments[arguments.index("--") + 1])
return names
def recorded_artifacts(record):
"""A harness record's artifacts, with the shared `probe` target of records from before 2026-10-24 renamed to
its crate's own (PROBE_TARGETS): the crate the record's `-p` selection names, else the one whose probe sources
the harness depended on. The prebuild would otherwise drop them as targets that no longer exist."""
artifacts = []
for artifact in record.get("artifacts", []):
if artifact[:2] != ["example", "probe"]:
artifacts.append(artifact)
continue
selection = artifact[3] if len(artifact) > 3 else []
crates = [value for flag, value in zip(selection, selection[1:]) if flag == "-p" and value in PROBE_TARGETS] \
or sorted({match.group(1) for path in record.get("dependencies", [])
if (match := OLD_PROBE_SOURCE.match(path)) and match.group(1) in PROBE_TARGETS})
artifacts += [["example", PROBE_TARGETS[crate], *artifact[2:]] for crate in crates] or [artifact]
return artifacts
def only_probes_run(paths, names):
"""A probe binary's dep-info lists every probe in it. Keep those the harness ran, the probes they include! or
name (crate::<probe>) and the shared support modules they name (support::<module>), so that editing one probe
@@ -1323,7 +1345,7 @@ def main():
if not record or "artifacts" not in record:
template = SHARED / "dependencies" / f"{name}.json"
record = json.loads(template.read_text(encoding="utf-8")) if template.exists() else {}
for artifact in record.get("artifacts", []):
for artifact in recorded_artifacts(record):
if artifact not in artifacts:
artifacts.append(artifact)
config = host_config()
+2 -2
View File
@@ -229,9 +229,9 @@ def gen_vanilla_order(root, version, store, build):
"dev.horizonlab.parity.VanillaCommandParseOracle", "tree", build], build)
env = dict(os.environ, CARGO_TARGET_DIR=str(root / ".local" / "port-target"))
jobs = os.environ.get("FLEET_LOAD_JOBS")
run(["cargo", "build", "-p", "horizon-client", "--example", "probe",
run(["cargo", "build", "-p", "horizon-client", "--example", "client_probe",
*(["-j", jobs] if jobs else [])], root, env=env)
fixture = root / ".local/port-target/debug/examples/probe"
fixture = root / ".local/port-target/debug/examples/client_probe"
run([fixture, "command_parse_fixture", "tree", build / "rust_tree.json"], root)
return [python(), "tools/generate_command_order.py", build / "tree.json", build / "rust_tree.json"]
+2 -2
View File
@@ -72,9 +72,9 @@ def main():
run(['java','-Xmx512M','-cp',os.pathsep.join([str(classes),str(jars[side]),dependency_path]),'dev.horizonlab.parity.VanillaActiveEffectTickOracle',mode,path],side+'-'+mode)
fixtures=list(corpus());inputs=build/'inputs.txt';inputs.write_text(''.join(json.dumps(value,separators=(',',':'))+'\n' for value in fixtures),encoding='utf-8')
fixture_paths=[inputs];tested_fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
references=[]
for side,jar in jars.items():
java(side,side,build)
+2 -2
View File
@@ -61,9 +61,9 @@ def main():
run(['java','-Xmx512M','-cp',os.pathsep.join([str(classes),str(jars[side]),dependency_path]),'dev.horizonlab.parity.VanillaActiveEffectsOracle',mode,path],side+'-'+mode)
fixtures=list(corpus());inputs=build/'inputs.txt';inputs.write_text(''.join(json.dumps(value,separators=(',',':'))+'\n' for value in fixtures),encoding='utf-8')
fixture_paths=[inputs];tested_fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
references=[]
for side,jar in jars.items():
java(side,side,build)
+2 -2
View File
@@ -53,9 +53,9 @@ def main():
with (build/(name+".log")).open("w",encoding="utf-8") as log:base.run(list(map(str,command)),stdout=log,stderr=subprocess.STDOUT)
dependency_path=os.pathsep.join(map(str,libraries))
run(["javac","--release",lock["minecraft"]["java_major"],"-proc:none","-cp",str(jars["server"])+os.pathsep+dependency_path,"-d",classes,oracle],"compile-java")
run(["cargo","build","--release","-p","horizon-world","--example","probe"],"compile-rust")
run(["cargo","build","--release","-p","horizon-world","--example","world_probe"],"compile-rust")
metadata=json.loads(subprocess.check_output(["cargo","metadata","--no-deps","--format-version","1"],cwd=lab.ROOT,text=True))
binary=Path(metadata["target_directory"])/"release/examples"/("probe.exe" if os.name=="nt" else "probe")
binary=Path(metadata["target_directory"])/"release/examples"/("world_probe.exe" if os.name=="nt" else "world_probe")
run([binary,"anchor_fixture",build],"rust")
references=[]
for side,jar in jars.items():
+2 -2
View File
@@ -241,9 +241,9 @@ def main():
expected = 3 * operations + len(fixtures)
(build / 'inputs.txt').write_text(''.join(json.dumps(f, separators=(',', ':')) + '\n' for f in fixtures))
input_hash = lab.digest(build / 'inputs.txt', 'sha256')
run(['cargo', 'build', '--locked', '-p', 'horizon-client', '--example', 'probe'], 'compile-rust')
run(['cargo', 'build', '--locked', '-p', 'horizon-client', '--example', 'client_probe'], 'compile-rust')
metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--locked', '--no-deps', '--format-version', '1'], cwd=lab.ROOT))
binary = Path(metadata['target_directory']) / 'debug/examples' / ('probe.exe' if os.name=='nt' else 'probe')
binary = Path(metadata['target_directory']) / 'debug/examples' / ('client_probe.exe' if os.name=='nt' else 'client_probe')
run([binary, 'arrow_probe',resources, build, '--describe'], 'describe')
references = []
for side, jar in jars.items():
+2 -2
View File
@@ -59,9 +59,9 @@ def main():
run(['java','-Xmx512M','-cp',os.pathsep.join([str(classes),str(jars[side]),dependency_path]),'dev.horizonlab.parity.VanillaAttributeHealthOracle',mode,path],side+'-'+mode)
java('server','export',build);states=json.loads((build/'catalog.json').read_text());fixtures=list(corpus(states));inputs=build/'inputs.txt';inputs.write_text(''.join(json.dumps(value,separators=(',',':'))+'\n' for value in fixtures),encoding='utf-8')
fixture_paths=[inputs,build/'catalog.json'];tested_fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
run([binary,'attribute_health_fixture',build],'rust');run([binary,'attribute_health_fixture',build,'live'],'rust-live');references=[]
for side,jar in jars.items():
java(side,side,build);reference=build/f'{side}.txt';matched=base.compare(reference,build/'rust.txt')
+2 -2
View File
@@ -82,9 +82,9 @@ def main():
run(['java','-Xmx512M','-cp',os.pathsep.join([str(classes),str(jars[side]),dependency_path]),'dev.horizonlab.parity.VanillaAttributeMapQueriesOracle',mode,path],side+'-'+mode)
fixtures=list(corpus());inputs=build/'inputs.txt';inputs.write_text(''.join(json.dumps(value,separators=(',',':'))+'\n' for value in fixtures),encoding='utf-8')
fixture_paths=[inputs];tested_fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
references=[]
for side,jar in jars.items():
java(side,side,build)
+2 -2
View File
@@ -89,9 +89,9 @@ def main():
run(['java','-Xmx512M','-cp',os.pathsep.join([str(classes),str(jars[side]),dependency_path]),'dev.horizonlab.parity.VanillaAttributeOracle',mode,path],side+'-'+mode)
java('server','export',build);states=json.loads((build/'attributes.json').read_text());fixtures=list(corpus(states));inputs=build/'inputs.txt';inputs.write_text(''.join(json.dumps(value,separators=(',',':'))+'\n' for value in fixtures),encoding='utf-8')
fixture_paths=[inputs,build/'attributes.json'];tested_fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
run([binary,'attribute_fixture',build],'rust');references=[]
for side,jar in jars.items():
java(side,side,build);reference=build/f'{side}.txt';matched=base.compare(reference,build/'rust.txt')
+2 -2
View File
@@ -70,9 +70,9 @@ def main():
run(['java','-Xmx512M','-cp',os.pathsep.join([str(classes),str(jars[side]),dependency_path]),'dev.horizonlab.parity.VanillaAttributeUpdatesOracle',mode,path],side+'-'+mode)
fixtures=list(corpus());inputs=build/'inputs.txt';inputs.write_text(''.join(json.dumps(value,separators=(',',':'))+'\n' for value in fixtures),encoding='utf-8')
fixture_paths=[inputs];tested_fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
references=[]
for side,jar in jars.items():
java(side,side,build)
+2 -2
View File
@@ -71,9 +71,9 @@ def main():
fixture_paths.append(path)
if json.loads((build/"facts-client.json").read_text())!=json.loads((build/"facts-server.json").read_text()):raise ValueError("reference feature block states differ")
tested_fixtures=base.source_hashes(fixture_paths)
run(["cargo","build","--release","-p","horizon-world","--example","probe"],"compile-rust")
run(["cargo","build","--release","-p","horizon-world","--example","world_probe"],"compile-rust")
metadata=json.loads(subprocess.check_output(["cargo","metadata","--no-deps","--format-version","1"],cwd=lab.ROOT,text=True))
binary=Path(metadata["target_directory"])/"release/examples"/("probe.exe" if os.name=="nt" else "probe")
binary=Path(metadata["target_directory"])/"release/examples"/("world_probe.exe" if os.name=="nt" else "world_probe")
run([binary,"basic_feature_fixture",build],"rust")
references=[]
for side,jar in jars.items():
+2 -2
View File
@@ -57,9 +57,9 @@ def main():
with (build/(name+".log")).open("w",encoding="utf-8") as log:subprocess.run(list(map(str,command)),cwd=lab.ROOT,check=True,timeout=3600,stdout=log,stderr=subprocess.STDOUT)
dependency_path=os.pathsep.join(map(str,libraries))
run(["javac","--release",lock["minecraft"]["java_major"],"-proc:none","-cp",str(jars["server"])+os.pathsep+dependency_path,"-d",classes,oracle],"compile-java")
run(["cargo","build","--release","-p","horizon-world","--example","probe"],"compile-rust")
run(["cargo","build","--release","-p","horizon-world","--example","world_probe"],"compile-rust")
metadata=json.loads(subprocess.check_output(["cargo","metadata","--no-deps","--format-version","1"],cwd=lab.ROOT,text=True))
binary=Path(metadata["target_directory"])/"release/examples"/("probe.exe" if os.name=="nt" else "probe")
binary=Path(metadata["target_directory"])/"release/examples"/("world_probe.exe" if os.name=="nt" else "world_probe")
run([binary,"biome_chunk_fixture",build],"rust")
references=[]
for side,jar in jars.items():
+2 -2
View File
@@ -76,9 +76,9 @@ def main():
registries=build/'registries.json';registries.write_text(json.dumps(bundle,separators=(',',':')),encoding='utf-8')
fixtures=list(corpus(bundle));inputs=build/'inputs.txt';inputs.write_text(''.join(json.dumps(f,separators=(',',':'))+'\n' for f in fixtures),encoding='utf-8')
fixture_paths=[inputs,registries,*exports];tested_fixtures=base.source_hashes(fixture_paths)
run(["cargo","build","--release","-p","horizon-world","--example","probe"],"compile-rust")
run(["cargo","build","--release","-p","horizon-world","--example","world_probe"],"compile-rust")
metadata=json.loads(subprocess.check_output(["cargo","metadata","--no-deps","--format-version","1"],cwd=lab.ROOT,text=True))
binary=Path(metadata["target_directory"])/"release/examples"/("probe.exe" if os.name=="nt" else "probe")
binary=Path(metadata["target_directory"])/"release/examples"/("world_probe.exe" if os.name=="nt" else "world_probe")
run([binary,"biome_generation_fixture",build],"rust")
references=[]
for side,jar in jars.items():
+2 -2
View File
@@ -53,9 +53,9 @@ def main():
with (build/(name+'.log')).open('w',encoding='utf-8') as log:base.run(list(map(str,command)),stdout=log,stderr=subprocess.STDOUT)
dependency_path=os.pathsep.join(map(str,libraries))
run(['javac','--release',lock['minecraft']['java_major'],'-proc:none','-sourcepath',str(lab.ROOT/'mods/horizon/src/test/java'),'-cp',str(jars['server'])+os.pathsep+dependency_path,'-d',classes,oracle,helper],'compile-java')
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
run([binary,'biome_placement_fixture',build],'rust');references=[]
for side,jar in jars.items():
run(['java','-Xmx512M','-cp',os.pathsep.join([str(classes),str(jar),dependency_path]),'dev.horizonlab.parity.VanillaBiomePlacementOracle',side,build],side)
+2 -2
View File
@@ -95,9 +95,9 @@ def main():
fixtures=list(corpus(bundle));inputs=build/'inputs.txt';inputs.write_text('\n'.join(fixtures)+'\n',encoding='utf-8')
(build/'positions.json').write_text(json.dumps(positions(),separators=(',',':')),encoding='utf-8')
fixture_paths=[inputs,*exports,build/'positions.json',*[build/(name+'.json') for name in bundle]];tested_fixtures=base.source_hashes(fixture_paths)
run(["cargo","build","--release","-p","horizon-world","--example","probe"],"compile-rust")
run(["cargo","build","--release","-p","horizon-world","--example","world_probe"],"compile-rust")
metadata=json.loads(subprocess.check_output(["cargo","metadata","--no-deps","--format-version","1"],cwd=lab.ROOT,text=True))
binary=Path(metadata["target_directory"])/"release/examples"/("probe.exe" if os.name=="nt" else "probe")
binary=Path(metadata["target_directory"])/"release/examples"/("world_probe.exe" if os.name=="nt" else "world_probe")
run([binary,"biome_source_codec_fixture",build],"rust")
references=[]
for side,jar in jars.items():
+2 -2
View File
@@ -44,9 +44,9 @@ def main():
with (build/(name+".log")).open("w",encoding="utf-8") as log:base.run(list(map(str,command)),stdout=log,stderr=subprocess.STDOUT)
dependency_path=os.pathsep.join(map(str,libraries))
run(["javac","--release",lock["minecraft"]["java_major"],"-proc:none","-cp",str(jars["server"])+os.pathsep+dependency_path,"-d",classes,oracle],"compile-java")
run(["cargo","build","--release","-p","horizon-world","--example","probe"],"compile-rust")
run(["cargo","build","--release","-p","horizon-world","--example","world_probe"],"compile-rust")
metadata=json.loads(subprocess.check_output(["cargo","metadata","--no-deps","--format-version","1"],cwd=lab.ROOT,text=True))
binary=Path(metadata["target_directory"])/"release/examples"/("probe.exe" if os.name=="nt" else "probe")
binary=Path(metadata["target_directory"])/"release/examples"/("world_probe.exe" if os.name=="nt" else "world_probe")
run([binary,"biome_source_fixture",build],"rust")
references=[]
for side,jar in jars.items():
+2 -2
View File
@@ -82,9 +82,9 @@ def main():
with (build/(name+".log")).open("w",encoding="utf-8") as log:base.run(list(map(str,command)),stdout=log,stderr=subprocess.STDOUT)
dependency_path=os.pathsep.join(map(str,libraries))
run(["javac","--release",lock["minecraft"]["java_major"],"-proc:none","-cp",str(jars["server"])+os.pathsep+dependency_path,"-d",classes,oracle],"compile-java")
run(["cargo","build","--release","-p","horizon-world","--example","probe"],"compile-rust")
run(["cargo","build","--release","-p","horizon-world","--example","world_probe"],"compile-rust")
metadata=json.loads(subprocess.check_output(["cargo","metadata","--no-deps","--format-version","1"],cwd=lab.ROOT,text=True))
binary=Path(metadata["target_directory"])/"release/examples"/("probe.exe" if os.name=="nt" else "probe")
binary=Path(metadata["target_directory"])/"release/examples"/("world_probe.exe" if os.name=="nt" else "world_probe")
run([binary,"biome_temperature_fixture",build],"rust")
references=[]
for side,jar in jars.items():
+2 -2
View File
@@ -68,9 +68,9 @@ def main():
run(['java','-Xmx512M','-cp',os.pathsep.join([str(classes),str(jars[side]),dependency_path]),'dev.horizonlab.parity.VanillaBlockCollisionScanOracle',mode,path],side+'-'+mode)
fixtures=list(corpus());inputs=build/'inputs.txt';inputs.write_text(''.join(json.dumps(value,separators=(',',':'))+'\n' for value in fixtures),encoding='utf-8')
fixture_paths=[inputs];tested_fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
run([binary,'block_collision_scan_fixture',build],'rust');references=[]
for side,jar in jars.items():
java(side,side,build);reference=build/f'{side}.txt';matched=base.compare(reference,build/'rust.txt')
+1 -1
View File
@@ -279,7 +279,7 @@ def main():
*(PARITY / f'{n}.java' for n in ('ParityData', 'VanillaBlockEntityAnimOracle'))], 'compile-java')
run(['java', '-Xmx2G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaBlockEntityAnimOracle',
inputs, build / 'vanilla.txt'], 'vanilla')
run(['cargo', 'run', '--quiet', '--profile', 'fast', '-p', 'horizon-client', '--example', 'probe', '--',
run(['cargo', 'run', '--quiet', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe', '--',
'block_entity_anim_fixture', resources, inputs, build / 'rust.txt'], 'rust')
def split(path):
+1 -1
View File
@@ -303,7 +303,7 @@ def main():
vanilla = [json.loads(l) for l in (build / 'vanilla.jsonl').read_text().splitlines()]
textures = sorted({s['texture'] for v in vanilla for s in v.get('submits', []) if 'texture' in s})
(build / 'textures.txt').write_text(''.join(t + '\n' for t in textures))
run(['cargo', 'run', '--quiet', '--profile', 'fast', '-p', 'horizon-client', '--example', 'probe', '--',
run(['cargo', 'run', '--quiet', '--profile', 'fast', '-p', 'horizon-client', '--example', 'client_probe', '--',
'block_entity_render_fixture', resources, inputs, build / 'textures.txt', build / 'rust.jsonl'], 'rust')
rust = [json.loads(l) for l in (build / 'rust.jsonl').read_text().splitlines()]
assert len(vanilla) == len(rust), (len(vanilla), len(rust))
+2 -2
View File
@@ -75,9 +75,9 @@ def main():
with (build/(name+'.log')).open('w') as log:subprocess.run(list(map(str,command)),cwd=lab.ROOT,check=True,timeout=3600,stdout=log,stderr=subprocess.STDOUT)
dependencies=os.pathsep.join(map(str,libraries))
run(['javac','--release',lock['minecraft']['java_major'],'-proc:none','-sourcepath',str(lab.ROOT/'mods/horizon/src/test/java'),'-cp',str(jars['server'])+os.pathsep+dependencies,'-d',classes,oracle],'compile-java')
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
run([binary,'block_entity_storage_fixture',inputs,build/'rust.txt'],'rust')
references=[]
for side,jar in jars.items():
+1 -1
View File
@@ -120,7 +120,7 @@ def main():
run(['java', '-Xmx1G', '-cp', str(classes) + os.pathsep + dependencies,
'dev.horizonlab.parity.VanillaBlockEntityTickerOracle', inputs, build / 'vanilla.txt'], 'vanilla')
run(['cargo', 'run', '--quiet', '--profile', 'fast', '-p', 'horizon-client', '--example',
'probe', '--', 'block_entity_tickers_fixture', inputs, build / 'rust.txt'], 'rust')
'client_probe', '--', 'block_entity_tickers_fixture', inputs, build / 'rust.txt'], 'rust')
matched = base.compare(build / 'vanilla.txt', build / 'rust.txt')
ticks = sum(1 for line in lines if line == 'tick')
listed = sum(len(line.split()) - 1 for line in (build / 'vanilla.txt').read_text().splitlines())
+2 -2
View File
@@ -69,8 +69,8 @@ def main():
with (build/'inputs.txt').open('w') as output:
for f in corpus(states,definitions):output.write(json.dumps(f,separators=(',',':'))+'\n');count+=1
fixture_paths=[build/n for n in ['inputs.txt','landing-states.json','landing-definitions.json','movement-properties.nbt','block-registry.nbt','cached-collision.nbt']];fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--locked','--release','-p','horizon-world','--example','probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--locked','--no-deps','--format-version','1'],cwd=lab.ROOT));binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
run(['cargo','build','--locked','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--locked','--no-deps','--format-version','1'],cwd=lab.ROOT));binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
run([binary,'block_landing_fixture',build],'rust');references=[]
for side,jar in jars.items():
java(side,side);matched=base.compare(build/(side+'.txt'),build/'rust.txt');references.append(dict(side=side,jar_sha256=lab.digest(jar,'sha256'),output_sha256=lab.digest(build/(side+'.txt'),'sha256'),matched_output_lines=matched));print(f'{side}: {matched:,} registered block landing lines match',flush=True)
+2 -2
View File
@@ -57,9 +57,9 @@ def main():
java('server','export',build)
fixtures=list(corpus());inputs=build/'inputs.txt';inputs.write_text(''.join(json.dumps(value,separators=(',',':'))+'\n' for value in fixtures),encoding='utf-8')
fixture_paths=[inputs,build/'block-registry.nbt',build/'cached-collision.nbt',build/'block-properties.nbt'];tested_fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
run([binary,'block_properties_fixture',build],'rust');references=[]
for side,jar in jars.items():
java(side,side,build);reference=build/f'{side}.txt';matched=base.compare(reference,build/'rust.txt')
+2 -2
View File
@@ -53,9 +53,9 @@ def main():
run(['java','-Xmx512M','-cp',os.pathsep.join([str(classes),str(jars[side]),dependency_path]),'dev.horizonlab.parity.VanillaBlockPushOracle',mode,path],side+'-'+mode)
fixtures=list(corpus());inputs=build/'inputs.txt';inputs.write_text(''.join(json.dumps(value,separators=(',',':'))+'\n' for value in fixtures),encoding='utf-8')
fixture_paths=[inputs];tested_fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
run([binary,'block_push_fixture',build],'rust');references=[]
for side,jar in jars.items():
java(side,side,build);reference=build/f'{side}.txt';matched=base.compare(reference,build/'rust.txt')
+2 -2
View File
@@ -60,9 +60,9 @@ def main():
if len(facts['states'])!=35723:raise ValueError('incomplete pinned state registry')
fixtures=list(corpus(facts));inputs=build/'inputs.txt';inputs.write_text(''.join(json.dumps(value,separators=(',',':'))+'\n' for value in fixtures),encoding='utf-8')
fixture_paths=[inputs,build/'facts-client.json',build/'facts-server.json'];tested_fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
run([binary,'block_state_codec_fixture',build],'rust');references=[]
for side,jar in jars.items():
java(side,side,build);reference=build/f'{side}.txt';matched=base.compare(reference,build/'rust.txt')
+2 -2
View File
@@ -35,9 +35,9 @@ def main():
run(['java','-Xmx512M','-cp',os.pathsep.join([str(classes),str(jars[side]),dependency_path]),'dev.horizonlab.parity.VanillaBlockSupportOracle',mode,path],side+'-'+mode)
java('server','export',build)
fixture_paths=[build/'block-registry.nbt',build/'cached-support.nbt'];tested_fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
run([binary,'block_support_fixture',build],'rust');references=[]
for side,jar in jars.items():
java(side,side,build);reference=build/f'{side}.txt';matched=base.compare(reference,build/'rust.txt')
+2 -2
View File
@@ -236,9 +236,9 @@ def main():
output.write(json.dumps(fixture,separators=(',',':'))+'\n');fixture_count+=1
fixture_paths=[inputs,build/'survival-extra-definitions.json',build/'fluid-tags.json',build/'survival-placement-classes.json',build/'survival-support-tags.json',build/'facts.json',build/'survival-classes.json',build/'survival-rules.json',build/'tags.json',build/'block-registry.nbt',build/'cached-collision.nbt',build/'block-properties.nbt',build/'cached-support.nbt']
tested_fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
base.ensure_sources_unchanged(sources,tested_sources)
checkpoint={'schema':1,'environment':environment,'sources_sha256':tested_sources,'fixtures_sha256':{str(lab.ROOT/name):digest for name,digest in tested_fixtures.items()},'artifacts_sha256':{str(path):lab.digest(path,'sha256') for path in [binary,*sorted(classes.rglob('*.class'))]},'binary':str(binary),'counts':{'supported_blocks':len(definitions),'supported_states':sum(state['id'] in definitions for state in facts['states']),'survival_rules':len(set(definitions.values())),'survival_rule_kinds':len({rule.split(':',1)[0] for rule in definitions.values()}),'fluid_tag_files':len(fluid_tags),'fixtures':fixture_count},'outputs':{}}
save_checkpoint(checkpoint_path,checkpoint)
+2 -2
View File
@@ -60,9 +60,9 @@ def main():
run(['java','-Xmx512M','-cp',os.pathsep.join([str(classes),str(jars[side]),dependency_path]),'dev.horizonlab.parity.VanillaBlockingItemDamageOracle',mode,path],side+'-'+mode)
fixtures=list(corpus());inputs=build/'inputs.txt';inputs.write_text(''.join(json.dumps(value,separators=(',',':'))+'\n' for value in fixtures),encoding='utf-8')
fixture_paths=[inputs];tested_fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
run([binary,'blocking_item_damage_fixture',build],'rust');references=[]
for side,jar in jars.items():
java(side,side,build);reference=build/f'{side}.txt';matched=base.compare(reference,build/'rust.txt')
+2 -2
View File
@@ -60,9 +60,9 @@ def main():
run(['java','-Xmx512M','-cp',os.pathsep.join([str(classes),str(jars[side]),dependency_path]),'dev.horizonlab.parity.VanillaBlockingRulesOracle',mode,path],side+'-'+mode)
fixtures=list(corpus());inputs=build/'inputs.txt';inputs.write_text(''.join(json.dumps(value,separators=(',',':'))+'\n' for value in fixtures),encoding='utf-8')
fixture_paths=[inputs];tested_fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
run([binary,'blocking_rules_fixture',build],'rust');references=[]
for side,jar in jars.items():
java(side,side,build);reference=build/f'{side}.txt';matched=base.compare(reference,build/'rust.txt')
+2 -2
View File
@@ -70,9 +70,9 @@ def main():
(build/"tags.json").write_text(json.dumps(tags,separators=(",",":")),encoding="utf-8")
fixture_paths=[inputs,build/"tags.json",build/"facts-client.json",build/"facts-server.json"]
tested_fixtures=base.source_hashes(fixture_paths)
run(["cargo","build","--release","-p","horizon-world","--example","probe"],"compile-rust")
run(["cargo","build","--release","-p","horizon-world","--example","world_probe"],"compile-rust")
metadata=json.loads(subprocess.check_output(["cargo","metadata","--no-deps","--format-version","1"],cwd=lab.ROOT,text=True))
binary=Path(metadata["target_directory"])/"release/examples"/("probe.exe" if os.name=="nt" else "probe")
binary=Path(metadata["target_directory"])/"release/examples"/("world_probe.exe" if os.name=="nt" else "world_probe")
run([binary,"bulk_section_fixture",build],"rust")
references=[]
for side,jar in jars.items():
+2 -2
View File
@@ -64,9 +64,9 @@ def main():
run(['java','-Xmx512M','-cp',os.pathsep.join([str(classes),str(jars[side]),dependency_path]),'dev.horizonlab.parity.VanillaBundleWeightOracle',mode,path],side+'-'+mode)
fixtures=list(corpus());inputs=build/'inputs.txt';inputs.write_text(''.join(json.dumps(value,separators=(',',':'))+'\n' for value in fixtures),encoding='utf-8')
fixture_paths=[inputs];tested_fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
run([binary,'bundle_weight_fixture',build],'rust');references=[]
for side,jar in jars.items():
java(side,side,build);reference=build/f'{side}.txt';matched=base.compare(reference,build/'rust.txt')
+2 -2
View File
@@ -65,9 +65,9 @@ def main():
with (build/(name+".log")).open("w",encoding="utf-8") as log:base.run(list(map(str,command)),stdout=log,stderr=subprocess.STDOUT)
dependency_path=os.pathsep.join(map(str,libraries))
run(["javac","--release",lock["minecraft"]["java_major"],"-proc:none","-cp",str(jars["server"])+os.pathsep+dependency_path,"-d",classes,oracle,helper],"compile-java")
run(["cargo","build","--release","-p","horizon-world","--example","probe"],"compile-rust")
run(["cargo","build","--release","-p","horizon-world","--example","world_probe"],"compile-rust")
metadata=json.loads(subprocess.check_output(["cargo","metadata","--no-deps","--format-version","1"],cwd=lab.ROOT,text=True))
binary=Path(metadata["target_directory"])/"release/examples"/("probe.exe" if os.name=="nt" else "probe")
binary=Path(metadata["target_directory"])/"release/examples"/("world_probe.exe" if os.name=="nt" else "world_probe")
run([binary,"canyon_carver_fixture",build],"rust")
references=[]
for side,jar in jars.items():
+2 -2
View File
@@ -72,9 +72,9 @@ def main():
with (build/(name+".log")).open("w",encoding="utf-8") as log:base.run(list(map(str,command)),stdout=log,stderr=subprocess.STDOUT)
dependency_path=os.pathsep.join(map(str,libraries))
run(["javac","--release",lock["minecraft"]["java_major"],"-proc:none","-cp",str(jars["server"])+os.pathsep+dependency_path,"-d",classes,oracle],"compile-java")
run(["cargo","build","--release","-p","horizon-world","--example","probe"],"compile-rust")
run(["cargo","build","--release","-p","horizon-world","--example","world_probe"],"compile-rust")
metadata=json.loads(subprocess.check_output(["cargo","metadata","--no-deps","--format-version","1"],cwd=lab.ROOT,text=True))
binary=Path(metadata["target_directory"])/"release/examples"/("probe.exe" if os.name=="nt" else "probe")
binary=Path(metadata["target_directory"])/"release/examples"/("world_probe.exe" if os.name=="nt" else "world_probe")
run([binary,"carving_geometry_fixture",build],"rust")
references=[]
for side,jar in jars.items():
+2 -2
View File
@@ -65,9 +65,9 @@ def main():
with (build/(name+".log")).open("w",encoding="utf-8") as log:base.run(list(map(str,command)),stdout=log,stderr=subprocess.STDOUT)
dependency_path=os.pathsep.join(map(str,libraries))
run(["javac","--release",lock["minecraft"]["java_major"],"-proc:none","-cp",str(jars["server"])+os.pathsep+dependency_path,"-d",classes,oracle],"compile-java")
run(["cargo","build","--release","-p","horizon-world","--example","probe"],"compile-rust")
run(["cargo","build","--release","-p","horizon-world","--example","world_probe"],"compile-rust")
metadata=json.loads(subprocess.check_output(["cargo","metadata","--no-deps","--format-version","1"],cwd=lab.ROOT,text=True))
binary=Path(metadata["target_directory"])/"release/examples"/("probe.exe" if os.name=="nt" else "probe")
binary=Path(metadata["target_directory"])/"release/examples"/("world_probe.exe" if os.name=="nt" else "world_probe")
run([binary,"carving_mask_fixture",build],"rust")
references=[]
for side,jar in jars.items():
+2 -2
View File
@@ -60,9 +60,9 @@ def main():
with (build/(name+".log")).open("w",encoding="utf-8") as log:base.run(list(map(str,command)),stdout=log,stderr=subprocess.STDOUT)
dependency_path=os.pathsep.join(map(str,libraries))
run(["javac","--release",lock["minecraft"]["java_major"],"-proc:none","-cp",str(jars["server"])+os.pathsep+dependency_path,"-d",classes,oracle,helper],"compile-java")
run(["cargo","build","--release","-p","horizon-world","--example","probe"],"compile-rust")
run(["cargo","build","--release","-p","horizon-world","--example","world_probe"],"compile-rust")
metadata=json.loads(subprocess.check_output(["cargo","metadata","--no-deps","--format-version","1"],cwd=lab.ROOT,text=True))
binary=Path(metadata["target_directory"])/"release/examples"/("probe.exe" if os.name=="nt" else "probe")
binary=Path(metadata["target_directory"])/"release/examples"/("world_probe.exe" if os.name=="nt" else "world_probe")
run([binary,"cave_carver_fixture",build],"rust")
references=[]
for side,jar in jars.items():
+2 -2
View File
@@ -71,9 +71,9 @@ class Oracle:
def rust_binary():
subprocess.run(['cargo', 'build', '--release', '-q', '-p', 'horizon-world', '--example', 'probe'], check=True, cwd=lab.ROOT)
subprocess.run(['cargo', 'build', '--release', '-q', '-p', 'horizon-world', '--example', 'world_probe'], check=True, cwd=lab.ROOT)
metadata = json.loads(subprocess.check_output(['cargo', 'metadata', '--no-deps', '--format-version', '1'], cwd=lab.ROOT, text=True))
return Path(metadata['target_directory']) / 'release/examples/probe'
return Path(metadata['target_directory']) / 'release/examples/world_probe'
def run_rust(binary, out, seed, dimension, rects, scan=False):
+2 -2
View File
@@ -73,9 +73,9 @@ def main():
(build/"tags.json").write_text(json.dumps(tags,separators=(",",":")),encoding="utf-8")
fixture_paths=[inputs,build/"tags.json",build/"facts-client.json",build/"facts-server.json"]
tested_fixtures=base.source_hashes(fixture_paths)
run(["cargo","build","--release","-p","horizon-world","--example","probe"],"compile-rust")
run(["cargo","build","--release","-p","horizon-world","--example","world_probe"],"compile-rust")
metadata=json.loads(subprocess.check_output(["cargo","metadata","--no-deps","--format-version","1"],cwd=lab.ROOT,text=True))
binary=Path(metadata["target_directory"])/"release/examples"/("probe.exe" if os.name=="nt" else "probe")
binary=Path(metadata["target_directory"])/"release/examples"/("world_probe.exe" if os.name=="nt" else "world_probe")
run([binary,"chunk_stage_fixture",build],"rust")
references=[]
for side,jar in jars.items():
+2 -2
View File
@@ -42,9 +42,9 @@ def main():
with (build/(name+'.log')).open('w') as log:subprocess.run(list(map(str,command)),cwd=lab.ROOT,check=True,timeout=3600,stdout=log,stderr=subprocess.STDOUT)
dependencies=os.pathsep.join(map(str,libraries))
run(['javac','--release',lock['minecraft']['java_major'],'-proc:none','-sourcepath',str(lab.ROOT/'mods/horizon/src/test/java'),'-cp',str(jars['server'])+os.pathsep+dependencies,'-d',classes,oracle],'compile-java')
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
run([binary,'chunk_status_fixture',inputs,build/'rust.txt'],'rust')
references=[]
for side,jar in jars.items():
+1 -1
View File
@@ -54,7 +54,7 @@ def main():
with (build/'inputs.txt').open('w') as output:
for f in corpus(info):output.write(json.dumps(f,separators=(',',':'))+'\n');count+=1
fixture_paths=[build/n for n in ['inputs.txt','info.json','block-registry.nbt','tags.json']];fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--locked','--release','-p','horizon-world','--example','probe'],'compile-rust');metadata=json.loads(subprocess.check_output(['cargo','metadata','--locked','--no-deps','--format-version','1'],cwd=lab.ROOT));binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe');run([binary,'climbing_fixture',build],'rust');references=[]
run(['cargo','build','--locked','--release','-p','horizon-world','--example','world_probe'],'compile-rust');metadata=json.loads(subprocess.check_output(['cargo','metadata','--locked','--no-deps','--format-version','1'],cwd=lab.ROOT));binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe');run([binary,'climbing_fixture',build],'rust');references=[]
for side,jar in jars.items():
java(side,side);matched=base.compare(build/(side+'.txt'),build/'rust.txt');references.append(dict(side=side,jar_sha256=lab.digest(jar,'sha256'),output_sha256=lab.digest(build/(side+'.txt'),'sha256'),matched_output_lines=matched));print(f'{side}: {matched:,} climbing output lines match Rust',flush=True)
base.ensure_sources_unchanged(sources,tested);base.ensure_sources_unchanged(fixture_paths,fixtures)
+2 -2
View File
@@ -59,9 +59,9 @@ def main():
run(['java','-Xmx512M','-cp',os.pathsep.join([str(classes),str(jars[side]),dependency_path]),'dev.horizonlab.parity.VanillaCollisionContextOracle',mode,path],side+'-'+mode)
fixtures=list(corpus());inputs=build/'inputs.txt';inputs.write_text(''.join(json.dumps(value,separators=(',',':'))+'\n' for value in fixtures),encoding='utf-8')
fixture_paths=[inputs];tested_fixtures=base.source_hashes(fixture_paths)
run(['cargo','build','--release','-p','horizon-world','--example','probe'],'compile-rust')
run(['cargo','build','--release','-p','horizon-world','--example','world_probe'],'compile-rust')
metadata=json.loads(subprocess.check_output(['cargo','metadata','--no-deps','--format-version','1'],cwd=lab.ROOT,text=True))
binary=Path(metadata['target_directory'])/'release/examples'/('probe.exe' if os.name=='nt' else 'probe')
binary=Path(metadata['target_directory'])/'release/examples'/('world_probe.exe' if os.name=='nt' else 'world_probe')
run([binary,'collision_context_fixture',build],'rust');references=[]
for side,jar in jars.items():
java(side,side,build);reference=build/f'{side}.txt';matched=base.compare(reference,build/'rust.txt')

Some files were not shown because too many files have changed in this diff Show More