Merge remote-tracking branch 'origin/main' into fix/dg1-villager-doors
This commit is contained in:
@@ -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
|
||||
|
||||
@@ -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::*;
|
||||
|
||||
@@ -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,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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(),
|
||||
|
||||
@@ -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()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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},
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -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])
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
},
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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#"
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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, ®istry).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));
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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 = "\
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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]
|
||||
|
||||
|
||||
@@ -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.
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
@@ -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();
|
||||
|
||||
@@ -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")
|
||||
|
||||
@@ -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'],
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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
@@ -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
@@ -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"]
|
||||
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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')
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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')
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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')
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -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))
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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())
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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')
|
||||
|
||||
@@ -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')
|
||||
|
||||
@@ -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')
|
||||
|
||||
@@ -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')
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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')
|
||||
|
||||
@@ -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')
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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')
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
Reference in New Issue
Block a user