Merge origin/main into fix/remote-tnt

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-26 04:07:18 +01:00
133 changed files with 10841 additions and 891 deletions
+2 -1
View File
@@ -29,7 +29,8 @@ env:
jobs:
audit:
runs-on: [self-hosted, horizon-game]
# The Mac mini's runners only: the audit compares with the previous one, so it stays on one platform.
runs-on: [self-hosted, horizon-game, macOS]
timeout-minutes: 150
steps:
- name: 03:00 in Paris
+5 -1
View File
@@ -23,7 +23,11 @@ env:
jobs:
parity-main:
runs-on: [self-hosted, horizon-game]
# The Mac mini's release runner (label added 2026-10-26), not the two `horizon-game` runners: behind PR parity jobs
# this run waited 2 h while every merge replaced the pending one, and releases wait for it. Releases need it green
# first, so the two never compete. Not the desktop: a job slowed down because the maintainer came back could time
# out, and a failure here bisects and comments on merges.
runs-on: [self-hosted, macOS, horizon-parity-main]
timeout-minutes: 240 # a core-crate batch reruns ~300 harnesses (~60-90 min), a bisect a few rounds of the failures
steps:
- uses: actions/checkout@v4
+13 -1
View File
@@ -36,7 +36,19 @@ jobs:
- name: Tools from the runner
run: bash tools/ci/runner-env.sh
- name: Vanilla data, and resources prepared by this preparer
run: bash tools/ci/vanilla-data.sh
env:
BASE_SHA: ${{ inputs.base }}
run: |
# main's script: one written before a fix to it left a real .local/horizon-client without sounds.json on
# the runner, and every later job there failed `subtitle`. A branch that changes the script runs its own.
set -euo pipefail
if git rev-parse --verify -q origin/main >/dev/null \
&& git diff --quiet "$(git merge-base "$BASE_SHA" HEAD)" HEAD -- tools/ci/vanilla-data.sh; then
git show origin/main:tools/ci/vanilla-data.sh > "$RUNNER_TEMP/vanilla-data.sh"
bash "$RUNNER_TEMP/vanilla-data.sh"
else
bash tools/ci/vanilla-data.sh
fi
- name: The prepared output is the one the preparer's OUTPUT_VERSION says
env:
BASE_SHA: ${{ inputs.base }}
+46 -1
View File
@@ -79,9 +79,50 @@ jobs:
# A dry run builds whatever the decision, to test the builds.
if [[ "${{ steps.mode.outputs.dry_run }}" == true ]]; then echo "release=true" >> "$GITHUB_OUTPUT"; fi
build:
exporters:
needs: decide
if: needs.decide.outputs.release == 'true'
# This runner holds the maintainer's own pinned Minecraft jars. Only our classes leave it.
runs-on: ${{ vars.MAC_RUNNER || 'ludovics-mac-mini' }}
# Three full preparations (two isolated, one batched) besides the compile.
timeout-minutes: 60
steps:
- uses: actions/checkout@v4
with:
ref: ${{ needs.decide.outputs.head }}
persist-credentials: false
clean: true
- uses: dtolnay/rust-toolchain@stable
- run: bash tools/ci/runner-env.sh
- run: bash tools/ci/vanilla-data.sh
- name: Compile and validate original exporters against the pinned jars
shell: bash
run: |
set -euo pipefail
# target/ is gone after the clean checkout, and vanilla-data.sh builds the preparer only when it
# prepares afresh.
cargo build --release --locked -p horizon-prepare
# Compiled here, never taken from the runner's shared preparations: pull requests' parity jobs
# write those (vanilla-data.sh links .local/exporters to them).
rm -rf .local/exporters
bundle=$(target/release/horizon-prepare compile-exporters --root "$PWD" | tail -1)
mkdir -p exporters
cp -R "$bundle/server" "$bundle/client" "$bundle/manifest.json" exporters/
# Only our classes and their manifest leave this runner.
stray=$(find exporters -type f ! -path exporters/manifest.json \
! \( -name '*.class' \( -path 'exporters/server/dev/horizonlab/parity/*' -o -path 'exporters/client/dev/horizonlab/parity/*' \) \))
[ -z "$stray" ] || { echo "::error::not one of our classes: $stray"; exit 1; }
python3 tools/check_prepare_exporters.py --binary target/release/horizon-prepare
- uses: actions/upload-artifact@v4
with:
name: original-exporters
path: exporters/
if-no-files-found: error
retention-days: 3
build:
needs: [decide, exporters]
if: needs.decide.outputs.release == 'true'
name: build ${{ matrix.name }}
strategy:
fail-fast: false
@@ -220,6 +261,10 @@ jobs:
path: ${{ runner.temp }}/smoke-test.json
if-no-files-found: error
retention-days: 3
- uses: actions/download-artifact@v4
with:
name: original-exporters
path: exporters
- name: Package
run: |
set -euo pipefail
+3
View File
@@ -31,3 +31,6 @@
/.horizon-cache/
/crash-reports/
/debug/
# Release-only compiled original exporter bundle.
/exporters/
Generated
+2
View File
@@ -1408,6 +1408,8 @@ dependencies = [
name = "horizon-prepare"
version = "0.1.0"
dependencies = [
"crc32fast",
"libc",
"regex",
"sha1",
"sha2",
+1 -1
View File
@@ -31,7 +31,7 @@ Horizon is Minecraft: Java Edition 26.3 rewritten in Rust: a native game that re
Horizon is installed through **the Horizon launcher**. Get it from [playhorizon.dev](https://playhorizon.dev) (the Download button picks your system) or from [the launcher releases](https://github.com/ludovic111/horizon/releases?q=launcher-v&expanded=true), for Linux x86-64, macOS on Apple Silicon or Windows x64. The launcher installs and updates the game, prepares its files from your own copy of Minecraft, and updates itself.
**You need** Minecraft: Java Edition 26.3, played once (the official launcher, Prism, MultiMC and other launchers all work); a Java 25 JDK, for the one-time preparation; and a GPU with Vulkan on Linux and Windows, or any Apple Silicon Mac. Step by step, with macOS's first-open prompt and the first launch: [Install and first launch](https://playhorizon.dev/docs/install).
**You need** Minecraft: Java Edition 26.3, played once (the official launcher, Prism, MultiMC and other launchers all work); a Java 25 runtime, for the one-time preparation; and a GPU with Vulkan on Linux and Windows, or any Apple Silicon Mac. Step by step, with macOS's first-open prompt and the first launch: [Install and first launch](https://playhorizon.dev/docs/install).
<table>
<tr>
+10
View File
@@ -208,6 +208,9 @@ fn play(path: &Path, report: &mut Report) -> Result<(), String> {
game_time: t,
day_time: 1000 + t,
}),
// The GUI of a 1280 x 720 window at scale 3.
gui_size: (427.0, 240.0),
held: None,
});
mods.tick(t);
for _ in 0..FRAMES_PER_TICK {
@@ -228,8 +231,15 @@ fn play(path: &Path, report: &mut Report) -> Result<(), String> {
Output::Stopped { reason, .. } => return Err(format!("it stopped: {reason}")),
Output::OpenScreen { .. } => "opened a screen".to_string(),
Output::CloseScreen { .. } => "closed its screen".to_string(),
Output::Shake { strength, seconds } => {
format!("shook the camera: {strength:.2} for {seconds:.1} s")
}
});
}
let shapes = mods.hud_shapes().count();
if shapes > 0 {
report.output.push(format!("drew {shapes} HUD shape(s)"));
}
match failed(&mods) {
Some(reason) => Err(format!("it stopped: {reason}")),
None => Ok(()),
@@ -598,6 +598,7 @@ fn print(out: &mut String, t: i32, i: usize, m: &Mob, player_down: bool, now: i6
let _ = writeln!(out, " removed {reason}");
return;
}
let _ = write!(out, "\tleashed {}", u8::from(m.extra.leash.is_some()));
let p = m.position;
let v = m.velocity;
let _ = write!(
@@ -977,6 +978,7 @@ pub fn main() -> horizon_client::Result<()> {
}
// Set once the brain exists (below).
x if x.starts_with("cooldown=") => {}
"dead" => m.health = 0.0,
"leashed" => m.extra.leash = Some(horizon_client::mobs::leash::Holder::Player),
x if x.starts_with("leashto=") => {
let n: u32 = x[8..].parse().unwrap();
@@ -1097,6 +1099,7 @@ pub fn main() -> horizon_client::Result<()> {
}
};
}
let mut dropped_leads = 0;
for t in 1..=s.ticks {
world.game_time += 1;
if s.daycycle {
@@ -1208,6 +1211,16 @@ pub fn main() -> horizon_client::Result<()> {
if !alive {
m.removed = true;
}
// Apply the same detach/drop event as Game::break_leash.
for event in &events[from..] {
if let MobEvent::LeashBreak { mob, drop, .. } = event
&& let Some(m) = mobs.iter_mut().find(|m| m.id == *mob)
&& horizon_client::mobs::leash::remove(m).is_some()
&& *drop
{
dropped_leads += 1;
}
}
horizon_client::mobs::apply_brain_events(&mut mobs, &mut events, from);
villager_events(
&mut mobs,
@@ -1427,6 +1440,9 @@ pub fn main() -> horizon_client::Result<()> {
world.game_time,
);
}
if s.name.starts_with("leash_death_") {
let _ = writeln!(out, "{t} leads {dropped_leads}");
}
for e in &events {
if let MobEvent::Sound(name, _, volume, pitch) = e {
let _ = writeln!(
+50 -5
View File
@@ -33,7 +33,11 @@ impl Cost {
#[derive(Clone, Debug)]
pub struct Enchantment {
pub id: Arc<str>,
/// The name the pinned English map gave at load: the fallback for a
/// language that has no entry for the key below.
pub description: String,
/// `description`'s translation key (`enchantment.minecraft.<name>`).
pub description_key: String,
pub max_level: u32,
pub weight: u32,
pub anvil_cost: u32,
@@ -224,6 +228,7 @@ impl Enchantments {
.get(key)
.cloned()
.unwrap_or_else(|| id.trim_start_matches("minecraft:").replace('_', " ")),
description_key: key.to_owned(),
max_level: v["max_level"].as_u64().unwrap_or(1) as u32,
weight: v["weight"].as_u64().unwrap_or(1) as u32,
anvil_cost: v["anvil_cost"].as_u64().unwrap_or(0) as u32,
@@ -329,16 +334,26 @@ impl Enchantments {
}
/// `Enchantment.getFullname` as plain text and whether it is a curse (red).
pub fn full_name(&self, id: &str, level: u32) -> (String, bool) {
let language = crate::lang::current();
self.full_name_in(language.as_deref(), id, level)
}
/// `full_name` against `language`; `None` (no language loaded: a
/// dedicated server, the probes) keeps the English names loaded above.
pub fn full_name_in(
&self,
language: Option<&crate::lang::Language>,
id: &str,
level: u32,
) -> (String, bool) {
let tr = |key: &str| language.and_then(|l| l.get(key).map(str::to_owned));
let Some(e) = self.get(id) else {
return (format!("{id} {}", level_name(level)), false);
};
let mut name = e.description.clone();
let mut name = tr(&e.description_key).unwrap_or_else(|| e.description.clone());
if level != 1 || e.max_level != 1 {
name.push(' ');
name.push_str(
self.lang
.get(&format!("enchantment.level.{level}"))
.map_or(&level_name(level), |s| s),
&tr(&format!("enchantment.level.{level}")).unwrap_or_else(|| level_name(level)),
);
}
(name, self.is_curse(id))
@@ -771,7 +786,7 @@ pub(crate) mod tests {
let defs = [
(
"minecraft:sharpness",
json!({"anvil_cost":1,"exclusive_set":"#minecraft:exclusive_set/damage","max_cost":{"base":21,"per_level_above_first":11},"max_level":5,"min_cost":{"base":1,"per_level_above_first":11},"primary_items":"#minecraft:enchantable/melee_weapon","supported_items":"#minecraft:enchantable/sharp_weapon","weight":10,"slots":["mainhand"],"effects":{"minecraft:damage":[{"effect":{"type":"minecraft:add","value":{"type":"minecraft:linear","base":1.0,"per_level_above_first":0.5}}}]}}),
json!({"anvil_cost":1,"description":{"translate":"enchantment.minecraft.sharpness"},"exclusive_set":"#minecraft:exclusive_set/damage","max_cost":{"base":21,"per_level_above_first":11},"max_level":5,"min_cost":{"base":1,"per_level_above_first":11},"primary_items":"#minecraft:enchantable/melee_weapon","supported_items":"#minecraft:enchantable/sharp_weapon","weight":10,"slots":["mainhand"],"effects":{"minecraft:damage":[{"effect":{"type":"minecraft:add","value":{"type":"minecraft:linear","base":1.0,"per_level_above_first":0.5}}}]}}),
),
(
"minecraft:smite",
@@ -795,6 +810,7 @@ pub(crate) mod tests {
.map(|(id, v)| Enchantment {
id: Arc::from(*id),
description: id.trim_start_matches("minecraft:").into(),
description_key: v["description"]["translate"].as_str().unwrap_or("").into(),
max_level: v["max_level"].as_u64().unwrap() as u32,
weight: v["weight"].as_u64().unwrap() as u32,
anvil_cost: v["anvil_cost"].as_u64().unwrap() as u32,
@@ -1088,4 +1104,33 @@ pub(crate) mod tests {
assert!(!e.compatible("minecraft:sharpness", "minecraft:smite"));
assert!(e.compatible("minecraft:sharpness", "minecraft:unbreaking"));
}
/// The enchantment's name and its level come from the selected language,
/// with the English name loaded above as the fallback.
#[test]
fn names_follow_the_language() {
struct Mem(HashMap<String, Vec<u8>>);
impl crate::lang::ResourceSource for Mem {
fn read(&self, path: &str) -> Option<Vec<u8>> {
self.0.get(path).cloned()
}
}
let ru = Mem(HashMap::from([(
"assets/minecraft/lang/ru_ru.json".to_owned(),
r#"{"enchantment.minecraft.sharpness":"Острота","enchantment.level.5":"V"}"#
.as_bytes()
.to_vec(),
)]));
let ru = crate::lang::Language::load(&[&ru], "ru_ru");
let e = sample();
assert_eq!(
e.full_name_in(Some(&ru), "minecraft:sharpness", 5).0,
"Острота V"
);
// mending carries no key in the fixture: the English name stays.
assert_eq!(
e.full_name_in(Some(&ru), "minecraft:mending", 1).0,
"mending"
);
}
}
+78 -14
View File
@@ -97,6 +97,8 @@ mod maps;
mod minecarts;
mod mob_blocks;
mod mob_gear;
mod mod_input;
mod mod_render;
mod mods;
mod mount_menu;
mod mounts;
@@ -1242,6 +1244,11 @@ struct Game<'a> {
luminance: Option<horizon_client::dynamic_light::Luminance>,
/// Name tags drawn over everything (`RenderPipelines.TEXT_SEE_THROUGH`).
see_through_vertices: Vec<Vertex>,
/// Runs of `entity_vertices` by entity, for a shader pack's per-entity draws; recorded only
/// while `pack_ids` is set (game/shader_packs.rs).
entity_spans: std::cell::RefCell<Vec<horizon_client::gfx::pack_draw::EntitySpan>>,
/// The shader pack's entity and block entity ids, while one draws entities.
pack_ids: Option<shader_packs::PackIds>,
started: Instant,
previous: Instant,
/// FramerateLimitTracker.latestInputTime.
@@ -2769,7 +2776,13 @@ impl Game<'_> {
}
_ => 1.0,
};
self.audio.play(name, c, volume, pitch);
if matches!(id, 1029 | 1030) {
// Clients play the anvil sound from its level event;
// capturing it also sends a duplicate sound packet.
self.audio.play_unshared(name, c, volume, pitch);
} else {
self.audio.play(name, c, volume, pitch);
}
}
}
LevelEvent::Sound {
@@ -4931,6 +4944,7 @@ impl Game<'_> {
// Hud: the action bar and titles draw over the hotbar (nextStratum).
self.draw_boss_bars(&mut batch);
self.draw_extras(&mut batch);
self.draw_mod_shapes(&mut batch);
}
if show_hud {
// Hud.nextContextualInfoState: the jump bar, the experience bar or
@@ -6752,8 +6766,10 @@ impl Game<'_> {
alpha: f64,
mut out: Vec<Vertex>,
) -> Vec<Vertex> {
self.entity_spans.borrow_mut().clear();
self.prepare_entity_culling(camera);
self.prepare_trims();
self.mark_entity(out.len(), "minecraft:entity_flame");
let fire_yaw = if self.camera_type == perspective::CameraType::ThirdPersonFront {
self.yaw + 180.0
} else {
@@ -6845,14 +6861,19 @@ impl Game<'_> {
}
}
// `ItemEntityRenderer`.
self.mark_entity(out.len(), "minecraft:item");
self.dropped_item_geometry(camera, alpha, &mut out);
// `VaultRenderer`.
self.mark_entity(out.len(), "");
self.vault_geometry(camera, alpha, &mut out);
self.mark_entity(out.len(), "minecraft:ominous_item_spawner");
self.ominous_item_spawner_geometry(camera, alpha, &mut out);
// Mobs and their projectiles.
// Mobs and their projectiles (a span each).
self.mob_geometry(camera, alpha, &mut out);
self.mark_entity(out.len(), "minecraft:player");
self.player_model_geometry(camera, self.clock.camera_fraction(), &mut out);
self.guest_model_geometry(camera, alpha, &mut out);
self.mark_entity(out.len(), "minecraft:evoker_fangs");
self.fangs_geometry(camera, alpha, &mut out);
let mut see_through = std::mem::take(&mut self.see_through_vertices);
see_through.clear();
@@ -6860,6 +6881,7 @@ impl Game<'_> {
self.text_display_geometry(camera, alpha, &mut out, &mut see_through);
self.see_through_vertices = see_through;
// Entity shadows (EntityRenderer.extractShadow).
self.mark_translucent_entity(out.len(), "minecraft:entity_shadow");
if let Some(sprite) = self.gui.atlas.sprites.get("misc/shadow").copied() {
let ambient = if self.dim == Dim::Nether { 0.1 } else { 0.0 };
let darken = self.sky_darken();
@@ -6953,13 +6975,14 @@ impl Game<'_> {
v.intersects(o - glam::Vec3::ONE, o + glam::Vec3::splat(2.0))
})
});
if self.entity_culler.is_some() {
if self.entity_culler.is_some() || self.pack_ids.is_some() {
for block in visible {
let start = out.len();
self.mark_block_entity(start, block.1);
self.res
.block_entity_render()
.render(&scene, std::iter::once(block), &mut out);
if !off_screen(block.1) {
if !off_screen(block.1) && self.entity_culler.is_some() {
self.cull_entity_vertices(&mut out, start);
}
}
@@ -6968,6 +6991,7 @@ impl Game<'_> {
.block_entity_render()
.render(&scene, visible, &mut out);
}
self.mark_stage(out.len(), "DESTROY");
for (pos, stage) in self.cracks(camera) {
let state = self.world.block(pos[0], pos[1], pos[2]);
self.res
@@ -6976,6 +7000,7 @@ impl Game<'_> {
}
}
// Experience orbs (ExperienceOrbRenderer): pulsing billboards from a 4x4 icon sheet.
self.mark_entity(out.len(), "minecraft:experience_orb");
if let Some(r) = self
.gui
.atlas
@@ -7039,6 +7064,7 @@ impl Game<'_> {
}
}
// Falling blocks use their baked model, including non-cubic shapes.
self.mark_entity(out.len(), "minecraft:falling_block");
for f in &self.falling {
let Some((_, tint)) = self.block_face_sprite(f.state) else {
continue;
@@ -7069,20 +7095,35 @@ impl Game<'_> {
vertex.color = horizon_client::hud_layout::multiply(vertex.color, tint);
}
}
self.mark_entity(out.len(), "");
self.moving_piston_geometry(camera, alpha, &mut out);
self.mark_entity(out.len(), "minecraft:tnt");
self.tnt_geometry(camera, alpha, &mut out);
self.mark_entity(out.len(), "minecraft:painting");
self.painting_geometry(camera, &mut out);
self.mark_entity(out.len(), "minecraft:item_frame");
self.frame_geometry(camera, &mut out);
self.mark_entity(out.len(), "minecraft:armor_stand");
self.armor_stand_geometry(camera, alpha, &mut out);
self.mark_entity(out.len(), "minecraft:oak_boat");
self.boat_geometry(camera, alpha, &mut out);
self.mark_entity(out.len(), "minecraft:minecart");
self.cart_geometry(camera, alpha, &mut out);
// Beams: `gbuffers_beaconbeam`, not a block entity's program (5.4 has no stage for them).
self.mark_stage(out.len(), "NONE");
self.beacon_geometry(camera, alpha, &mut out);
self.mark_entity(out.len(), "minecraft:fishing_bobber");
self.fishing_geometry(camera, alpha, &mut out);
self.mark_entity(out.len(), "minecraft:leash_knot");
self.leash_geometry(camera, alpha, &mut out);
self.mark_entity(out.len(), "minecraft:trident");
self.trident_geometry(camera, alpha, &mut out);
self.mark_entity(out.len(), "minecraft:firework_rocket");
self.rocket_geometry(camera, alpha, &mut out);
self.mark_entity(out.len(), "minecraft:splash_potion");
self.thrown_potion_geometry(camera, alpha, &mut out);
// Particles (ParticleEngine.extract): camera-facing quads.
self.mark_stage(out.len(), "PARTICLES");
let world = &self.world;
self.particles.render(
camera,
@@ -7093,6 +7134,7 @@ impl Game<'_> {
&mut out,
);
// Breaking progress overlays (destroy_stage_0..9): ours and the other players'.
self.mark_stage(out.len(), "DESTROY");
for (pos, stage) in self.cracks(camera) {
let o = (glam::DVec3::new(f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2]))
- camera)
@@ -8405,6 +8447,8 @@ impl Game<'_> {
1.0,
1.0,
);
// ItemStack.useOn: a use that acted counts as one of the item.
self.stats.add("used", &stack.item, 1);
self.damage_held(damage);
self.post_block_game_event("minecraft:block_change", pos, self.sculk_actor(), Some(new));
Ok(true)
@@ -8609,6 +8653,14 @@ impl Game<'_> {
1.0,
1.0,
);
// HoneycombItem.useOn's game event, and ItemStack.useOn's used statistic.
self.post_block_game_event(
"minecraft:block_change",
hit.pos,
self.sculk_actor(),
Some(state),
);
self.stats.add("used", &stack.item, 1);
if !self.creative {
self.consume_held();
}
@@ -9200,10 +9252,6 @@ impl Game<'_> {
)
}
fn apply_settings(&mut self) {
if let Some(r) = &self.renderer {
self.settings
.clamp_gui_scale([r.config.width as i32, r.config.height as i32]);
}
self.streaming.radius = self.settings.render_distance;
// Options.biomeBlendRadius, ambientOcclusion and cutoutLeaves:
// LevelExtractor.allChanged when they change.
@@ -9966,6 +10014,7 @@ impl Game<'_> {
self.pitch,
),
};
let (view_yaw, view_pitch) = self.shaken_view(view_yaw, view_pitch);
self.audio
.set_listener([camera.x, camera.y, camera.z], view_yaw, view_pitch);
let block = [
@@ -10197,6 +10246,7 @@ impl Game<'_> {
} else {
self.shader_pack_inputs(camera, alpha as f32)
};
let entity_spans = std::mem::take(self.entity_spans.get_mut());
let frame = Frame {
weather: &weather,
weather_time: horizon_client::weather::Time::new(self.world.game_time, alpha as f32),
@@ -10261,6 +10311,7 @@ impl Game<'_> {
color: sky.cloud_color,
}),
entities: &entities,
entity_spans: &entity_spans,
dynamic_lights: &self.dynamic_lights,
lightning: horizon_client::gfx::lightning::Input {
bolts: &bolts,
@@ -10312,6 +10363,7 @@ impl Game<'_> {
};
// Restore storage even when rendering fails (for example, a lost surface).
self.entity_vertices = entities;
*self.entity_spans.get_mut() = entity_spans;
self.see_through_vertices = see_through;
result
}
@@ -10577,6 +10629,10 @@ impl Game<'_> {
}
/// A mouse button while playing (window or control socket).
fn play_mouse(&mut self, button: MouseButton, pressed: bool) -> Result<()> {
// A mod's claimed item takes the use button (capability `input`).
if self.mod_use(button, pressed) {
return Ok(());
}
if self.sleeping.is_some() {
return Ok(());
}
@@ -11039,6 +11095,12 @@ impl ApplicationHandler for Game<'_> {
if self.screen == Screen::Advancements {
self.advancements_drag();
}
if self.screen == Screen::Stats {
self.stats_drag();
}
if self.screen == Screen::WorldOptions {
self.world_options_drag();
}
if self.screen == Screen::Creative {
let (_, oy) = Self::creative_origin(&b);
self.creative_screen.drag_scrollbar(self.cursor.1 - oy);
@@ -11318,6 +11380,9 @@ impl ApplicationHandler for Game<'_> {
Screen::WorldOptions if pressed && button == MouseButton::Left => {
self.world_options_click()
}
Screen::WorldOptions if button == MouseButton::Left => {
self.world_options_release()
}
Screen::Friends if pressed && button == MouseButton::Left => {
self.friends_screen_click()
}
@@ -11341,6 +11406,7 @@ impl ApplicationHandler for Game<'_> {
.map_or([1, 1], |r| [r.config.width, r.config.height]);
self.stats_click(size);
}
Screen::Stats if button == MouseButton::Left => self.stats_release(),
Screen::Mod if pressed && button == MouseButton::Left => {
self.mod_screen_click()
}
@@ -11485,6 +11551,7 @@ impl ApplicationHandler for Game<'_> {
return Ok(());
};
self.extras_key(key, event.state == ElementState::Pressed, event.repeat);
self.mod_key(key, event.state == ElementState::Pressed, event.repeat);
// key.smoothCamera toggles the cinematic camera.
if self.screen == Screen::Playing
&& event.state == ElementState::Pressed
@@ -11907,6 +11974,8 @@ impl<'a> Game<'a> {
dynamic_lights: Vec::new(),
luminance: None,
see_through_vertices: Vec::new(),
entity_spans: Default::default(),
pack_ids: None,
health_hud: hud_layout::HealthHud::default(),
started: now,
previous: now,
@@ -12842,6 +12911,7 @@ fn loading_frame(hud: &HudBatch) -> Frame<'_> {
hud,
nether_lighting: false,
entities: &[],
entity_spans: &[],
dynamic_lights: &[],
clouds: None,
lightning: Default::default(),
@@ -13102,10 +13172,6 @@ impl Loading {
return;
}
}
if let Some(r) = &self.renderer {
self.settings
.clamp_gui_scale([r.config.width as i32, r.config.height as i32]);
}
horizon_client::hud::GUI_SCALE.store(self.settings.gui_scale, Ordering::Relaxed);
self.window = Some(window);
}
@@ -13144,8 +13210,6 @@ impl Loading {
self.settings.horizon.api,
) {
Ok(r) => {
self.settings
.clamp_gui_scale([r.config.width as i32, r.config.height as i32]);
horizon_client::hud::GUI_SCALE.store(self.settings.gui_scale, Ordering::Relaxed);
self.renderer = Some(r);
}
+6 -3
View File
@@ -2501,12 +2501,14 @@ impl Game<'_> {
};
let max = Self::int(ctx, "maxCount").unwrap_or(-1);
let counting = max == 0;
// Inventory.clearOrCountMatchingItems: main, armor, crafting grid, carried.
// Inventory slots 0..40: main, armor feet to head, off hand;
// then clearOrCountMatchingItems visits the crafting grid and carried stack.
let mut removed = 0i32;
let mut budget = if max < 0 { i32::MAX } else { max };
let all = |g: &Self| -> Vec<Option<ItemStack>> {
let mut v: Vec<Option<ItemStack>> = g.inventory.clone();
v.extend(g.armor.iter().cloned());
v.extend(g.armor.iter().rev().cloned());
v.push(g.offhand.clone());
v.extend(g.craft_grid.iter().cloned());
v.push(g.carried.clone());
v
@@ -2520,7 +2522,8 @@ impl Game<'_> {
.collect();
let mut slots: Vec<&mut Option<ItemStack>> = Vec::new();
slots.extend(self.inventory.iter_mut());
slots.extend(self.armor.iter_mut());
slots.extend(self.armor.iter_mut().rev());
slots.push(&mut self.offhand);
slots.extend(self.craft_grid.iter_mut());
slots.push(&mut self.carried);
for (slot, matches) in slots.into_iter().zip(matching) {
@@ -294,6 +294,11 @@ impl Game<'_> {
if action == "tap" {
self.extras_key(physical, false, false);
}
// So do mods' keys (capability `input`).
self.mod_key(physical, action != "up", action == "repeat");
if action == "tap" {
self.mod_key(physical, false, false);
}
// Text screens consume raw presses; releases follow key binds.
let typing = matches!(self.screen, Screen::Chat | Screen::Options);
let key = if typing && arg(2)? != "up" {
@@ -3031,6 +3031,7 @@ impl Game<'_> {
continue;
}
}
self.mark_entity(entity_start, &mob.kind.id);
let light = self.world.light(
mob.position.x.floor() as i32,
(mob.position.y + mob.eye_height()).floor() as i32,
@@ -45,7 +45,8 @@ pub(super) struct RulesScreen {
initial: GameRules,
/// IntegerRuleEntry's boxes, by rule.
numbers: Vec<(&'static str, EditBox)>,
scroll: f32,
/// RuleList's scrolling: the wheel and the held scrollbar.
scroll: ui::Scroll,
/// ConfirmScreen "Game Rule Changes" in its place.
confirm: bool,
}
@@ -120,7 +121,7 @@ impl RulesScreen {
values: rules.clone(),
initial: rules.clone(),
numbers,
scroll: 0.0,
scroll: ui::Scroll::default(),
confirm: false,
}
}
@@ -156,12 +157,17 @@ impl RulesScreen {
})
.collect()
}
fn max_scroll(rows: usize, h: f32) -> f32 {
(ROW * rows as f32 + 4.0 - (h - HEADER - FOOTER)).max(0.0)
}
/// Entry `i`'s top: 2 under the list's top, less the scroll.
fn row_top(&self, i: usize) -> f32 {
HEADER + 2.0 - self.scroll.trunc() + ROW * i as f32
HEADER + 2.0 - self.scroll.amount.trunc() + ROW * i as f32
}
/// The list's scrollbar column (AbstractSelectionList: 6 pixels right of
/// the entries) and the pixels it scrolls.
fn bar(w: f32) -> f32 {
row_left(w) + ROW_WIDTH + 6.0 + 2.0
}
fn content(&self) -> f32 {
ROW * self.rows().len() as f32 + 4.0
}
/// getEntryAtPosition: the row under the pointer, inside the list.
fn hovered(&self, rows: usize, (x, y): (f32, f32), (w, h): (f32, f32)) -> Option<usize> {
@@ -212,10 +218,28 @@ impl RulesScreen {
/// The mouse wheel (AbstractSelectionList: half an entry a step).
pub(super) fn wheel(&mut self, delta: f32, h: f32) {
if !self.confirm {
let max = Self::max_scroll(self.rows().len(), h);
self.scroll = (self.scroll - delta * ROW / 2.0).clamp(0.0, max);
let content = self.content();
self.scroll
.wheel(delta, ROW / 2.0, HEADER, h - FOOTER, content);
}
}
/// A press on the scrollbar holds it (AbstractSelectionList.updateScrolling).
pub(super) fn press_scrollbar(&mut self, cursor: (f32, f32), (w, h): (f32, f32)) -> bool {
let content = self.content();
self.scroll
.press(cursor, Self::bar(w), HEADER, h - FOOTER, content)
}
/// The pointer moved while the scrollbar is held.
pub(super) fn drag(&mut self, y: f32, h: f32) {
if self.scroll.held() {
let content = self.content();
self.scroll.drag(y, HEADER, h - FOOTER, content);
}
}
/// The button came up: the scrollbar lets go.
pub(super) fn release(&mut self) {
self.scroll.release();
}
fn focused(&mut self) -> Option<(Option<&'static str>, &mut EditBox)> {
if self.search.focused {
return Some((None, &mut self.search));
@@ -229,7 +253,7 @@ impl RulesScreen {
/// number sets its rule when valid (IntegerRuleEntry's responder).
fn edited(&mut self, rule: Option<&'static str>) {
let Some(name) = rule else {
self.scroll = 0.0;
self.scroll.amount = 0.0;
return;
};
let Some(r) = gamerules::rule(name) else {
@@ -286,6 +310,11 @@ impl RulesScreen {
if on(cx, cy, 150.0, 20.0) {
return self.close();
}
// A press on the scrollbar holds it and clicks nothing else.
if self.press_scrollbar(cursor, size) {
self.unfocus();
return None;
}
// A click moves the focus to the widget under it.
let (sx, sy) = search_at(w);
if on(sx, sy, SEARCH_WIDTH, 15.0) {
@@ -360,7 +389,8 @@ impl RulesScreen {
return;
}
let rows = self.rows();
self.scroll = self.scroll.clamp(0.0, Self::max_scroll(rows.len(), h));
let content = ROW * rows.len() as f32 + 4.0;
self.scroll.clamp(HEADER, h - FOOTER, content);
// RuleList: the in-world list background, its entries clipped to it,
// then the separators and scrollbar.
ui::list_background(batch, atlas, HEADER, h - FOOTER, true);
@@ -421,16 +451,14 @@ impl RulesScreen {
}
batch.clip_since(first, 0.0, HEADER, w, h - FOOTER);
ui::separators(batch, atlas, HEADER, h - FOOTER, true);
let content = ROW * rows.len() as f32 + 4.0;
let bar_x = left + ROW_WIDTH + 6.0 + 2.0;
ui::scrollbar(
batch,
atlas,
bar_x,
Self::bar(w),
HEADER,
h - FOOTER,
content,
self.scroll.trunc(),
self.scroll.amount.trunc(),
);
// The header: the title centred over the search box.
let title = Text::translate("editGamerule.title", &[]);
@@ -536,6 +564,29 @@ mod tests {
);
}
/// AbstractScrollArea: a press on the bar holds it, a drag moves the
/// list (to the ends past them), a release lets go.
#[test]
fn the_scroll_bar_can_be_held_dragged_and_let_go() {
let mut s = RulesScreen::new(&GameRules::default());
let (w, h) = (427.0, 240.0);
let (top, bottom, content) = (HEADER, h - FOOTER, s.content());
assert!(
content > bottom - top,
"the rules overflow a 240-high screen"
);
let bar = RulesScreen::bar(w);
assert!(!s.press_scrollbar((bar - 4.0, top + 5.0), (w, h)));
assert!(s.press_scrollbar((bar + 3.0, top + 5.0), (w, h)));
s.drag(top + 40.0, h);
assert!(s.scroll.amount > 0.0);
s.drag(bottom + 10.0, h);
assert_eq!(s.scroll.amount, content - (bottom - top));
s.release();
s.drag(top, h);
assert_eq!(s.scroll.amount, content - (bottom - top));
}
#[test]
fn edits_change_rules_and_bad_numbers_hold_done() {
let mut s = RulesScreen::new(&GameRules::default());
+3 -3
View File
@@ -1136,9 +1136,9 @@ impl Game<'_> {
for e in events {
if let horizon_world::level::LevelEvent::LevelEvent { id, pos, data } = e {
// The acting guest does not predict the egg's teleport
// particles, nor bone meal's growth (BoneMealItem.useOn's
// levelEvent names no player).
let except = if matches!(*id, 2015 | 1505) {
// particles, bone meal's growth, or anvil result sounds
// (these levelEvent calls name no excluded player).
let except = if matches!(*id, 2015 | 1505 | 1029 | 1030) {
None
} else {
self.lan_acting
@@ -1808,14 +1808,13 @@ impl Game<'_> {
g.use_delay -= 1;
}
});
// ServerPlayerGameMode.handleBlockBreakAction: a creative
// player's START breaks the block once (destroyAndAck) and
// leaves nothing being destroyed; its client sends no STOP.
// Kept, the dig broke whatever was put there next, every
// destroy delay, for as long as the player broke nothing else.
// ServerPlayerGameMode.handleBlockBreakAction: creative and
// instant survival STARTs finish without a STOP from the client.
// tick_mining clears mining on completion; forget the START too,
// so a flower or crop planted here later is not broken again.
if digging.is_some()
&& host.hub.guests[gi].creative()
&& let Some(play) = host.play.get_mut(&conn)
&& (host.hub.guests[gi].creative() || play.mining.is_none())
{
play.digging = None;
}
@@ -802,6 +802,27 @@ impl Game<'_> {
}
}
/// The pointer moved while a list's scrollbar is held: the game rules'
/// list follows it (AbstractSelectionList.mouseDragged).
pub(super) fn world_options_drag(&mut self) {
let h = self.gui_size().1;
if let Some(o) = self.world_options.as_mut()
&& o.view == View::GameRules
&& let Some(rules) = o.rules.as_mut()
{
rules.drag(self.cursor.1, h);
}
}
/// The button came up: a held scrollbar lets go (onRelease).
pub(super) fn world_options_release(&mut self) {
if let Some(o) = self.world_options.as_mut()
&& let Some(rules) = o.rules.as_mut()
{
rules.release();
}
}
pub(super) fn world_options_click(&mut self) {
let Some(mut o) = self.world_options.take() else {
return;
+2
View File
@@ -79,6 +79,8 @@ impl Game<'_> {
if horizon_client::mobs::leash::remove(m).is_none() {
return;
}
// Leashable.tickLeash gates a dying entity's lead drop on entity_drops.
let drop = drop && (m.alive() || self.ui.rules.bool("entity_drops"));
let at = [m.position.x, m.position.y, m.position.z];
if sound {
self.lead_sound("break", at);
@@ -0,0 +1,92 @@
//! Capability `input` (docs/mods.md): the use button on items a mod claims,
//! and the mod's own keys. With no mod claiming items or keys, each hook
//! here returns after one check.
use super::Game;
use winit::{event::MouseButton, keyboard::KeyCode};
#[cfg(feature = "mods")]
use {super::Screen, horizon_mods::HeldItem};
/// A claimed item's use while the button is down.
#[cfg(feature = "mods")]
pub(super) struct ModUse {
item: HeldItem,
/// `Game::ticks` when it started.
since: u64,
}
#[cfg(not(feature = "mods"))]
impl Game<'_> {
pub(super) fn mod_use(&mut self, _button: MouseButton, _pressed: bool) -> bool {
false
}
pub(super) fn mod_key(&mut self, _key: KeyCode, _pressed: bool, _repeat: bool) {}
}
#[cfg(feature = "mods")]
impl Game<'_> {
/// The main hand's stack as `input` shows it; none when it is empty.
pub(super) fn mod_held(&self) -> Option<HeldItem> {
let stack = self.inventory.get(self.selected)?.as_ref()?;
Some(HeldItem {
id: stack.item.to_string(),
count: stack.count,
slot: self.selected as u32,
})
}
/// The use button while playing: true when a mod claimed the held item,
/// so the game does nothing else with it (no placing, eating, swing).
pub(super) fn mod_use(&mut self, button: MouseButton, pressed: bool) -> bool {
if button != MouseButton::Right || !self.mods.mods.claims_any() {
return false;
}
if !pressed {
return self.stop_mod_use();
}
let Some(item) = self.mod_held().filter(|h| self.mods.mods.claims(&h.id)) else {
return false;
};
self.mods.mods.use_start(&item);
self.mods.using = Some(ModUse {
item,
since: self.ticks,
});
true
}
/// Ends a claimed use: the button came up, the player switched slots,
/// or a screen opened. False when none was going.
pub(super) fn stop_mod_use(&mut self) -> bool {
let Some(u) = self.mods.using.take() else {
return false;
};
let ticks = self.ticks.saturating_sub(u.since).min(u64::from(u32::MAX)) as u32;
self.mods.mods.use_stop(&u.item, ticks);
true
}
/// Once a tick: a claimed use stops when its item leaves the hand or a
/// screen opens, as vanilla's `releaseUsingItem`.
pub(super) fn tick_mod_use(&mut self) {
let Some(u) = &self.mods.using else {
return;
};
let still = self
.mod_held()
.is_some_and(|h| h.id == u.item.id && h.slot == u.item.slot);
if !still || self.screen != Screen::Playing {
self.stop_mod_use();
}
}
/// A key went down or up: a mod's registered key while playing (no
/// screen) is its `key-down` / `key-up`. Vanilla's mapping on the same
/// key still runs.
pub(super) fn mod_key(&mut self, key: KeyCode, pressed: bool, repeat: bool) {
if repeat || !self.mods.mods.has_keys() {
return;
}
if pressed && (self.screen != Screen::Playing || self.title.is_some()) {
return;
}
if let Some(name) = horizon_client::keybinds::key_name(key) {
self.mods.mods.key(name, pressed);
}
}
}
@@ -0,0 +1,176 @@
//! Capability `render` (docs/mods.md): the shapes mods keep on the HUD,
//! drawn by the game's own HUD renderer, and their camera shakes. Mods
//! never supply shader code. With no mod drawing, each hook here returns
//! after one check.
use super::Game;
use horizon_client::hud::HudBatch;
#[cfg(feature = "mods")]
use {
horizon_client::{hud::rgba, items::ItemStack, text::Text},
horizon_mods::Shape,
std::time::Instant,
};
/// The camera's jolts from `render.shake`, while any is fading.
#[cfg(feature = "mods")]
#[derive(Default)]
pub(super) struct Shake {
jolts: Vec<Jolt>,
}
#[cfg(feature = "mods")]
struct Jolt {
start: Instant,
strength: f32,
seconds: f32,
}
/// The HUD batch's colour (ABGR) from a mod's 0xAARRGGBB.
#[cfg(feature = "mods")]
fn argb(color: u32) -> u32 {
let [a, r, g, b] = color.to_be_bytes();
rgba(r, g, b, a)
}
/// The view's turn at full strength, in degrees: yaw, then pitch.
#[cfg(feature = "mods")]
const SHAKE_DEGREES: (f32, f32) = (3.0, 2.0);
#[cfg(feature = "mods")]
impl Shake {
pub(super) fn add(&mut self, strength: f32, seconds: f32) {
self.jolts.push(Jolt {
start: Instant::now(),
strength,
seconds,
});
}
/// How far the view turns now (yaw, pitch degrees), `scale` being the
/// player's Distortion Effects; fades jolts out and forgets ended ones.
fn offset(&mut self, now: Instant, scale: f32) -> (f32, f32) {
self.jolts
.retain(|j| now.duration_since(j.start).as_secs_f32() < j.seconds);
let mut strength = 0.0;
for j in &self.jolts {
let left = 1.0 - now.duration_since(j.start).as_secs_f32() / j.seconds;
strength += j.strength * left * left;
}
let strength = strength.min(1.0) * scale.clamp(0.0, 1.0);
if strength <= 0.0 {
return (0.0, 0.0);
}
// Smooth noise: sines at unrelated rates, so it never repeats visibly.
let t = self
.jolts
.first()
.map_or(0.0, |j| now.duration_since(j.start).as_secs_f32());
let wave = |a: f32, b: f32, c: f32| {
((t * a).sin() * 0.5 + (t * b).sin() * 0.3 + (t * c).sin() * 0.2).clamp(-1.0, 1.0)
};
(
strength * SHAKE_DEGREES.0 * wave(23.0, 37.3, 51.7),
strength * SHAKE_DEGREES.1 * wave(29.1, 43.9, 61.3),
)
}
}
#[cfg(not(feature = "mods"))]
impl Game<'_> {
pub(super) fn draw_mod_shapes(&self, _batch: &mut HudBatch) {}
pub(super) fn shaken_view(&mut self, yaw: f32, pitch: f32) -> (f32, f32) {
(yaw, pitch)
}
}
#[cfg(feature = "mods")]
impl Game<'_> {
/// The running mods' HUD shapes, in order, over the HUD.
pub(super) fn draw_mod_shapes(&self, batch: &mut HudBatch) {
let atlas = &self.gui.atlas;
for shape in self.mods.mods.hud_shapes() {
match shape {
Shape::Fill(f) => {
let r = f.rect;
batch.fill(atlas, r.x, r.y, r.w, r.h, argb(f.color));
}
Shape::Quad(q) => {
let (a, b, c, d) = q.corners;
let corners = [[a.x, a.y], [b.x, b.y], [c.x, c.y], [d.x, d.y]];
batch.fill_quad(atlas, corners, argb(q.color));
}
Shape::Sprite(s) => {
let r = s.rect;
let name = s.sprite.strip_prefix("minecraft:").unwrap_or(&s.sprite);
let name = format!("gui/sprites/{name}");
batch.sprite_scaled(atlas, &name, r.x, r.y, r.w, r.h, argb(s.color));
}
Shape::Item(i) => {
if self.res.items().get(&i.item).is_none() {
continue;
}
let start = batch.vertices.len();
let stack = ItemStack::new(i.item.as_str(), 1);
self.draw_item_model(batch, &stack, i.at.x, i.at.y);
batch.scale_since(start, i.at.x, i.at.y, i.scale, i.scale);
}
Shape::Text(t) => {
let text = Text::literal(t.text.clone());
let x = if t.centered {
t.at.x - (HudBatch::text_width(atlas, &t.text) / 2.0).floor()
} else {
t.at.x
};
batch.text_styled(
atlas,
&text,
x,
t.at.y,
argb(t.color | 0xFF00_0000),
t.shadow,
);
}
}
}
}
/// The view's yaw and pitch after the mods' camera shakes; unchanged
/// while none is fading.
pub(super) fn shaken_view(&mut self, yaw: f32, pitch: f32) -> (f32, f32) {
if self.mods.shake.jolts.is_empty() {
return (yaw, pitch);
}
let scale = self.settings.file.double("screenEffectScale") as f32;
let (dy, dp) = self.mods.shake.offset(Instant::now(), scale);
(yaw + dy, (pitch + dp).clamp(-90.0, 90.0))
}
}
#[cfg(all(test, feature = "mods"))]
mod tests {
use super::*;
use std::time::Duration;
#[test]
fn a_jolt_fades_out_and_distortion_scales_it() {
let mut shake = Shake::default();
shake.add(1.0, 2.0);
let start = shake.jolts[0].start;
let at = |s: f32| start + Duration::from_secs_f32(s);
let size = |(y, p): (f32, f32)| y.abs() + p.abs();
// Off with Distortion Effects at 0, inside the limits otherwise.
assert_eq!(shake.offset(at(0.3), 0.0), (0.0, 0.0));
let (y, p) = shake.offset(at(0.3), 1.0);
assert!(y.abs() <= SHAKE_DEGREES.0 && p.abs() <= SHAKE_DEGREES.1);
// Fading: the largest turn over a window shrinks.
let mut peak = |from: f32| {
(0..50)
.map(|i| size(shake.offset(at(from + i as f32 * 0.002), 1.0)))
.fold(0.0, f32::max)
};
let early = peak(0.1);
let late = peak(1.6);
assert!(late < early, "{late} !< {early}");
// Gone once it ends.
assert_eq!(shake.offset(at(2.1), 1.0), (0.0, 0.0));
assert!(shake.jolts.is_empty());
}
}
+62 -45
View File
@@ -33,7 +33,13 @@ use {
#[derive(Default)]
pub(super) struct ModsState {
#[cfg(feature = "mods")]
mods: Mods,
pub(super) mods: Mods,
/// Capability `input`: a claimed item's use while the button is down.
#[cfg(feature = "mods")]
pub(super) using: Option<super::mod_input::ModUse>,
/// Capability `render`'s camera shakes.
#[cfg(feature = "mods")]
pub(super) shake: super::mod_render::Shake,
/// `--dev-mod PATH`: always on, reloaded when rebuilt.
pub(super) dev: Vec<PathBuf>,
/// When dev mods were last checked for a rebuild.
@@ -338,7 +344,12 @@ impl Game<'_> {
game_time: self.world.game_time.max(0) as u64,
day_time: self.world.day_time.max(0) as u64,
});
Snapshot { player, clock }
Snapshot {
player,
clock,
gui_size: self.gui_size(),
held: self.mod_held(),
}
}
/// A game tick.
pub(super) fn tick_mods(&mut self) {
@@ -350,6 +361,7 @@ impl Game<'_> {
if !self.mods.mods.is_running() {
return;
}
self.tick_mod_use();
let snapshot = self.mod_snapshot();
self.mods.mods.set_snapshot(snapshot);
self.mods.mods.tick(self.ticks);
@@ -430,6 +442,10 @@ impl Game<'_> {
self.open_mod_screen(owner, false);
continue;
}
Output::Shake { strength, seconds } => {
self.mods.shake.add(strength, seconds);
continue;
}
Output::CloseScreen { owner } => {
if self.mods.screen.as_ref().is_some_and(|s| s.owner == owner) {
self.close_mod_screen(false);
@@ -473,30 +489,28 @@ impl Game<'_> {
}
/// A `ui` screen's title and widgets as the mod last pushed them; None
/// when the surface is gone (the mod stopped or closed it).
fn mod_ui_view(&self) -> Option<(String, Vec<UiWidget>)> {
let ms = self.mods.screen.as_ref()?;
/// when the surface is gone (the mod stopped or closed it). Borrows
/// `mods` only, so `self.mods.screen` may stay borrowed for the scrolls.
fn mod_ui_view<'a>(mods: &'a Mods, ms: &ModScreen) -> Option<(&'a str, &'a [UiWidget])> {
if ms.settings {
let widgets = self.mods.mods.settings_widgets(ms.owner);
let widgets = mods.settings_widgets(ms.owner);
if widgets.is_empty() {
return None;
}
let name = self
.mods
.mods
let name = mods
.entries()
.get(ms.owner)
.and_then(|e| e.manifest.as_ref())
.map_or("Mod", |m| m.name.as_str());
Some((name.to_string(), widgets.to_vec()))
Some((name, widgets))
} else {
let s: &UiScreen = self.mods.mods.screen(ms.owner)?;
Some((s.title.clone(), s.widgets.clone()))
let s: &UiScreen = mods.screen(ms.owner)?;
Some((s.title.as_str(), s.widgets.as_slice()))
}
}
/// The layout the mod screen's widgets get at `h`: (widget, top,
/// height), the column being `COLUMN` wide down the middle.
fn mod_ui_layout(&self, h: f32, widgets: &[UiWidget]) -> Vec<(f32, f32)> {
fn mod_ui_layout(h: f32, widgets: &[UiWidget]) -> Vec<(f32, f32)> {
let mut out = Vec::with_capacity(widgets.len());
let mut y = MOD_UI_TOP;
for w in widgets {
@@ -561,13 +575,19 @@ impl Game<'_> {
/// The mod's screen or settings page: its title over widgets stacked
/// down the middle, a Done button, Esc to leave (vanilla's menus).
pub(super) fn draw_mod_screen(&mut self, batch: &mut HudBatch) {
if self.mods.screen.is_none() {
let Some(ms) = self.mods.screen.as_mut() else {
// The screen was dropped while it was up: back to the world,
// mouse held again like any return to Playing.
self.screen = Screen::Playing;
if self.player.is_some() {
self.capture(true);
}
return;
}
let Some((title, widgets)) = self.mod_ui_view() else {
self.mods.screen = None;
self.screen = Screen::Playing;
};
let Some((title, widgets)) = Self::mod_ui_view(&self.mods.mods, ms) else {
// The mod's surface is gone (it stopped or cleared it): leave
// the screen like Done did, without `closed` — the mod ended it.
self.close_mod_screen(false);
return;
};
// Item icons draw in a second pass: `draw_item` needs `&mut self`,
@@ -587,7 +607,7 @@ impl Game<'_> {
);
let cx = (batch.width / 2.0).floor();
let x = cx - MOD_UI_COLUMN / 2.0;
let layout = self.mod_ui_layout(batch.height, &widgets);
let layout = Self::mod_ui_layout(batch.height, widgets);
let mut list_i = 0usize;
for (w, &(wy, wh)) in widgets.iter().zip(&layout) {
match w {
@@ -628,11 +648,8 @@ impl Game<'_> {
);
}
UiWidget::List(l) => {
let scroll = {
let ms = self.mods.screen.as_mut().expect("checked");
ms.scrolls.resize_with(list_i + 1, ui::Scroll::default);
ms.scrolls[list_i]
};
ms.scrolls.resize_with(list_i + 1, ui::Scroll::default);
let scroll = ms.scrolls[list_i];
list_i += 1;
let rows_top = wy + 4.0;
let rows_bottom = wy + wh - 4.0;
@@ -703,53 +720,53 @@ impl Game<'_> {
self.close_mod_screen(true);
return;
}
let Some((_, widgets)) = self.mod_ui_view() else {
let Some(ms) = self.mods.screen.as_ref() else {
return;
};
let Some((_, widgets)) = Self::mod_ui_view(&self.mods.mods, ms) else {
return;
};
let owner = ms.owner;
let x = (w / 2.0).floor() - MOD_UI_COLUMN / 2.0;
let layout = self.mod_ui_layout(h, &widgets);
let layout = Self::mod_ui_layout(h, widgets);
let mut list_i = 0usize;
// The `ui_select` call needs `&mut`: find the pick first.
let mut hit = None;
for (w, &(wy, wh)) in widgets.iter().zip(&layout) {
let UiWidget::List(l) = w else { continue };
let scroll = self
.mods
.screen
.as_ref()
.and_then(|ms| ms.scrolls.get(list_i).copied())
.unwrap_or_default();
let scroll = ms.scrolls.get(list_i).copied().unwrap_or_default();
list_i += 1;
let row = ((cursor.1 - (wy + 4.0) + scroll.amount) / 12.0) as i64;
if ui::hovered(cursor, x + 1.0, wy + 1.0, MOD_UI_COLUMN - 7.0, wh - 2.0)
&& row >= 0
&& (row as usize) < l.rows.len()
{
self.audio.play_button_click();
self.mods.mods.ui_select(
self.mods.screen.as_ref().map_or(0, |ms| ms.owner),
l.id,
row as u32,
);
self.show_mod_output();
return;
hit = Some((l.id, row as u32));
break;
}
}
if let Some((id, row)) = hit {
self.audio.play_button_click();
self.mods.mods.ui_select(owner, id, row);
self.show_mod_output();
}
}
/// The wheel over a `list` scrolls it.
pub(super) fn mod_screen_scroll(&mut self, delta: f32) {
let (w, h) = self.gui_size();
let cursor = self.cursor;
let Some((_, widgets)) = self.mod_ui_view() else {
let Some(ms) = self.mods.screen.as_mut() else {
return;
};
let Some((_, widgets)) = Self::mod_ui_view(&self.mods.mods, ms) else {
return;
};
let x = (w / 2.0).floor() - MOD_UI_COLUMN / 2.0;
let layout = self.mod_ui_layout(h, &widgets);
let layout = Self::mod_ui_layout(h, widgets);
let mut list_i = 0usize;
for (w, &(wy, wh)) in widgets.iter().zip(&layout) {
let UiWidget::List(l) = w else { continue };
let over = ui::hovered(cursor, x, wy, MOD_UI_COLUMN, wh);
let Some(ms) = self.mods.screen.as_mut() else {
return;
};
ms.scrolls.resize_with(list_i + 1, ui::Scroll::default);
if over {
let content = l.rows.len() as f32 * 12.0;
+40
View File
@@ -240,6 +240,42 @@ impl Game<'_> {
discrete: false,
});
}
// ItemFrameRenderer.shouldShowName/getNameTag: only the targeted
// frame's custom-named item, with the HUD visible (also glow frames).
if !self.ui.hide_gui
&& let Some((i, distance)) = self.frame_hit()
&& self.before_block(distance)
&& self.mob_hit().is_none_or(|(_, d)| d > distance)
&& let Some(name) = self.item_frames[i]
.item
.as_ref()
.and_then(|item| item.custom_name())
{
let frame = &self.item_frames[i];
let (lo, hi) = frame.bounds();
let center = glam::DVec3::from_array(std::array::from_fn(|a| (lo[a] + hi[a]) / 2.0));
if center.distance_squared(camera) < 64.0 * 64.0 {
// NAME_TAG is at the entity height (0.5), then the name
// submitter lifts it 0.5. ItemFrameRenderer offsets rendering
// 0.3 toward its facing and -0.25 vertically.
let step = frame.step();
tags.push(NameTag {
at: center
+ glam::DVec3::new(
f64::from(step[0] as f32 * 0.3),
0.75,
f64::from(step[2] as f32 * 0.3),
),
lines: vec![(Text::literal(name).resolve_legacy(), 0.0)],
light: self.world.light(
center.x.floor() as i32,
center.y.floor() as i32,
center.z.floor() as i32,
),
discrete: false,
});
}
}
tags
}
/// `SubmitNodeCollection.submitNameTag`: a discrete name is drawn once,
@@ -257,12 +293,16 @@ impl Game<'_> {
const FADED: u32 = 0x7F;
for tag in self.name_tags(camera, alpha) {
let o = tag.at - camera;
// `gbuffers_entities` draws name tag text (2.3); a sneaking player's faded tag, on its
// background, blends.
if tag.discrete {
self.mark_translucent_entity(out.len(), "minecraft:name_tag");
self.name_tag_quads(o, &tag.lines, FADED, true, 0, vertex_light(tag.light), out);
continue;
}
// LightCoordsUtil.lightCoordsWithEmission(lightCoords, 2).
let lit = (tag.light >> 4).max(2) << 4 | (tag.light & 15).max(2);
self.mark_entity(out.len(), "minecraft:name_tag");
self.name_tag_quads(o, &tag.lines, 0xFF, false, 0, vertex_light(lit), out);
// RenderPipelines.TEXT_SEE_THROUGH: no depth test, no lightmap.
self.name_tag_quads(o, &tag.lines, FADED, true, 2, 0, see_through);
+6
View File
@@ -142,6 +142,8 @@ impl Game<'_> {
}
let server = &self.server_packs.active;
let root = startup_root(&vanilla, &self.settings.resource_packs, server)?;
let root =
super::mods::content_root(&root, &self.settings.mods.enabled, &self.options.dev_mods);
self.reload_resources(&root)
}
fn reload_resources(&mut self, root: &Path) -> horizon_client::Result<()> {
@@ -192,6 +194,10 @@ impl Game<'_> {
let context = pack.context.clone();
self.pack = pack;
self.gui = gui;
// The atlas's sprites moved: the particle engine re-reads every rect
// and the packs' sprite sets, or every particle draws a stale region.
self.particles
.reload(root, &self.gui.atlas.sprites, &self.gui.atlas.translucent);
horizon_client::ui_theme::reset_atlas();
// Villager hats come from the pack's texture metadata (shared data, swapped in place).
*self
+12 -5
View File
@@ -718,17 +718,24 @@ impl Game<'_> {
})
};
// The ticking ones in the index's order, with whether the chunks
// around them tick too.
// around them tick too. Most sensors and catalysts wait for a
// vibration or a death: their tick would change nothing, so they
// are passed over here (a vibration scheduled during these ticks is
// chosen on the next tick at the earliest, as in vanilla).
let entities = &self.world.block_entities;
let due: Vec<((i32, i32, i32), bool)> = self
.sculk
.index
.iter()
.filter_map(|&key| {
let (cx, cz) = (key.0 >> 4, key.2 >> 4);
ticks(cx, cz).then(|| {
let adjacent = (-1..=1).all(|dx| (-1..=1).all(|dz| ticks(cx + dx, cz + dz)));
(key, adjacent)
})
if !ticks(cx, cz)
|| matches!(entities.get(&key), Some(BlockEntity::Sculk(e)) if e.idle())
{
return None;
}
let adjacent = (-1..=1).all(|dx| (-1..=1).all(|dz| ticks(cx + dx, cz + dz)));
Some((key, adjacent))
})
.collect();
for (key, adjacent) in due {
+259 -4
View File
@@ -4,9 +4,30 @@
use horizon_client::camera::CameraFluid;
use horizon_client::gfx::pack_uniforms::PackInputs;
use horizon_shaders::{Macros, Pack, Properties, dimension_folder, load_post};
use horizon_shaders::{BlockIds, Macros, Pack, Properties, dimension_folder, load_post};
use super::{Dim, Game};
use horizon_client::gfx::pack_draw::EntitySpan;
use std::cell::RefCell;
use std::collections::HashMap;
/// The ids a pack gives entities and block entities (4.1, 5.3), for the spans of the entity
/// geometry.
pub(super) struct PackIds {
entities: HashMap<String, i32>,
blocks: BlockIds,
/// `blockEntityId` by block state, filled as states are drawn.
block_states: RefCell<HashMap<u32, i32>>,
/// The id of a name the file lacks: 65535, or 0 without the file.
missing_entity: i32,
missing_block: i32,
/// `item.properties` (4.1) and the id of a held item the file lacks, or of an empty hand:
/// −1, or 0 without the file (5.3).
items: HashMap<String, i32>,
missing_item: i32,
/// `oldHandLight` (3.2): the first held item and light are those of the brighter hand.
old_hand_light: bool,
}
impl Game<'_> {
/// Loads the pack for the current dimension when it changed, and returns this frame's
@@ -42,8 +63,49 @@ impl Game<'_> {
);
}
let folder = dimension_folder(&pack, dimension);
let post = load_post(&pack, &folder, &properties, &macros, None);
if let Some((programs, notes)) = renderer.set_shader_pack(dimension, Some(post))
let inputs = renderer.pack_inputs();
let mut post = load_post(&pack, &folder, &properties, &macros, &inputs);
let biomes = self.res.biomes();
let names: Vec<&str> = biomes.list.iter().map(|b| b.name.as_str()).collect();
post.custom.set_biomes(&names);
let text = pack.read_text("block.properties").unwrap_or_default();
let ids = BlockIds::parse(&Properties::parse(&text, &macros));
for note in &ids.notes {
log::warn!("shader pack {name}: block.properties: {note}");
}
let text = pack.read_text("entity.properties");
let entities = BlockIds::parse_kind(
&Properties::parse(text.as_deref().unwrap_or_default(), &macros),
"entity",
);
let text = pack.read_text("item.properties");
let items = BlockIds::parse_kind(
&Properties::parse(text.as_deref().unwrap_or_default(), &macros),
"item",
);
self.pack_ids = Some(PackIds {
items: items.plain(),
missing_item: if text.is_some() { -1 } else { 0 },
// OQ-21: on unless the pack turns it off.
old_hand_light: properties
.get("oldHandLight")
.is_none_or(|v| v.trim() != "false"),
entities: entities.plain(),
missing_entity: if text.is_some() { 65535 } else { 0 },
missing_block: if ids.is_empty() { 0 } else { 65535 },
blocks: ids.clone(),
block_states: RefCell::default(),
});
let started_ids = std::time::Instant::now();
let table = block_id_table(&self.pack, &ids);
log::info!(
"shader pack {name}: mc_Entity for {} of {} block sprites in {} ms",
table.chunks(2).filter(|p| p[0] != -1).count(),
table.len() / 2,
started_ids.elapsed().as_millis()
);
if let Some((programs, notes)) =
renderer.set_shader_pack(dimension, Some(post), &table)
{
for note in notes {
log::warn!("shader pack {name}: {note}");
@@ -57,14 +119,22 @@ impl Game<'_> {
}
}
Err(e) => {
self.pack_ids = None;
log::warn!("shader pack {name}: {e}");
renderer.set_shader_pack(dimension, None);
renderer.set_shader_pack(dimension, None, &[]);
}
}
}
let lerp = |(old, new): (f32, f32)| old + (new - old) * partial;
let at = camera.floor().as_ivec3();
let light = self.world.light(at.x, at.y, at.z);
let biome = self
.world
.chunks
.get(&(at.x >> 4, at.z >> 4))
.map(|c| c.biome(at.x, at.y, at.z));
let (held_items, held_light) = self.held_for_pack();
let info = biome.map(|b| self.res.biomes().get(b));
PackInputs {
day_time: self.world.day_time,
rain: lerp(self.world.weather.rain_level),
@@ -79,6 +149,191 @@ impl Game<'_> {
eye_light: [i32::from(light & 15), i32::from(light >> 4)],
hide_gui: self.ui.hide_gui,
brightness: self.settings.gamma,
biome: biome.map_or(-1, i32::from),
biome_category: info.map_or(0, |b| horizon_shaders::biome_category(&b.name)),
biome_precipitation: info.map_or(0, |b| {
horizon_shaders::biome_precipitation(b.precipitation, b.temperature)
}),
temperature: info.map_or(0.0, |b| b.temperature),
rainfall: info.map_or(0.0, |b| b.downfall),
held_items,
held_light,
}
}
/// `heldItemId(2)` and `heldBlockLightValue(2)`: main hand, then off hand (5.2, 5.3).
fn held_for_pack(&mut self) -> ([i32; 2], [i32; 2]) {
if self.pack_ids.is_none() {
return ([0; 2], [0; 2]);
}
if self.luminance.is_none() {
self.luminance = Some(horizon_client::dynamic_light::Luminance::new(
self.res.facts(),
self.pack.assets.registry,
));
}
let (Some(ids), Some(lum)) = (&self.pack_ids, &self.luminance) else {
return ([0; 2], [0; 2]);
};
let hands = [self.selected, super::shield::OFFHAND_SLOT].map(|slot| {
let item = self.stack_in(slot).map(|s| &*s.item);
let id = item.and_then(|i| ids.items.get(i).copied());
(
id.unwrap_or(ids.missing_item),
item.map_or(0, |i| i32::from(lum.of(i))),
)
});
let first = if ids.old_hand_light && hands[1].1 > hands[0].1 {
hands[1]
} else {
hands[0]
};
([first.0, hands[1].0], [first.1, hands[1].1])
}
}
impl Game<'_> {
/// Starts a span of the entity geometry at vertex `start` for entity type `name`
/// (`minecraft:zombie`; "" for one the pack cannot name). Nothing without a pack.
pub(super) fn mark_entity(&self, start: usize, name: &str) {
self.mark_entity_part(start, name, false);
}
/// Starts a span for entity geometry that blends (name tags, shadows).
pub(super) fn mark_translucent_entity(&self, start: usize, name: &str) {
self.mark_entity_part(start, name, true);
}
fn mark_entity_part(&self, start: usize, name: &str, translucent: bool) {
if let Some(ids) = &self.pack_ids {
let id = ids.entities.get(name).copied();
self.push_span(start, "ENTITIES", id.unwrap_or(ids.missing_entity));
if let Some(last) = self.entity_spans.borrow_mut().last_mut() {
last.translucent = translucent;
}
}
}
/// Starts a span for the block entity of block state `state`.
pub(super) fn mark_block_entity(&self, start: usize, state: u32) {
let Some(ids) = &self.pack_ids else { return };
let id = *ids
.block_states
.borrow_mut()
.entry(state)
.or_insert_with(|| {
let registry = self.pack.assets.registry;
registry
.state(horizon_world::registry::BlockStateId(state))
.and_then(|s| {
ids.blocks
.id(&s.name, |k| s.properties.get(k).map(String::as_str))
})
.unwrap_or(ids.missing_block)
});
self.push_span(start, "BLOCK_ENTITIES", id);
}
/// Starts a span of geometry that is not an entity (`PARTICLES`, `DESTROY`...).
pub(super) fn mark_stage(&self, start: usize, stage: &str) {
if self.pack_ids.is_some() {
self.push_span(start, stage, 0);
}
}
fn push_span(&self, start: usize, stage: &str, id: i32) {
let mut spans = self.entity_spans.borrow_mut();
let span = EntitySpan {
start: start as u32,
stage: horizon_shaders::render_stage(stage),
id,
translucent: false,
};
// A span that drew nothing gives way to the next.
match spans.last_mut() {
Some(last) if last.start == span.start => *last = span,
_ => spans.push(span),
}
}
}
/// `mc_Entity` (x, y) of each block sprite layer, as (id, fluid) pairs: terrain vertices carry
/// their sprite layer, not their block. A layer takes the id of the block named like its sprite
/// (`block/oak_leaves` for `oak_leaves`), else the id most blocks drawing it share (ties: the
/// lowest); -1 when no block drawing it has one. y is 1 for the fluid sprites, -1 otherwise.
fn block_id_table(pack: &super::PackResources, ids: &BlockIds) -> Vec<i32> {
use std::collections::{BTreeMap, BTreeSet};
let layers = pack
.render
.sprite_layers
.values()
.max()
.map_or(0, |l| l + 1) as usize;
let mut table = vec![-1; layers * 2];
if ids.is_empty() {
return table;
}
let registry = pack.assets.registry;
let catalog = &pack.render.model_catalog;
let sprite = |name: &str| pack.render.sprite_layers.get(name).copied();
// (layer, id) -> (a block named like the sprite, the blocks).
let mut votes: BTreeMap<(u32, i32), (bool, BTreeSet<&str>)> = BTreeMap::new();
for i in 0..registry.len() {
let state_id = horizon_world::registry::BlockStateId(i as u32);
let Some(state) = registry.state(state_id) else {
continue;
};
let Some(id) = ids.id(&state.name, |k| state.properties.get(k).map(String::as_str)) else {
continue;
};
let block = state.name.strip_prefix("minecraft:").unwrap_or(&state.name);
let mut vote = |layer: u32| {
let named = pack
.layer_names
.get(&layer)
.and_then(|n| n.strip_prefix("block/"))
== Some(block);
let v = votes.entry((layer, id)).or_default();
v.0 |= named;
v.1.insert(&state.name);
};
// Fluids draw from their own sprites.
let fluid = match block {
"water" => ["water_still", "water_flow"],
"lava" => ["lava_still", "lava_flow"],
_ => ["", ""],
};
for f in fluid.iter().filter(|f| !f.is_empty()) {
if let Some(l) = sprite(&format!("minecraft:block/{f}")) {
vote(l);
}
}
let origin = horizon_core::position::BlockPos::new(0, 0, 0);
for (_, model) in catalog.collect(state_id, origin).unwrap_or_default() {
for face in &model.faces {
vote(face.layer);
}
}
}
let mut best: BTreeMap<u32, (bool, usize, i32)> = BTreeMap::new();
for ((layer, id), (named, blocks)) in votes {
let candidate = (named, blocks.len(), -id);
let b = best.entry(layer).or_insert(candidate);
if candidate > *b {
*b = candidate;
}
}
for (layer, (_, _, id)) in best {
if let Some(slot) = table.get_mut(layer as usize * 2) {
*slot = -id;
}
}
for f in ["water_still", "water_flow", "lava_still", "lava_flow"] {
if let Some(l) = sprite(&format!("minecraft:block/{f}"))
&& let Some(slot) = table.get_mut(l as usize * 2 + 1)
{
*slot = 1;
}
}
table
}
@@ -272,8 +272,6 @@ impl Loading {
}
pub(super) fn apply_menu_settings(&mut self) {
if let Some(renderer) = &mut self.renderer {
self.settings
.clamp_gui_scale([renderer.config.width as i32, renderer.config.height as i32]);
renderer.gamma = self.settings.gamma;
renderer.set_present_mode(self.settings.vsync, self.settings.horizon.present_mode);
}
+51 -9
View File
@@ -158,7 +158,8 @@ const COLUMNS: [(&str, &str); 6] = [
#[derive(Default)]
pub(super) struct StatsUi {
tab: usize,
scroll: f32,
/// The list's scrolling: the wheel and the held scrollbar.
scroll: horizon_client::ui::Scroll,
sort: Option<(usize, i32)>,
}
/// `MenuTabBar` geometry: three tabs over at most 400 pixels.
@@ -182,6 +183,15 @@ impl Game<'_> {
self.stats_ui = StatsUi::default();
self.screen = Screen::Stats;
}
/// The list's scrollbar column (right of the 280 pixel list) and the
/// pixels it scrolls.
fn stats_bar(w: f32) -> f32 {
((w - 280.0) / 2.0).floor() + 280.0 + 6.0
}
fn stats_content(&self) -> f32 {
let (row_h, rows) = self.stats_rows();
row_h * rows as f32 + 4.0
}
fn stats_rows(&self) -> (f32, usize) {
match self.stats_ui.tab {
0 => (14.0, CUSTOM.len()),
@@ -260,10 +270,9 @@ impl Game<'_> {
// The list.
let (row_h, rows) = self.stats_rows();
let content = row_h * rows as f32 + 4.0;
let max_scroll = (content - (bottom - top)).max(0.0);
self.stats_ui.scroll = self.stats_ui.scroll.clamp(0.0, max_scroll);
self.stats_ui.scroll.clamp(top, bottom, content);
let left = ((w - 280.0) / 2.0).floor();
let scroll = self.stats_ui.scroll;
let scroll = self.stats_ui.scroll.amount;
let row_y = |i: usize| top + 4.0 + i as f32 * row_h - scroll;
let visible = |y: f32| y >= top && y + row_h <= bottom;
match self.stats_ui.tab {
@@ -408,11 +417,11 @@ impl Game<'_> {
ui::scrollbar(
batch,
atlas,
left + 280.0 + 6.0,
Self::stats_bar(w),
top,
bottom,
content,
self.stats_ui.scroll,
self.stats_ui.scroll.amount,
);
self.draw_stats_footer(batch, w, h);
}
@@ -433,6 +442,10 @@ impl Game<'_> {
);
}
pub(super) fn stats_click(&mut self, size: [u32; 2]) {
// A press on the scrollbar holds it and clicks nothing else.
if self.stats_press_scrollbar(size) {
return;
}
let b = HudBatch::new(size);
let (w, h) = (b.width, b.height);
let (x0, tw) = tabs(w);
@@ -441,7 +454,7 @@ impl Game<'_> {
&& self.stats_ui.tab != i
{
self.stats_ui.tab = i;
self.stats_ui.scroll = 0.0;
self.stats_ui.scroll.amount = 0.0;
self.audio
.play("minecraft:ui.button.click", None, 0.25, 1.0);
return;
@@ -461,7 +474,7 @@ impl Game<'_> {
}
if self.stats_ui.tab == 1 {
let left = ((w - 280.0) / 2.0).floor();
let y = TAB_H + 4.0 - self.stats_ui.scroll;
let y = TAB_H + 4.0 - self.stats_ui.scroll.amount;
for c in 0..COLUMNS.len() {
let x = left + 75.0 + 40.0 * c as f32 - 18.0;
if ui::hovered(self.cursor, x, y + 1.0, 18.0, 18.0) {
@@ -479,6 +492,35 @@ impl Game<'_> {
}
pub(super) fn stats_scroll(&mut self, amount: f32) {
let (row_h, _) = self.stats_rows();
self.stats_ui.scroll -= amount * row_h / 2.0;
let h = self.gui_size().1;
let content = self.stats_content();
self.stats_ui
.scroll
.wheel(amount, row_h / 2.0, TAB_H, h - FOOTER, content);
}
/// A press on the statistics list's scrollbar holds it
/// (`AbstractSelectionList.updateScrolling`).
pub(super) fn stats_press_scrollbar(&mut self, size: [u32; 2]) -> bool {
let b = HudBatch::new(size);
let (w, h) = (b.width, b.height);
let content = self.stats_content();
self.stats_ui
.scroll
.press(self.cursor, Self::stats_bar(w), TAB_H, h - FOOTER, content)
}
/// The pointer moved while the scrollbar is held.
pub(super) fn stats_drag(&mut self) {
if !self.stats_ui.scroll.held() {
return;
}
let h = self.gui_size().1;
let content = self.stats_content();
self.stats_ui
.scroll
.drag(self.cursor.1, TAB_H, h - FOOTER, content);
}
/// The button came up: the scrollbar lets go.
pub(super) fn stats_release(&mut self) {
self.stats_ui.scroll.release();
}
}
@@ -246,6 +246,9 @@ pub(super) fn make_streaming(
let inner = Arc::new(VanillaTerrain::for_world(&options.resources.join("worldgen"), pack.assets.registry, res.biomes(), seed, dim.id(), structures).map_err(|e| {
format!("{e}\nPrepare the worldgen bundle with the launcher, or: horizon-prepare --prepare")
})?);
if dim == Dim::Overworld && structures {
inner.search_rings_behind();
}
locator = Some(inner.clone());
Streaming::new(
Arc::new(Persistent {
+273 -36
View File
@@ -69,8 +69,14 @@ pub mod lightning;
mod lod;
mod occlusion;
mod pack_atlas;
pub mod pack_draw;
mod pack_entities;
mod pack_hand;
mod pack_post;
mod pack_sky;
mod pack_timing;
pub mod pack_uniforms;
mod pack_weather;
mod page_runs;
pub mod panorama;
mod resident;
@@ -86,6 +92,19 @@ const COMPLETE_COLUMN: u32 = (1 << (crate::chunk::HEIGHT / 16)) - 1;
/// its fixed-point UVs (`terrain.wgsl`'s `terrain_uv`).
/// The world pass again after occlusion culling's test: it loads both
/// targets (phase 2 draws over phase 1, reading the test's results).
/// LevelRenderer: no sky inside lava or powder snow (sky fog ends within 2 blocks).
fn sky_open(frame: &Frame) -> bool {
match frame.fog {
Some(f) => f.sky_end > 2.0,
None => !frame.underwater,
}
}
/// The Overworld-style sky (disc, sunset, stars, void) draws this frame.
fn sky_visible(frame: &Frame) -> bool {
!frame.title && frame.skybox && sky_open(frame)
}
fn world_pass_after_culling<'e>(
encoder: &'e mut wgpu::CommandEncoder,
view: &wgpu::TextureView,
@@ -232,6 +251,8 @@ pub struct Frame<'a> {
pub nether_lighting: bool,
/// Camera-relative entity geometry textured from the shared atlas.
pub entities: &'a [Vertex],
/// Runs of `entities` by entity, while a shader pack draws them (`pack_draw::EntitySpan`).
pub entity_spans: &'a [pack_draw::EntitySpan],
pub weather: &'a [crate::weather::Vertex],
pub weather_time: crate::weather::Time,
/// Horizon Extras' dynamic lights, nearest first (`dynamic_light::select`); empty when off.
@@ -473,8 +494,16 @@ pub struct Renderer {
world_post: world_post::Post,
/// The shader pack's post-processing, and the dimension (legacy id) it was loaded for.
pack_post: Option<(i32, Option<pack_post::PackPost>)>,
/// The entity vertices Horizon draws itself while a shader pack draws the others.
pack_entity_rest: Vec<Vertex>,
/// Set 1 of the cloud pipeline, for a shader pack's `gbuffers_clouds`.
cloud_bindings: wgpu::BindGroupLayout,
/// Rain and snow handed to a shader pack's `gbuffers_weather`, once a pack draws them.
pack_weather: Option<pack_weather::PackWeather>,
/// The block sprites as one atlas, while a shader pack is loaded.
pack_atlas: Option<pack_atlas::PackAtlas>,
/// The pack's terrain program reads flat draws' vertices (`pack_terrain_inputs`).
pack_terrain_flat: bool,
pub hud: HudRenderer,
/// Vanilla's menu background blur, made on first use.
menu_blur: Option<crate::menu_blur::MenuBlur>,
@@ -842,12 +871,17 @@ async fn open_device(
continue;
}
// Mappable primary buffers: section pages that no longer fit in
// video memory go to system memory.
// video memory go to system memory. Shader packs' 16-bit normalized buffers (render
// targets with the adapter's own format features) and R11F_G11F_B10F: a float
// stand-in neither clamps nor drops NaN.
let features = timing::GpuTimer::features(&adapter)
| cull::Cull::features(&adapter)
| (adapter.features()
& (wgpu::Features::INDIRECT_FIRST_INSTANCE
| wgpu::Features::MAPPABLE_PRIMARY_BUFFERS));
| wgpu::Features::MAPPABLE_PRIMARY_BUFFERS
| wgpu::Features::TEXTURE_FORMAT_16BIT_NORM
| wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES
| wgpu::Features::RG11B10UFLOAT_RENDERABLE));
let driver = format!("{} {}", info.driver, info.driver_info);
startup_step(format_args!(
"requesting the device (driver {}) with features [{features}] and the adapter's \
@@ -1484,7 +1518,10 @@ impl Renderer {
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8Unorm,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
// COPY_SRC: a shader pack's weather copies the rain and snow sprites out.
usage: wgpu::TextureUsages::TEXTURE_BINDING
| wgpu::TextureUsages::COPY_DST
| wgpu::TextureUsages::COPY_SRC,
view_formats: &[],
},
wgpu::util::TextureDataOrder::LayerMajor,
@@ -2149,13 +2186,16 @@ impl Renderer {
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let flat_wanted = flat::wanted(&adapter, &device);
// Readable as storage where flat draws run: a shader pack's terrain program reads them.
let arena = arena::Arena::new(
&device,
std::mem::size_of::<TerrainVertex>() as u64,
1 << 20,
flat_wanted,
);
// Sections as one index list per frame where multi-draw is emulated.
let flat = flat::wanted(&adapter, &device).then(|| {
let flat = flat_wanted.then(|| {
let buffers = [Some(wgpu::VertexBufferLayout {
array_stride: std::mem::size_of::<TerrainVertex>() as u64,
step_mode: wgpu::VertexStepMode::Vertex,
@@ -2362,7 +2402,11 @@ impl Renderer {
occlusion: occlusion::Occlusion::new(crate::chunk::MIN_Y, crate::chunk::HEIGHT / 16),
world_post,
pack_post: None,
pack_entity_rest: Vec::new(),
cloud_bindings,
pack_weather: None,
pack_atlas: None,
pack_terrain_flat: false,
hud,
menu_blur: None,
info,
@@ -2793,24 +2837,84 @@ impl Renderer {
self.world_post.scale = scale.clamp(0.25, 2.0);
self.world_post.antialias = antialias;
}
/// Runs `post` over the world from now on (`None`: no pack), for the dimension `dimension`.
/// Runs `post` over the world from now on (`None`: no pack), for the dimension `dimension`;
/// `block_ids` gives each block sprite layer's `mc_Entity` (id, fluid) pair.
/// Returns the programs that run and the notes of loading them.
pub fn set_shader_pack(
&mut self,
dimension: i32,
pack: Option<horizon_shaders::Post>,
block_ids: &[i32],
) -> Option<(Vec<String>, Vec<String>)> {
if pack.is_none() {
self.pack_atlas = None;
}
let instance = wgpu::vertex_attr_array![5=>Float32x4];
let vertex = wgpu::VertexBufferLayout {
array_stride: std::mem::size_of::<TerrainVertex>() as u64,
step_mode: wgpu::VertexStepMode::Vertex,
attributes: &TERRAIN_ATTRIBUTES,
};
let instances = wgpu::VertexBufferLayout {
array_stride: 16,
step_mode: wgpu::VertexStepMode::Instance,
attributes: &instance,
};
let buffers = [Some(vertex), Some(instances)];
let flat = self.pack_terrain_flat;
let post = pack.map(|post| {
let world = pack_post::World {
atlas: self.pack_atlas.as_ref().map(|a| (a.view.clone(), a.size())),
lightmap: self.lightmap_view.clone(),
terrain: self.pack_atlas.as_ref().map(|_| pack_post::Geometry {
buffers: if flat { &buffers[..1] } else { &buffers },
table: self.flat.as_ref().filter(|_| flat).map(|f| &f.draw_layout),
depth_write: true,
atlas: None,
ids: None,
cull: true,
}),
block_ids,
celestial: self
.hud
.atlas_texture
.as_ref()
.map(|t| t.create_view(&Default::default())),
clouds: Some(&self.cloud_bindings),
weather: true,
hand: true,
};
pack_post::PackPost::new(
&self.device,
&self.queue,
post,
self.config.format.remove_srgb_suffix(),
world,
)
});
if post.is_none() {
self.pack_atlas = None;
} else if self.pack_atlas.is_none() {
let report = post.as_ref().map(|p| {
let programs = p.programs().into_iter().map(str::to_owned).collect();
(programs, p.notes.clone())
});
self.pack_post = Some((dimension, post));
report
}
/// What a shader pack's gbuffers programs read from Horizon's geometry: the sky's, and
/// terrain's in the pack's block atlas (made here when missing; none when it does not fit).
pub fn pack_inputs(&mut self) -> horizon_shaders::GameInputs {
horizon_shaders::GameInputs {
terrain: self.pack_terrain_inputs(),
sky: Some(pack_sky::inputs()),
celestial: Some(pack_sky::celestial_inputs()),
entities: Some(pack_entities::inputs()),
clouds: Some(pack_entities::cloud_inputs()),
weather: Some(pack_weather::inputs()),
hand: Some(pack_hand::inputs()),
}
}
fn pack_terrain_inputs(&mut self) -> Option<horizon_shaders::GbuffersInputs> {
if self.pack_atlas.is_none() {
let mut encoder = self.device.create_command_encoder(&Default::default());
let layers = self
.sprite_textures
@@ -2827,12 +2931,13 @@ impl Renderer {
);
self.queue.submit([encoder.finish()]);
}
let report = post.as_ref().map(|p| {
let programs = p.programs().into_iter().map(str::to_owned).collect();
(programs, p.notes.clone())
});
self.pack_post = Some((dimension, post));
report
// Flat draws whenever the device has them (`render` keeps them on with a pack).
self.pack_terrain_flat = self.flat.is_some() && self.flat_on;
Some(
self.pack_atlas
.as_ref()?
.terrain_inputs(self.pack_terrain_flat),
)
}
/// The dimension the shader pack was last set for.
pub fn shader_pack_dimension(&self) -> Option<i32> {
@@ -3243,11 +3348,23 @@ impl Renderer {
// Occlusion culling leaves the sections its last result did not see
// to phase 2, after the others, with instance counts of 0. Whether
// the frame has draws enough goes by the last one's.
// A shader pack drawing terrain draws all of it: occlusion culling reads the depth of
// Horizon's own terrain draw.
let pack_terrain = !frame.title
&& self
.pack_post
.as_ref()
.and_then(|p| p.1.as_ref())
.is_some_and(|p| p.has_terrain());
let mut cull = self
.cull
.as_mut()
.filter(|c| {
self.cull_on && !frame.title && self.multi_draw && visible.len() >= c.min_sections
self.cull_on
&& !frame.title
&& !pack_terrain
&& self.multi_draw
&& visible.len() >= c.min_sections
})
.and_then(|cull| cull.begin(&self.device).then_some(cull));
self.phase2_draws.clear();
@@ -3472,6 +3589,22 @@ impl Renderer {
self.uploads
.buffer(&mut encoder, &self.outline, 0, bytemuck::cast_slice(&lines));
}
// While a shader pack draws entities, the runs of `entity_spans` its programs draw are
// left out of Horizon's own entity draw.
let mut entities = frame.entities;
if !frame.title
&& let Some((_, Some(post))) = &mut self.pack_post
&& post.has_entities()
{
post.prepare_entities(
&self.device,
&self.queue,
frame.entities,
frame.entity_spans,
&mut self.pack_entity_rest,
);
entities = &self.pack_entity_rest;
}
let [
entity_quads,
crumbling_quads,
@@ -3479,12 +3612,9 @@ impl Renderer {
water_mask_quads,
shadow_quads,
translucent_particle_quads,
] = self.entity_batch.update(
frame.entities,
frame.additive,
frame.hand,
frame.see_through,
);
] = self
.entity_batch
.update(entities, frame.additive, frame.hand, frame.see_through);
let weather_quads = frame.weather.len() as u32 / 4;
let world_quads = entity_quads
+ crumbling_quads
@@ -3653,7 +3783,7 @@ impl Renderer {
Some(flat)
if self.flat_on
&& !self.draws.is_empty()
&& self.drawn_sections >= flat.min_sections =>
&& (self.drawn_sections >= flat.min_sections || pack_terrain) =>
{
let sections = &self.sections;
let lods = &self.lods;
@@ -3713,6 +3843,44 @@ impl Renderer {
}
// The world's targets: the screen, or the scaled target of `post`.
let pack_post = !frame.title && self.pack_post.as_ref().is_some_and(|p| p.1.is_some());
// The pack's program reads the vertices this frame's draws bind.
let pack_draws_terrain = pack_terrain && flat_frame == self.pack_terrain_flat;
let pack_draws_sky = pack_post
&& self
.pack_post
.as_ref()
.and_then(|p| p.1.as_ref())
.is_some_and(|p| p.has_sky());
let pack_draws_celestial = pack_post
&& self
.pack_post
.as_ref()
.and_then(|p| p.1.as_ref())
.is_some_and(|p| p.has_celestial());
let pack_draws_water = pack_draws_terrain
&& self
.pack_post
.as_ref()
.and_then(|p| p.1.as_ref())
.is_some_and(|p| p.has_water());
let pack_draws_clouds = pack_post
&& self
.pack_post
.as_ref()
.and_then(|p| p.1.as_ref())
.is_some_and(|p| p.has_clouds());
let pack_draws_hand = pack_post
&& self
.pack_post
.as_ref()
.and_then(|p| p.1.as_ref())
.is_some_and(|p| p.has_hand());
let pack_draws_weather = pack_post
&& self
.pack_post
.as_ref()
.and_then(|p| p.1.as_ref())
.is_some_and(|p| p.has_weather());
let scaled = self.world_post.prepare(
&self.device,
[self.config.width, self.config.height],
@@ -3766,13 +3934,9 @@ impl Renderer {
..Default::default()
});
pass.set_bind_group(0, &self.group, &[]);
// LevelRenderer: no sky inside lava or powder snow (sky fog ends within 2 blocks).
let sky_visible = match frame.fog {
Some(f) => f.sky_end > 2.0,
None => !frame.underwater,
};
let sky_visible = sky_open(frame);
if frame.title || (sky_visible && (frame.skybox || frame.end_sky)) {
if !frame.title && frame.skybox {
if !frame.title && frame.skybox && !pack_draws_sky {
pass.set_pipeline(&self.sky);
pass.draw(0..3, 0..1);
}
@@ -3786,22 +3950,29 @@ impl Renderer {
if frame.end_sky {
self.end_sky.draw(&mut pass);
}
if celestial_vertices > 0 {
if celestial_vertices > 0 && !pack_draws_celestial {
pass.set_vertex_buffer(0, self.celestial_buffer.slice(..));
pass.draw_indexed(0..(celestial_vertices as u32 / 4) * 6, 0, 0..1);
}
pass.set_bind_group(0, &self.group, &[]);
}
if !frame.title && frame.stars.is_some() {
if !frame.title && frame.stars.is_some() && !pack_draws_sky {
self.stars.draw(&mut pass);
pass.set_bind_group(0, &self.group, &[]);
}
if !frame.title && frame.dark_disc {
if !frame.title && frame.dark_disc && !pack_draws_sky {
pass.set_pipeline(&self.dark_disc);
pass.draw(0..3, 0..1);
}
}
match self.flat.as_ref().filter(|_| flat_frame) {
match self
.flat
.as_ref()
.filter(|_| flat_frame && !pack_draws_terrain)
{
_ if pack_draws_terrain => {
pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
}
Some(flat) => {
pass.set_pipeline(&flat.solid);
let vertices = |p| self.arena.buffer(p);
@@ -3875,7 +4046,9 @@ impl Renderer {
pass.draw_indexed(0..entity_quads * 6, 0, 0..1);
pass.set_bind_group(0, &self.group, &[]);
}
self.weather.draw(&mut pass, &self.entity_group);
if !pack_draws_weather {
self.weather.draw(&mut pass, &self.entity_group);
}
pass.set_bind_group(0, &self.group, &[]);
if crumbling_quads > 0 {
pass.set_pipeline(&self.crumbling_pipeline);
@@ -3937,6 +4110,8 @@ impl Renderer {
pass.draw(0..4, debug_depth..debug_depth + debug_top);
}
match self.flat.as_ref().filter(|_| flat_frame) {
// The pack draws translucent terrain after its deferred programs.
_ if pack_draws_water => {}
Some(flat) => {
pass.set_pipeline(&flat.translucent);
flat.draw(&mut pass, &flat.calls[flat.solid_calls..], |p| {
@@ -4004,7 +4179,7 @@ impl Renderer {
0..1,
);
}
if cloud_quads > 0 {
if cloud_quads > 0 && !pack_draws_clouds {
pass.set_pipeline(&self.cloud_pipeline);
pass.set_bind_group(0, &self.entity_group, &[]);
pass.set_bind_group(1, &self.cloud_group, &[]);
@@ -4025,9 +4200,68 @@ impl Renderer {
}
if let Some((color, depth)) = &scaled
&& pack_post
&& let Some((_, Some(post))) = &mut self.pack_post
&& let Some((dimension, Some(mut post))) = self.pack_post.take()
{
let size = self.world_post.size().unwrap_or([1, 1]);
let weather = match &self.hud.atlas_texture {
Some(atlas) if pack_draws_weather => self
.pack_weather
.get_or_insert_with(|| pack_weather::PackWeather::new(&self.device))
.prepare(
&self.device,
&mut encoder,
&mut self.uploads,
atlas,
frame.weather,
frame.weather_time,
&self.indices,
),
_ => None,
};
post.set_weather(weather);
let flat = self.flat.as_ref().filter(|_| flat_frame);
let pages: Vec<(u32, wgpu::Buffer)> = match flat {
Some(_) if pack_draws_terrain => self
.arena
.page_buffers()
.map(|(p, b)| (p, b.clone()))
.collect(),
_ => Vec::new(),
};
let mut terrain =
|rp: &mut wgpu::RenderPass<'_>,
translucent: bool,
page: &dyn Fn(&mut wgpu::RenderPass<'_>, u32)| {
if !pack_draws_terrain {
return;
}
match flat {
Some(flat) => {
let calls = if translucent {
&flat.calls[flat.solid_calls..]
} else {
&flat.calls[..flat.solid_calls]
};
flat.draw_with(rp, calls, |p| self.arena.buffer(p), page);
}
None => {
rp.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
rp.set_vertex_buffer(1, self.instances.slice(..));
let (first, count) = if translucent {
(solid_draws, translucent_draws)
} else {
(0, solid_draws)
};
self.draw_sections(rp, &self.indirect, 0, first, count);
}
}
};
post.set_clouds(pack_draws_clouds.then(|| pack_post::Clouds {
vertices: self.cloud_buffer.clone(),
group: self.cloud_group.clone(),
indices: self.indices.clone(),
quads: cloud_quads,
}));
post.run(
&self.device,
&self.queue,
@@ -4039,11 +4273,14 @@ impl Renderer {
&frame.pack,
size,
[self.config.width, self.config.height],
&pages,
&mut terrain,
);
self.pack_post = Some((dimension, Some(post)));
} else if scaled.is_some() {
self.world_post.finish(&mut encoder, &view_target);
}
if hand_quads > 0 {
if hand_quads > 0 && !pack_draws_hand {
let attachments = [Some(wgpu::RenderPassColorAttachment {
view: &view_target,
resolve_target: None,
+16 -4
View File
@@ -65,8 +65,15 @@ pub struct Arena {
}
impl Arena {
pub fn new(device: &wgpu::Device, stride: u64, capacity: u64) -> Self {
Self::with_usage(device, stride, capacity, wgpu::BufferUsages::VERTEX)
/// Vertices; `storage` also lets shaders read them as a storage buffer (a shader pack's
/// terrain program reads the other corners of a vertex's quad for its normal).
pub fn new(device: &wgpu::Device, stride: u64, capacity: u64, storage: bool) -> Self {
let usage = if storage {
wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::STORAGE
} else {
wgpu::BufferUsages::VERTEX
};
Self::with_usage(device, stride, capacity, usage)
}
/// Sorted translucent indices; `storage` when compute passes read them.
pub fn indices(device: &wgpu::Device, capacity: u64, storage: bool) -> Self {
@@ -148,6 +155,11 @@ impl Arena {
pub fn has_page(&self, page: u32) -> bool {
self.pages.get(page as usize).is_some_and(Option::is_some)
}
/// Each live page's buffer, by page.
pub fn page_buffers(&self) -> impl Iterator<Item = (u32, &wgpu::Buffer)> {
let pages = self.pages.iter().enumerate();
pages.filter_map(|(i, p)| Some((i as u32, &p.as_ref()?.buffer)))
}
pub fn buffer(&self, page: u32) -> &wgpu::Buffer {
&self.pages[page as usize]
.as_ref()
@@ -352,7 +364,7 @@ mod tests {
eprintln!("no GPU adapter: skipped");
return;
};
let mut arena = Arena::new(&device, 4, GRAIN);
let mut arena = Arena::new(&device, 4, GRAIN, false);
arena.page_limit = 2 * GRAIN;
assert_eq!(arena.bytes(), 0);
let (first, a) = alloc(&mut arena, &device, &queue, GRAIN).unwrap();
@@ -395,7 +407,7 @@ mod tests {
return;
};
for mut arena in [
Arena::new(&device, 28, GRAIN),
Arena::new(&device, 28, GRAIN, false),
Arena::indices(&device, GRAIN, false),
] {
alloc(&mut arena, &device, &queue, GRAIN).unwrap();
+14 -1
View File
@@ -73,7 +73,8 @@ pub struct Flat {
phase2_call_data: Vec<[u32; 5]>,
/// The copy of phase 2's draws, and its ranges.
phase2_group: Option<(wgpu::BindGroup, u32)>,
draw_layout: wgpu::BindGroupLayout,
/// The layout of a page's bind group 1 (shader packs' terrain pipelines share it).
pub(super) draw_layout: wgpu::BindGroupLayout,
blocks_per_page: u64,
pages: Vec<Option<PageTable>>,
free_ids: Vec<u32>,
@@ -650,10 +651,22 @@ impl Flat {
pass: &mut wgpu::RenderPass<'_>,
calls: &[Call],
vertices: impl Fn(u32) -> &'a wgpu::Buffer,
) {
self.draw_with(pass, calls, vertices, |_, _| {});
}
/// `draw`, calling `page` before each run of calls from one arena page (a shader pack binds
/// that page's vertices for reading).
pub fn draw_with<'a>(
&self,
pass: &mut wgpu::RenderPass<'_>,
calls: &[Call],
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 call in calls {
self.bind_page(pass, call.page, &vertices);
page(pass, call.page);
pass.draw_indexed(call.first..call.first + call.count, 0, 0..1);
}
}
+106 -5
View File
@@ -3,7 +3,6 @@
//! layer is copied into a grid, row by row from the top left, and an animated layer again
//! whenever its frame changes.
#[expect(dead_code, reason = "the gbuffers pass binds it (next slice)")]
pub(super) struct PackAtlas {
texture: wgpu::Texture,
pub view: wgpu::TextureView,
@@ -64,10 +63,6 @@ impl PackAtlas {
}
/// The atlas's size in pixels (`atlasSize`).
#[cfg_attr(
not(test),
expect(dead_code, reason = "the gbuffers pass reads it (next slice)")
)]
pub fn size(&self) -> [u32; 2] {
[self.texture.width(), self.texture.height()]
}
@@ -118,6 +113,112 @@ impl PackAtlas {
}
}
/// GLSL: the face normal and tangent of a flat-drawn vertex, from its quad's first three corners
/// (quads are four consecutive vertices of the page; position words 0-2, UV word 3).
const FACE: &str = " uint hz_q = (uint(gl_VertexIndex) & ~3u) * 6u;\n \
vec3 hz_p0 = uintBitsToFloat(uvec3(hz_vertices[hz_q], hz_vertices[hz_q + 1u], hz_vertices[hz_q + 2u]));\n \
vec3 hz_p1 = uintBitsToFloat(uvec3(hz_vertices[hz_q + 6u], hz_vertices[hz_q + 7u], hz_vertices[hz_q + 8u]));\n \
vec3 hz_p2 = uintBitsToFloat(uvec3(hz_vertices[hz_q + 12u], hz_vertices[hz_q + 13u], hz_vertices[hz_q + 14u]));\n \
uvec3 hz_w = uvec3(hz_vertices[hz_q + 3u], hz_vertices[hz_q + 9u], hz_vertices[hz_q + 15u]);\n \
vec2 hz_t0 = vec2(hz_w.x & 65535u, hz_w.x >> 16u);\n \
vec2 hz_d1 = vec2(hz_w.y & 65535u, hz_w.y >> 16u) - hz_t0;\n \
vec2 hz_d2 = vec2(hz_w.z & 65535u, hz_w.z >> 16u) - hz_t0;\n \
vec3 hz_e1 = hz_p1 - hz_p0;\n \
vec3 hz_e2 = hz_p2 - hz_p0;\n \
vec3 hz_n = cross(hz_e1, hz_e2);\n \
if (dot(hz_n, hz_n) > 1e-12) {\n \
hz_Normal = normalize(hz_n);\n \
float hz_r = hz_d1.x * hz_d2.y - hz_d2.x * hz_d1.y;\n \
vec3 hz_t = (hz_e1 * hz_d2.y - hz_e2 * hz_d1.y) * sign(hz_r);\n \
vec3 hz_b = (hz_e2 * hz_d1.x - hz_e1 * hz_d2.x) * sign(hz_r);\n \
if (dot(hz_t, hz_t) > 1e-12) {\n \
hz_t = normalize(hz_t - hz_Normal * dot(hz_Normal, hz_t));\n \
hz_tangent = vec4(hz_t, dot(cross(hz_t, hz_Normal), hz_b) < 0.0 ? -1.0 : 1.0);\n \
}\n \
}\n";
impl PackAtlas {
/// The vertex inputs of a gbuffers program drawing terrain (`TerrainVertex`, terrain.wgsl's
/// `vs_terrain` or, for `flat` draws, `vs_terrain_flat`), in atlas coordinates.
pub fn terrain_inputs(&self, flat: bool) -> horizon_shaders::GbuffersInputs {
let mut declarations = String::from(
"layout(location = 0) in vec3 hz_v_pos;\nlayout(location = 1) in uvec2 hz_v_uv;\n\
layout(location = 2) in uint hz_v_layer;\nlayout(location = 3) in vec4 hz_v_color;\n\
layout(location = 4) in uvec2 hz_v_light;\n",
);
let origin = if flat {
declarations.push_str(
"layout(set = 1, binding = 0) readonly buffer HzBlockSlots { uint hz_block_slots[]; };\n\
layout(set = 1, binding = 1) readonly buffer HzSlotOrigins { vec4 hz_slot_origins[]; };\n",
);
// `mc_Entity` of each sprite layer: id, then 1 for fluids or -1 (the game's table),
// and the arena page's vertices (`TerrainVertex`, six words each).
declarations.push_str(
"layout(set = 3, binding = 0) readonly buffer HzBlockIds { int hz_block_ids[]; };\n\
layout(set = 3, binding = 1) readonly buffer HzVertices { uint hz_vertices[]; };\n",
);
"hz_slot_origins[hz_block_slots[uint(gl_VertexIndex) >> 8u]]"
} else {
declarations.push_str("layout(location = 5) in vec4 hz_v_origin;\n");
"hz_v_origin"
};
let [width, height] = self.size();
let scale = [
self.sprite as f32 / width as f32,
self.sprite as f32 / height as f32,
];
let columns = self.columns;
// UVs past a sprite (models up to 2, distant tiles) cannot repeat in an atlas: clamped.
let body = format!(
" vec4 hz_origin = {origin};\n \
uint hz_layer = hz_v_layer & 32767u;\n \
hz_cell = vec2(float(hz_layer % {columns}u), float(hz_layer / {columns}u));\n \
hz_scale = vec2({:?}, {:?});\n \
hz_Vertex = vec4(hz_v_pos + hz_origin.xyz, 1.0);\n \
hz_MultiTexCoord0 = vec4((hz_cell + clamp(vec2(hz_v_uv) * hz_origin.w, 0.0, 1.0)) * hz_scale, 0.0, 1.0);\n \
hz_MultiTexCoord1 = vec4(float(hz_v_light.y), float(hz_v_light.x), 0.0, 1.0);\n \
hz_MultiTexCoord2 = hz_MultiTexCoord1;\n \
hz_Color = hz_v_color;\n \
hz_Normal = vec3(0.0, 1.0, 0.0);\n \
hz_tangent = vec4(1.0, 0.0, 0.0, 1.0);\n",
scale[0], scale[1],
);
let mut body = body;
if flat {
body.push_str(FACE);
}
declarations.push_str("vec2 hz_cell; vec2 hz_scale; vec4 hz_tangent;\n");
let entity = if flat {
"vec4(float(hz_block_ids[2u * hz_layer]), float(hz_block_ids[2u * hz_layer + 1u]), 0.0, 0.0)"
} else {
"vec4(-1.0, -1.0, 0.0, 0.0)"
};
let attributes = [
("mc_Entity", entity),
(
"mc_midTexCoord",
"vec4((hz_cell + 0.5) * hz_scale, 0.0, 1.0)",
),
("at_tangent", "hz_tangent"),
("vaPosition", "hz_Vertex.xyz"),
("vaUV0", "hz_MultiTexCoord0.xy"),
("vaUV2", "hz_MultiTexCoord1.xy"),
("vaColor", "hz_Color"),
("vaNormal", "hz_Normal"),
];
horizon_shaders::GbuffersInputs {
declarations,
body,
attributes: attributes
.iter()
.map(|&(n, v)| (n.to_owned(), v.to_owned()))
.collect(),
after: String::new(),
alpha_test: None,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
@@ -0,0 +1,83 @@
//! The uniforms a shader pack's gbuffers programs read per draw (`HzDraw` at set 2, the
//! translator's `DRAW_UNIFORMS`): one slot per render stage of a uniform buffer, picked with a
//! dynamic offset at each draw.
use horizon_shaders::{RENDER_STAGES, render_stage};
/// Where a run of `Frame::entities` begins, and what it is (slice 7): the run lasts until the
/// next span. Recorded only while a shader pack draws entities, so Horizon's own frames carry
/// none; Horizon itself still draws the whole list at once.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct EntitySpan {
/// The first vertex.
pub start: u32,
/// The render stage (5.4: `ENTITIES`, `BLOCK_ENTITIES`, `PARTICLES`, `DESTROY`), which picks
/// the program.
pub stage: u32,
/// `entityId` for entities, `blockEntityId` for block entities (5.3), else 0.
pub id: i32,
/// An entity part that blends (a name tag, a shadow): `gbuffers_entities_translucent`.
pub translucent: bool,
}
/// `HzDraw`'s size: `renderStage`, `entityId`, `blockEntityId`, a pad, `entityColor`.
const SIZE: u32 = 32;
pub(super) struct DrawUniforms {
pub layout: wgpu::BindGroupLayout,
group: wgpu::BindGroup,
stride: u32,
}
impl DrawUniforms {
pub fn new(device: &wgpu::Device) -> Self {
let stride = SIZE.max(device.limits().min_uniform_buffer_offset_alignment);
let mut contents = vec![0u8; stride as usize * RENDER_STAGES.len()];
for (i, slot) in contents.chunks_mut(stride as usize).enumerate() {
slot[..4].copy_from_slice(&(i as i32).to_le_bytes());
}
let buffer = wgpu::util::DeviceExt::create_buffer_init(
device,
&wgpu::util::BufferInitDescriptor {
label: Some("Shader pack draws"),
contents: &contents,
usage: wgpu::BufferUsages::UNIFORM,
},
);
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("Shader pack draws"),
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: true,
min_binding_size: wgpu::BufferSize::new(u64::from(SIZE)),
},
count: None,
}],
});
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Shader pack draws"),
layout: &layout,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
buffer: &buffer,
offset: 0,
size: wgpu::BufferSize::new(u64::from(SIZE)),
}),
}],
});
Self {
layout,
group,
stride,
}
}
/// Draws that follow read `renderStage` = `MC_RENDER_STAGE_<stage>`, other values zero.
pub fn bind(&self, pass: &mut wgpu::RenderPass<'_>, stage: &str) {
pass.set_bind_group(2, &self.group, &[self.stride * render_stage(stage)]);
}
}
@@ -0,0 +1,462 @@
//! Entities, block entities, translucent entity parts and particles drawn by a shader pack's
//! `gbuffers_entities`, `gbuffers_block`, `gbuffers_entities_translucent` and
//! `gbuffers_particles` (spec 2.3, 5.3, 5.4): the runs of `Frame::entities` the game marked (`EntitySpan`), each its
//! own draw with its `entityId` or `blockEntityId` and `entityColor` in a per-draw slot of
//! `HzDraw` (set 2). Horizon draws whatever the pack does not.
use std::ops::Range;
use horizon_shaders::render_stage;
use super::Vertex;
use super::pack_draw::EntitySpan;
/// `HzDraw`'s size (pack_draw.rs).
const SLOT: u64 = 32;
const ATTRIBUTES: [wgpu::VertexAttribute; 6] = wgpu::vertex_attr_array![
0 => Float32x3, 1 => Float32x2, 2 => Uint32, 3 => Unorm8x4, 4 => Uint8x4, 5 => Snorm8x4
];
/// The entity vertex: Horizon's own (`Vertex`).
pub fn buffers() -> [Option<wgpu::VertexBufferLayout<'static>>; 1] {
[Some(wgpu::VertexBufferLayout {
array_stride: std::mem::size_of::<Vertex>() as u64,
step_mode: wgpu::VertexStepMode::Vertex,
attributes: &ATTRIBUTES,
})]
}
/// What `gbuffers_entities` and `gbuffers_block` read from an entity vertex: camera-relative
/// position, the shared atlas's UV, colour, light (block, sky in 16ths) and the world-oriented
/// normal. The quad's corners, read from the same vertices at set 1, give the face normal where
/// the vertex has none (block entities) and `at_tangent` along the texture's u, as for terrain.
pub fn inputs() -> horizon_shaders::GbuffersInputs {
let declarations = "layout(location = 0) in vec3 hz_v_pos;\nlayout(location = 1) in vec2 hz_v_uv;\n\
layout(location = 2) in uint hz_v_overlay;\nlayout(location = 3) in vec4 hz_v_color;\n\
layout(location = 4) in uvec4 hz_v_light;\nlayout(location = 5) in vec4 hz_v_normal;\n\
layout(set = 1, binding = 0) readonly buffer HzEntityVertices { uint hz_entity_vertices[]; };\n\
vec4 hz_tangent; vec2 hz_mid;\n"
.to_owned();
let words = std::mem::size_of::<Vertex>() / 4;
let corner = |k: usize, field: &str| {
let at = |o: usize| format!("hz_entity_vertices[hz_q + {}u]", k * words + o);
match field {
"pos" => format!("uintBitsToFloat(uvec3({}, {}, {}))", at(0), at(1), at(2)),
_ => format!("uintBitsToFloat(uvec2({}, {}))", at(3), at(4)),
}
};
let body = format!(
" uint hz_q = (uint(gl_VertexIndex) & ~3u) * {words}u;\n \
vec3 hz_e1 = {p1} - {p0};\n \
vec3 hz_e2 = {p2} - {p0};\n \
vec2 hz_t0 = {t0};\n \
vec2 hz_d1 = {t1} - hz_t0;\n \
vec2 hz_d2 = {t2} - hz_t0;\n \
hz_mid = (hz_t0 + {t2}) * 0.5;\n \
vec3 hz_n = cross(hz_e1, hz_e2);\n \
hz_Normal = dot(hz_v_normal.xyz, hz_v_normal.xyz) > 0.01 ? normalize(hz_v_normal.xyz)\n \
: dot(hz_n, hz_n) > 1e-12 ? normalize(hz_n) : vec3(0.0, 1.0, 0.0);\n \
hz_tangent = vec4(1.0, 0.0, 0.0, 1.0);\n \
float hz_r = hz_d1.x * hz_d2.y - hz_d2.x * hz_d1.y;\n \
vec3 hz_t = (hz_e1 * hz_d2.y - hz_e2 * hz_d1.y) * sign(hz_r);\n \
vec3 hz_b = (hz_e2 * hz_d1.x - hz_e1 * hz_d2.x) * sign(hz_r);\n \
hz_t -= hz_Normal * dot(hz_Normal, hz_t);\n \
if (dot(hz_t, hz_t) > 1e-12) {{\n \
hz_t = normalize(hz_t);\n \
hz_tangent = vec4(hz_t, dot(cross(hz_t, hz_Normal), hz_b) < 0.0 ? -1.0 : 1.0);\n \
}}\n \
hz_Vertex = vec4(hz_v_pos, 1.0);\n \
hz_MultiTexCoord0 = vec4(hz_v_uv, 0.0, 1.0);\n \
hz_MultiTexCoord1 = vec4(float(hz_v_light.y), float(hz_v_light.x), 0.0, 1.0);\n \
hz_MultiTexCoord2 = hz_MultiTexCoord1;\n \
hz_Color = hz_v_color;\n",
p0 = corner(0, "pos"),
p1 = corner(1, "pos"),
p2 = corner(2, "pos"),
t0 = corner(0, "uv"),
t1 = corner(1, "uv"),
t2 = corner(2, "uv"),
);
let attributes = [
("at_tangent", "hz_tangent"),
("mc_midTexCoord", "vec4(hz_mid, 0.0, 1.0)"),
("vaPosition", "hz_Vertex.xyz"),
("vaUV0", "hz_v_uv"),
("vaUV1", "ivec2(0, 10)"),
("vaUV2", "ivec2(hz_MultiTexCoord1.xy)"),
("vaColor", "hz_Color"),
("vaNormal", "hz_Normal"),
];
horizon_shaders::GbuffersInputs {
declarations,
body,
attributes: attributes
.iter()
.map(|&(n, v)| (n.to_owned(), v.to_owned()))
.collect(),
after: String::new(),
// Cutout, as vanilla's entity types mostly are (OQ-23): the loader's test at 0.1.
alpha_test: Some(horizon_shaders::AlphaTest {
op: ">",
reference: 0.1,
}),
}
}
/// What `gbuffers_clouds` reads from the clouds' mesh (entity vertices, `vs_cloud`): the
/// position moved by the clouds' offset, the colour of the face's shade from their palette,
/// full sky light. Set 1 holds the clouds' uniform (`clouds::Uniform`).
pub fn cloud_inputs() -> horizon_shaders::GbuffersInputs {
let declarations = "layout(location = 0) in vec3 hz_v_pos;\nlayout(location = 1) in vec2 hz_v_uv;\n\
layout(location = 2) in uint hz_v_overlay;\nlayout(location = 3) in vec4 hz_v_color;\n\
layout(location = 4) in uvec4 hz_v_light;\nlayout(location = 5) in vec4 hz_v_normal;\n\
layout(set = 1, binding = 0) uniform HzCloud { vec4 hz_cloud_offset; vec4 hz_cloud_colors[4]; };\n"
.to_owned();
let body = " hz_Vertex = vec4(hz_v_pos + hz_cloud_offset.xyz, 1.0);\n \
hz_MultiTexCoord0 = vec4(hz_v_uv, 0.0, 1.0);\n \
hz_MultiTexCoord1 = vec4(0.0, 240.0, 0.0, 1.0);\n \
hz_MultiTexCoord2 = hz_MultiTexCoord1;\n \
hz_Color = hz_cloud_colors[min(hz_v_light.x, 3u)];\n \
hz_Normal = dot(hz_v_normal.xyz, hz_v_normal.xyz) > 0.01 ? normalize(hz_v_normal.xyz) : vec3(0.0, 1.0, 0.0);\n"
.to_owned();
let attributes = [
("vaPosition", "hz_Vertex.xyz"),
("vaUV0", "hz_v_uv"),
("vaUV2", "ivec2(0, 240)"),
("vaColor", "hz_Color"),
("vaNormal", "hz_Normal"),
];
horizon_shaders::GbuffersInputs {
declarations,
body,
attributes: attributes
.iter()
.map(|&(n, v)| (n.to_owned(), v.to_owned()))
.collect(),
after: String::new(),
alpha_test: None,
}
}
/// `entityColor` for a run whose first quad carries overlay code `overlay`: the hurt red or a
/// white flash, its alpha how much of that colour shows over the entity (vanilla mixes the
/// overlay texel's colour in by one minus the texel's alpha).
pub fn entity_color(overlay: u32) -> [f32; 4] {
let [r, g, b, a] = crate::overlay::HURT_TEXEL.map(|v| f32::from(v) / 255.0);
let white = |u: u32| {
let a = f32::from(crate::overlay::white_alpha(u)) / 255.0;
[1.0, 1.0, 1.0, 1.0 - a]
};
match overlay {
1 | 8 => [r, g, b, 1.0 - a],
5 => white(15),
16..32 => white(overlay - crate::overlay::WHITE),
_ => [0.0; 4],
}
}
/// One draw: its quads in `PackEntities`' buffer, its program and its slot of `HzDraw`.
pub(super) struct Draw {
/// The first vertex.
pub base: u32,
pub quads: u32,
/// The program that draws it (`ENTITY`, `BLOCK`, `TRANSLUCENT`, `PARTICLE`).
pub program: usize,
pub slot: u32,
}
/// The vertices and per-draw uniforms of the runs a pack draws, rebuilt each frame.
pub(super) struct PackEntities {
vertices: wgpu::Buffer,
/// Set 1: the vertices again, for the quads' corners.
pub table: wgpu::BindGroupLayout,
pub table_group: wgpu::BindGroup,
slots: wgpu::Buffer,
pub group: wgpu::BindGroup,
stride: u64,
/// Two triangles per quad, for `quads` quads.
pub indices: wgpu::Buffer,
quads: u32,
scratch: Vec<Vertex>,
uniforms: Vec<u8>,
pub draws: Vec<Draw>,
}
impl PackEntities {
pub fn new(device: &wgpu::Device, layout: &wgpu::BindGroupLayout) -> Self {
let stride = SLOT.max(u64::from(
device.limits().min_uniform_buffer_offset_alignment,
));
let table = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("Shader pack entity vertices"),
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Storage { read_only: true },
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
}],
});
let (vertices, table_group) = Self::vertex_buffer(device, &table, 4096);
let (slots, group) = Self::slot_buffer(device, layout, 64, stride);
Self {
vertices,
table,
table_group,
slots,
group,
stride,
indices: quad_indices(device, 1024),
quads: 1024,
scratch: Vec::new(),
uniforms: Vec::new(),
draws: Vec::new(),
}
}
fn vertex_buffer(
device: &wgpu::Device,
table: &wgpu::BindGroupLayout,
vertices: u64,
) -> (wgpu::Buffer, wgpu::BindGroup) {
let buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Shader pack entity vertices"),
size: vertices * std::mem::size_of::<Vertex>() as u64,
usage: wgpu::BufferUsages::VERTEX
| wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Shader pack entity vertices"),
layout: table,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: buffer.as_entire_binding(),
}],
});
(buffer, group)
}
fn slot_buffer(
device: &wgpu::Device,
layout: &wgpu::BindGroupLayout,
slots: u64,
stride: u64,
) -> (wgpu::Buffer, wgpu::BindGroup) {
let buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Shader pack entity draws"),
size: slots * stride,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Shader pack entity draws"),
layout,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
buffer: &buffer,
offset: 0,
size: wgpu::BufferSize::new(SLOT),
}),
}],
});
(buffer, group)
}
pub fn vertices(&self) -> wgpu::BufferSlice<'_> {
self.vertices.slice(..)
}
/// The dynamic offset of draw slot `slot`.
pub fn offset(&self, slot: u32) -> u32 {
(u64::from(slot) * self.stride) as u32
}
/// Splits `entities` between the pack, which draws the runs of `spans` its programs cover
/// (`drawn`: whether it has `gbuffers_entities`, `gbuffers_block` or their fallbacks), and
/// Horizon, which draws the rest (`rest`). Uploads the pack's part.
#[allow(clippy::too_many_arguments)]
pub fn prepare(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
layout: &wgpu::BindGroupLayout,
entities: &[Vertex],
spans: &[EntitySpan],
drawn: [bool; PROGRAMS],
rest: &mut Vec<Vertex>,
) {
self.draws.clear();
self.scratch.clear();
self.uniforms.clear();
rest.clear();
let first = spans.first().map_or(entities.len(), |s| s.start as usize);
rest.extend_from_slice(&entities[..first.min(entities.len())]);
for (span, range) in runs(entities.len(), spans) {
let run = &entities[range];
let Some(program) = drawn_by_pack(&span, drawn).filter(|_| plain(run)) else {
rest.extend_from_slice(run);
continue;
};
if run.is_empty() {
continue;
}
let start = self.scratch.len() as u32;
self.scratch.extend_from_slice(run);
let (entity_id, block_id) = match program {
BLOCK => (0, span.id),
_ => (span.id, 0),
};
let mut bytes = [0u8; SLOT as usize];
bytes[0..4].copy_from_slice(&(span.stage as i32).to_le_bytes());
bytes[4..8].copy_from_slice(&entity_id.to_le_bytes());
bytes[8..12].copy_from_slice(&block_id.to_le_bytes());
for (i, c) in entity_color(run[0].layer).iter().enumerate() {
bytes[16 + 4 * i..20 + 4 * i].copy_from_slice(&c.to_le_bytes());
}
self.uniforms.extend_from_slice(&bytes);
self.uniforms
.resize(self.uniforms.len() + (self.stride - SLOT) as usize, 0);
self.draws.push(Draw {
base: start,
quads: run.len() as u32 / 4,
program,
slot: self.draws.len() as u32,
});
}
if self.draws.is_empty() {
return;
}
let vertex_size = std::mem::size_of::<Vertex>() as u64;
let (need_vertices, need_slots) = (self.scratch.len() as u64, self.draws.len() as u64);
let have_vertices = self.vertices.size() / vertex_size;
let have_slots = self.slots.size() / self.stride;
if need_vertices > have_vertices {
(self.vertices, self.table_group) =
Self::vertex_buffer(device, &self.table, need_vertices.next_power_of_two());
}
if need_slots > have_slots {
(self.slots, self.group) =
Self::slot_buffer(device, layout, need_slots.next_power_of_two(), self.stride);
}
let quads = self.draws.iter().map(|d| d.quads).max().unwrap_or(0);
if quads > self.quads {
self.quads = quads.next_power_of_two();
self.indices = quad_indices(device, self.quads);
}
queue.write_buffer(&self.vertices, 0, bytemuck::cast_slice(&self.scratch));
queue.write_buffer(&self.slots, 0, &self.uniforms);
}
}
/// Two triangles for each of `quads` quads, from vertex 0.
pub(super) fn quad_indices(device: &wgpu::Device, quads: u32) -> wgpu::Buffer {
let indices: Vec<u32> = (0..quads)
.flat_map(|q| [0, 1, 2, 0, 2, 3].map(|i| q * 4 + i))
.collect();
wgpu::util::DeviceExt::create_buffer_init(
device,
&wgpu::util::BufferInitDescriptor {
label: Some("Shader pack entity indices"),
contents: bytemuck::cast_slice(&indices),
usage: wgpu::BufferUsages::INDEX,
},
)
}
/// Whether a run holds only geometry a gbuffers program can draw from the shared atlas: no
/// celestial body, cloud, beam, End portal or crack (overlay codes Horizon's entity shader
/// draws in its own way; entity.wgsl).
fn plain(run: &[Vertex]) -> bool {
run.iter()
.step_by(4)
.all(|v| !matches!(v.layer, 2 | 4 | 6 | 9 | 10 | 11 | 12))
}
/// The programs of entity runs, in the order they draw.
pub const ENTITY: usize = 0;
pub const BLOCK: usize = 1;
pub const TRANSLUCENT: usize = 2;
pub const PARTICLE: usize = 3;
pub const PROGRAMS: usize = 4;
/// Which program draws `span`'s run, given which of them (or their fallbacks) the pack has;
/// `None`: Horizon draws it.
pub fn drawn_by_pack(span: &EntitySpan, drawn: [bool; PROGRAMS]) -> Option<usize> {
let program = if span.stage == render_stage("ENTITIES") {
if span.translucent {
TRANSLUCENT
} else {
ENTITY
}
} else if span.stage == render_stage("BLOCK_ENTITIES") {
BLOCK
} else if span.stage == render_stage("PARTICLES") {
PARTICLE
} else {
return None;
};
drawn[program].then_some(program)
}
/// Each span with its vertex range: from its start to the next span's (or the end).
pub fn runs(
len: usize,
spans: &[EntitySpan],
) -> impl Iterator<Item = (EntitySpan, Range<usize>)> + '_ {
spans.iter().enumerate().map(move |(i, s)| {
let end = spans.get(i + 1).map_or(len, |n| n.start as usize);
let start = (s.start as usize).min(len);
(*s, start..end.clamp(start, len))
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn runs_split_the_list_between_pack_and_horizon() {
let v = |layer| Vertex {
layer,
..bytemuck::Zeroable::zeroed()
};
let span = |start, stage: &str, id| EntitySpan {
start,
stage: render_stage(stage),
id,
translucent: false,
};
let spans = [
span(2, "ENTITIES", 7),
span(5, "PARTICLES", 0),
span(6, "BLOCK_ENTITIES", 9),
];
let ranges: Vec<_> = runs(10, &spans).map(|(_, r)| r).collect();
assert_eq!(ranges, [2..5, 5..6, 6..10]);
let all = [true; PROGRAMS];
assert_eq!(drawn_by_pack(&spans[0], all), Some(ENTITY));
assert_eq!(drawn_by_pack(&spans[1], all), Some(PARTICLE));
assert_eq!(drawn_by_pack(&spans[1], [true, true, true, false]), None);
assert_eq!(drawn_by_pack(&spans[2], [true, false, true, true]), None);
assert_eq!(drawn_by_pack(&spans[2], all), Some(BLOCK));
let shadow = EntitySpan {
translucent: true,
..spans[0]
};
assert_eq!(drawn_by_pack(&shadow, all), Some(TRANSLUCENT));
assert_eq!(drawn_by_pack(&span(0, "DESTROY", 0), all), None);
// A beacon beam's quads stay Horizon's.
assert!(plain(&[v(0), v(0), v(0), v(0), v(1)]));
assert!(!plain(&[v(0), v(0), v(0), v(0), v(6)]));
assert_eq!(entity_color(1)[0], 1.0);
assert!((entity_color(1)[3] - (1.0 - 178.0 / 255.0)).abs() < 1e-6);
assert_eq!(entity_color(0), [0.0; 4]);
}
}
+169
View File
@@ -0,0 +1,169 @@
//! The first-person hand and held items drawn by a shader pack's `gbuffers_hand` (spec 2.3):
//! `Frame::hand`'s entity vertices, read as entities are (`pack_entities::inputs`), with the
//! hand's own projection as `gl_ProjectionMatrix` (5.2: `gbufferProjection` stays the world's).
use glam::Mat4;
use super::Vertex;
/// `MC_HAND_DEPTH`'s value (1.5): the hand's depth is scaled by it through its projection, so
/// that it sits in front of the world in the shared depth buffer.
const HAND_DEPTH: f32 = 0.125;
/// `HzHand`: the hand's projection and its inverse.
const UNIFORM: u64 = 2 * 64;
/// What `gbuffers_hand` reads: the entity inputs, and the hand's projection from set 1.
pub fn inputs() -> horizon_shaders::GbuffersInputs {
let mut inputs = super::pack_entities::inputs();
inputs.declarations.push_str(
"layout(set = 1, binding = 1) uniform HzHand { mat4 hz_hand_projection; mat4 hz_hand_projection_inverse; };\n",
);
inputs.body.push_str(
" hz_ProjectionMatrix = hz_hand_projection;\n \
hz_ProjectionMatrixInverse = hz_hand_projection_inverse;\n \
hz_ModelViewProjectionMatrix = hz_hand_projection * hz_ModelViewMatrix;\n",
);
inputs
}
/// The hand's projection in GL's conventions: `hud_fov` degrees, the view bob, depth scaled by
/// `MC_HAND_DEPTH`.
pub fn projection(hud_fov: f32, aspect: f32, far: f32, bob: Mat4) -> Mat4 {
Mat4::from_scale(glam::Vec3::new(1.0, 1.0, HAND_DEPTH))
* Mat4::perspective_rh_gl(hud_fov.to_radians(), aspect, 0.05, far)
* bob
}
/// The hand's vertices (also read at set 1 for normals and tangents), its uniform and quad
/// indices.
pub struct PackHand {
pub layout: wgpu::BindGroupLayout,
vertices: wgpu::Buffer,
uniform: wgpu::Buffer,
pub group: wgpu::BindGroup,
pub indices: wgpu::Buffer,
capacity: u32,
/// Quads uploaded this frame.
pub quads: u32,
}
impl PackHand {
pub fn new(device: &wgpu::Device) -> Self {
let entry = |binding, ty| wgpu::BindGroupLayoutEntry {
binding,
visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
};
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("Shader pack hand"),
entries: &[
entry(0, wgpu::BufferBindingType::Storage { read_only: true }),
entry(1, wgpu::BufferBindingType::Uniform),
],
});
let uniform = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Shader pack hand"),
size: UNIFORM,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let capacity = 256;
let (vertices, group) = Self::vertex_buffer(device, &layout, &uniform, capacity);
Self {
indices: super::pack_entities::quad_indices(device, capacity),
layout,
vertices,
uniform,
group,
capacity,
quads: 0,
}
}
fn vertex_buffer(
device: &wgpu::Device,
layout: &wgpu::BindGroupLayout,
uniform: &wgpu::Buffer,
quads: u32,
) -> (wgpu::Buffer, wgpu::BindGroup) {
let buffer = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Shader pack hand vertices"),
size: u64::from(quads) * 4 * std::mem::size_of::<Vertex>() as u64,
usage: wgpu::BufferUsages::VERTEX
| wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Shader pack hand"),
layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: buffer.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: uniform.as_entire_binding(),
},
],
});
(buffer, group)
}
/// Uploads this frame's hand and its projection.
pub fn prepare(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
hand: &[Vertex],
projection: Mat4,
) {
self.quads = (hand.len() / 4) as u32;
if self.quads == 0 {
return;
}
if self.quads > self.capacity {
self.capacity = self.quads.next_power_of_two();
(self.vertices, self.group) =
Self::vertex_buffer(device, &self.layout, &self.uniform, self.capacity);
self.indices = super::pack_entities::quad_indices(device, self.capacity);
}
queue.write_buffer(&self.vertices, 0, bytemuck::cast_slice(hand));
let matrices = [projection, projection.inverse()].map(|m| m.to_cols_array());
queue.write_buffer(&self.uniform, 0, bytemuck::cast_slice(&matrices));
}
pub fn vertices(&self) -> wgpu::BufferSlice<'_> {
self.vertices.slice(..)
}
}
#[cfg(test)]
mod tests {
use super::*;
/// The hand's window depth lies within `MC_HAND_DEPTH` of the middle (packs tell the hand
/// apart by it), and x, y match the plain projection.
#[test]
fn hand_depth_is_scaled_around_the_middle() {
let p = projection(70.0, 16.0 / 9.0, 512.0, Mat4::IDENTITY);
let plain = Mat4::perspective_rh_gl(70f32.to_radians(), 16.0 / 9.0, 0.05, 512.0);
for z in [-0.06f32, -0.5, -3.0, -400.0] {
let v = glam::Vec4::new(0.1, -0.2, z, 1.0);
let (a, b) = (p * v, plain * v);
let window = (a.z / a.w) * 0.5 + 0.5;
assert!(
(window - 0.5).abs() <= HAND_DEPTH * 0.5 + 1e-6,
"{z}: {window}"
);
assert!((a.x / a.w - b.x / b.w).abs() < 1e-6);
}
}
}
File diff suppressed because it is too large Load Diff
+12 -3
View File
@@ -1,5 +1,6 @@
// Helpers of a shader pack's post-processing (pack_post.rs): the world into colortex0 and
// depthtex0, and colortex0 onto the screen for packs without `final`.
// depthtex0 (a depth attachment, for terrain's depth test), and colortex0 onto the screen for
// packs without `final`.
@vertex
fn vs_full(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
@@ -12,7 +13,7 @@ fn vs_full(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
struct World {
@location(0) color: vec4<f32>,
@location(1) depth: vec4<f32>,
@builtin(frag_depth) depth: f32,
}
// Pack buffers keep GL's rows (row 0 at the bottom), and GL's window depth: Horizon's
@@ -23,7 +24,7 @@ fn fs_blit(@builtin(position) p: vec4<f32>) -> World {
let at = vec2<i32>(i32(p.x), size.y - 1 - i32(p.y));
var out: World;
out.color = textureLoad(source, at, 0);
out.depth = vec4<f32>(1.0 - textureLoad(world_depth, at, 0), 0.0, 0.0, 1.0);
out.depth = 1.0 - textureLoad(world_depth, at, 0);
return out;
}
@@ -52,3 +53,11 @@ fn vs_uv(@builtin(vertex_index) i: u32) -> Full {
fn fs_copy(v: Full) -> @location(0) vec4<f32> {
return textureSample(source, linear, v.uv);
}
// One level of a buffer's mip chain from the level above (6.1.7): the average of the 2×2
// texels under each destination texel, by one bilinear sample at their shared corner.
@fragment
fn fs_down(@builtin(position) p: vec4<f32>) -> @location(0) vec4<f32> {
let size = max(textureDimensions(source) / 2u, vec2<u32>(1u));
return textureSampleLevel(source, linear, p.xy / vec2<f32>(size), 0.0);
}
+323
View File
@@ -0,0 +1,323 @@
//! The vanilla sky's geometry for a shader pack's `gbuffers_skybasic` (spec 2.3): the sky disc,
//! the sunset fan, the stars and the void disc, as Horizon's own sky draws them (terrain.wgsl,
//! stars.rs), built once into a vertex buffer. The frame's colours and rotations sit in a small
//! uniform (set 1) that the vertex inputs read. `gbuffers_skytextured` draws the frame's sun and
//! moon quads, textured from the shared atlas.
use std::ops::Range;
use wgpu::util::DeviceExt;
/// A sky vertex: a position and what it belongs to (`SKY`...).
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
struct Vertex {
pos: [f32; 3],
kind: u32,
}
const SKY: u32 = 0;
const SUNSET_APEX: u32 = 1;
/// Rim of the sunset fan: `pos.xy` is (sin, cos) of its angle.
const SUNSET_RIM: u32 = 2;
const STAR: u32 = 3;
const VOID: u32 = 4;
/// The frame's sky (std140).
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
struct Uniform {
/// Camera-relative world from star space.
stars: [[f32; 4]; 4],
/// Sky colour, alpha 1.
color: [f32; 4],
/// Sunset colour and alpha.
sunrise: [f32; 4],
/// cos and sin of the sunset fan's turn, star brightness.
sun: [f32; 4],
}
/// A sun or moon vertex: position, atlas UV, RGBA8 colour.
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
struct Celestial {
pos: [f32; 3],
uv: [f32; 2],
color: u32,
}
/// Quads of the sun and moon (and room to spare).
const CELESTIAL_QUADS: usize = 4;
const CELESTIAL_ATTRIBUTES: [wgpu::VertexAttribute; 3] =
wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x2, 2 => Unorm8x4];
pub(super) const ATTRIBUTES: [wgpu::VertexAttribute; 2] =
wgpu::vertex_attr_array![0 => Float32x3, 1 => Uint32];
/// What `gbuffers_skybasic` reads from these vertices.
pub fn inputs() -> horizon_shaders::GbuffersInputs {
let declarations =
"layout(location = 0) in vec3 hz_v_pos;\nlayout(location = 1) in uint hz_v_kind;\n\
layout(set = 1, binding = 0) uniform HzSky { mat4 hz_sky_stars; vec4 hz_sky_color; \
vec4 hz_sky_sunrise; vec4 hz_sky_sun; };\n"
.to_owned();
let body = format!(
" vec3 hz_p = hz_v_pos;\n \
hz_Color = hz_sky_color;\n \
if (hz_v_kind == {SUNSET_APEX}u || hz_v_kind == {SUNSET_RIM}u) {{\n \
vec3 hz_l = vec3(0.0, 100.0, 0.0);\n \
hz_Color = hz_sky_sunrise;\n \
if (hz_v_kind == {SUNSET_RIM}u) {{\n \
hz_l = vec3(hz_v_pos.xy * 120.0, -hz_v_pos.y * 40.0 * hz_sky_sunrise.a);\n \
hz_Color.a = 0.0;\n \
}}\n \
vec3 hz_r = vec3(hz_l.x * hz_sky_sun.x - hz_l.y * hz_sky_sun.y, hz_l.x * hz_sky_sun.y + hz_l.y * hz_sky_sun.x, hz_l.z);\n \
hz_p = vec3(hz_r.x, -hz_r.z, hz_r.y);\n \
}} else if (hz_v_kind == {STAR}u) {{\n \
hz_p = (hz_sky_stars * vec4(hz_v_pos, 1.0)).xyz;\n \
hz_Color = vec4(hz_sky_sun.z);\n \
}} else if (hz_v_kind == {VOID}u) {{\n \
hz_Color = vec4(0.0, 0.0, 0.0, 1.0);\n \
}}\n \
hz_Vertex = vec4(hz_p, 1.0);\n \
hz_MultiTexCoord0 = vec4(0.0, 0.0, 0.0, 1.0);\n \
hz_MultiTexCoord1 = vec4(0.0, 240.0, 0.0, 1.0);\n \
hz_MultiTexCoord2 = hz_MultiTexCoord1;\n \
hz_Normal = vec3(0.0, 1.0, 0.0);\n"
);
horizon_shaders::GbuffersInputs {
declarations,
body,
attributes: vec![
("vaPosition".into(), "hz_Vertex.xyz".into()),
("vaColor".into(), "hz_Color".into()),
("vaNormal".into(), "hz_Normal".into()),
],
// At the far plane: the sky shows only where nothing else drew, and it writes no depth.
after: " gl_Position.z = gl_Position.w;\n".into(),
alpha_test: None,
}
}
/// What `gbuffers_skytextured` reads from the sun and moon's vertices.
pub fn celestial_inputs() -> horizon_shaders::GbuffersInputs {
horizon_shaders::GbuffersInputs {
declarations:
"layout(location = 0) in vec3 hz_v_pos;\nlayout(location = 1) in vec2 hz_v_uv;\n\
layout(location = 2) in vec4 hz_v_color;\n"
.into(),
body: " hz_Vertex = vec4(hz_v_pos, 1.0);\n \
hz_MultiTexCoord0 = vec4(hz_v_uv, 0.0, 1.0);\n \
hz_MultiTexCoord1 = vec4(0.0, 240.0, 0.0, 1.0);\n \
hz_MultiTexCoord2 = hz_MultiTexCoord1;\n \
hz_Color = hz_v_color;\n \
hz_Normal = vec3(0.0, 0.0, 1.0);\n"
.into(),
attributes: vec![
("vaPosition".into(), "hz_Vertex.xyz".into()),
("vaUV0".into(), "hz_v_uv".into()),
("vaColor".into(), "hz_Color".into()),
("vaNormal".into(), "hz_Normal".into()),
],
after: " gl_Position.z = gl_Position.w;\n".into(),
alpha_test: None,
}
}
/// One draw of the sky: its render stage, whether `gbuffers_skytextured` draws it, its vertices.
pub(super) struct Part {
pub stage: &'static str,
pub textured: bool,
pub range: Range<u32>,
}
/// A disc fan at height `y`, radius 512, as triangles (SkyRenderer's sky and void discs).
fn disc(y: f32, kind: u32, out: &mut Vec<Vertex>) {
let sign = y.signum();
let rim = |i: i32| {
let a = (i as f32).to_radians();
Vertex {
pos: [sign * 512.0 * a.cos(), y, 512.0 * a.sin()],
kind,
}
};
let centre = Vertex {
pos: [0.0, y, 0.0],
kind,
};
for i in (-180..180).step_by(45) {
out.extend([centre, rim(i), rim(i + 45)]);
}
}
pub(super) struct PackSky {
vertices: wgpu::Buffer,
celestial: wgpu::Buffer,
uniform: wgpu::Buffer,
pub layout: wgpu::BindGroupLayout,
group: wgpu::BindGroup,
/// Vertex ranges of the sky disc, the sunset fan, the stars and the void.
ranges: [Range<u32>; 4],
}
impl PackSky {
pub fn new(device: &wgpu::Device) -> Self {
let mut v = Vec::new();
disc(16.0, SKY, &mut v);
let sky = 0..v.len() as u32;
let apex = Vertex {
pos: [0.0; 3],
kind: SUNSET_APEX,
};
let rim = |i: u32| {
let a = i as f32 * std::f32::consts::TAU / 16.0;
Vertex {
pos: [a.sin(), a.cos(), 0.0],
kind: SUNSET_RIM,
}
};
for i in 0..16 {
v.extend([apex, rim(i), rim(i + 1)]);
}
let sunset = sky.end..v.len() as u32;
v.extend(
super::stars::star_triangles()
.into_iter()
.map(|pos| Vertex { pos, kind: STAR }),
);
let stars = sunset.end..v.len() as u32;
disc(-4.0, VOID, &mut v);
let void = stars.end..v.len() as u32;
let vertices = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Shader pack sky"),
contents: bytemuck::cast_slice(&v),
usage: wgpu::BufferUsages::VERTEX,
});
let celestial = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Shader pack sun and moon"),
size: (std::mem::size_of::<Celestial>() * 6 * CELESTIAL_QUADS) as u64,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let uniform = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Shader pack sky"),
size: std::mem::size_of::<Uniform>() as u64,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("Shader pack sky"),
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
}],
});
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Shader pack sky"),
layout: &layout,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: uniform.as_entire_binding(),
}],
});
Self {
vertices,
celestial,
uniform,
layout,
group,
ranges: [sky, sunset, stars, void],
}
}
pub fn buffers() -> [Option<wgpu::VertexBufferLayout<'static>>; 1] {
[Some(wgpu::VertexBufferLayout {
array_stride: std::mem::size_of::<Vertex>() as u64,
step_mode: wgpu::VertexStepMode::Vertex,
attributes: &ATTRIBUTES,
})]
}
pub fn celestial_buffers() -> [Option<wgpu::VertexBufferLayout<'static>>; 1] {
[Some(wgpu::VertexBufferLayout {
array_stride: std::mem::size_of::<Celestial>() as u64,
step_mode: wgpu::VertexStepMode::Vertex,
attributes: &CELESTIAL_ATTRIBUTES,
})]
}
/// Writes the frame's sky and returns its draws in vanilla's order: the disc, the sunset
/// fan while the sun is near the horizon, the sun and the moon, the stars and, with the
/// camera low, the void. `tilt` is the pack's `sunPathRotation` (degrees): the sun, moon
/// and stars turn with it (7.1).
pub fn prepare(&self, queue: &wgpu::Queue, frame: &super::Frame, tilt: f32) -> Vec<Part> {
let turn = super::pack_uniforms::tilt_matrix(tilt);
let sun_angle = frame.sky.sun_angle.to_radians();
// The fan turns to the other horizon in the afternoon (terrain.wgsl's sunrise_weight).
let flip = if sun_angle.sin() < 0.0 { 180f32 } else { 0.0 };
let theta = (flip + 90.0).to_radians();
let (rotation, brightness) = frame.stars.unwrap_or_default();
let [r, g, b] = frame.sky.sky_color;
let uniform = Uniform {
stars: (turn * rotation).to_cols_array_2d(),
color: [r, g, b, 1.0],
sunrise: frame.sky.sunrise_color,
sun: [theta.cos(), theta.sin(), brightness.clamp(0.0, 1.0), 0.0],
};
queue.write_buffer(&self.uniform, 0, bytemuck::bytes_of(&uniform));
// The sun's quad, then the moon's (Game::celestial_geometry), as triangles.
let quads = frame
.celestial
.as_chunks::<4>()
.0
.iter()
.take(CELESTIAL_QUADS);
let triangles: Vec<Celestial> = quads
.clone()
.flat_map(|q| [0, 1, 2, 0, 2, 3].map(|i| q[i]))
.map(|v| Celestial {
pos: turn.transform_vector3(v.pos.into()).into(),
uv: v.uv,
color: v.color,
})
.collect();
queue.write_buffer(&self.celestial, 0, bytemuck::cast_slice(&triangles));
let [sky, sunset, stars, void] = self.ranges.clone();
let part = |stage, textured, range| Part {
stage,
textured,
range,
};
let mut parts = vec![part("SKY", false, sky)];
if frame.sky.sunrise_color[3] > 0.001 {
parts.push(part("SUNSET", false, sunset));
}
for (i, stage) in ["SUN", "MOON"].into_iter().enumerate().take(quads.len()) {
parts.push(part(stage, true, i as u32 * 6..i as u32 * 6 + 6));
}
if frame.stars.is_some() {
parts.push(part("STARS", false, stars));
}
if frame.dark_disc {
parts.push(part("VOID", false, void));
}
parts
}
/// Binds the vertices of the `textured` (sun and moon) or other parts.
pub fn bind(&self, pass: &mut wgpu::RenderPass<'_>, textured: bool) {
if textured {
pass.set_vertex_buffer(0, self.celestial.slice(..));
} else {
pass.set_bind_group(1, &self.group, &[]);
pass.set_vertex_buffer(0, self.vertices.slice(..));
}
}
}
@@ -0,0 +1,148 @@
//! Developers' aid: `HORIZON_SHADER_PACK_TIMING=1` times every pass of a shader pack on the
//! GPU, one frame in `EVERY`, and logs each pass's median every `REPORT` timed frames. The
//! frame after a timed one waits for the GPU before reading the timestamps (Metal resolves
//! them without waiting for the passes that write them), so timing slows the game.
const EVERY: u32 = 30;
const REPORT: usize = 30;
/// Passes timed per frame at most (two timestamps each).
const CAPACITY: u32 = 64;
pub(super) struct PassTiming {
queries: wgpu::QuerySet,
resolve: wgpu::Buffer,
read: wgpu::Buffer,
period_ns: f32,
frame: u32,
/// The passes timed in the frame being recorded or waiting to be read, in order.
names: Vec<String>,
timed: bool,
samples: Vec<(String, Vec<f32>)>,
reports: usize,
}
impl PassTiming {
pub fn new(device: &wgpu::Device, queue: &wgpu::Queue) -> Option<Self> {
if std::env::var_os("HORIZON_SHADER_PACK_TIMING").is_none()
|| !device.features().contains(wgpu::Features::TIMESTAMP_QUERY)
{
return None;
}
let size = u64::from(CAPACITY) * 2 * 8;
let buffer = |label, usage| {
device.create_buffer(&wgpu::BufferDescriptor {
label: Some(label),
size,
usage,
mapped_at_creation: false,
})
};
Some(Self {
queries: device.create_query_set(&wgpu::QuerySetDescriptor {
label: Some("Shader pack pass timing"),
ty: wgpu::QueryType::Timestamp,
count: CAPACITY * 2,
}),
resolve: buffer(
"Shader pack timing resolve",
wgpu::BufferUsages::QUERY_RESOLVE | wgpu::BufferUsages::COPY_SRC,
),
read: buffer(
"Shader pack timing read",
wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
),
period_ns: queue.get_timestamp_period(),
frame: 0,
names: Vec::new(),
timed: false,
samples: Vec::new(),
reports: 0,
})
}
/// At the start of a frame: reads the last timed frame's passes, and decides whether this
/// one is timed.
pub fn begin(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) {
if self.timed && !self.names.is_empty() {
self.collect(device, queue);
}
self.names.clear();
self.frame += 1;
self.timed = self.frame.is_multiple_of(EVERY);
}
/// Timestamp writes for the pass `name`, in a timed frame.
pub fn writes(&mut self, name: &str) -> Option<wgpu::RenderPassTimestampWrites<'_>> {
let i = self.names.len() as u32;
if !self.timed || i >= CAPACITY {
return None;
}
self.names.push(name.to_owned());
Some(wgpu::RenderPassTimestampWrites {
query_set: &self.queries,
beginning_of_pass_write_index: Some(2 * i),
end_of_pass_write_index: Some(2 * i + 1),
})
}
fn collect(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) {
// The timed frame first, then the resolve, so every timestamp is written.
_ = device.poll(wgpu::PollType::wait_indefinitely());
let count = self.names.len() as u32 * 2;
let bytes = u64::from(count) * 8;
let mut encoder = device.create_command_encoder(&Default::default());
encoder.resolve_query_set(&self.queries, 0..count, &self.resolve, 0);
encoder.copy_buffer_to_buffer(&self.resolve, 0, &self.read, 0, bytes);
queue.submit([encoder.finish()]);
let slice = self.read.slice(..bytes);
slice.map_async(wgpu::MapMode::Read, |_| {});
_ = device.poll(wgpu::PollType::wait_indefinitely());
let Ok(data) = slice.get_mapped_range() else {
return;
};
let stamps: Vec<u64> = data
.as_chunks::<8>()
.0
.iter()
.map(|b| u64::from_le_bytes(*b))
.collect();
drop(data);
self.read.unmap();
// Passes overlap on tiled GPUs (a pass begins before the one before it ends): a pass
// costs the time from the later of its beginning and the previous pass's end.
let mut previous_end = 0;
for (name, pair) in self.names.iter().zip(stamps.as_chunks::<2>().0) {
if pair[0] == 0 || pair[1] < pair[0] {
continue;
}
let from = pair[0].max(previous_end).min(pair[1]);
previous_end = pair[1];
let ms = (pair[1] - from) as f32 * self.period_ns / 1e6;
match self.samples.iter_mut().find(|s| s.0 == *name) {
Some(s) => s.1.push(ms),
None => self.samples.push((name.clone(), vec![ms])),
}
}
self.reports += 1;
if self.reports.is_multiple_of(REPORT) {
self.report();
}
}
fn report(&mut self) {
let mut total = 0.0;
let mut parts = Vec::new();
// A pass that did not run in this window (no entities, the sky out of sight) is left out.
for (name, v) in self.samples.iter_mut().filter(|s| !s.1.is_empty()) {
v.sort_by(f32::total_cmp);
let median = v[v.len() / 2];
total += median;
parts.push(format!("{name} {median:.3}"));
v.clear();
}
log::info!(
"shader pack GPU time per pass (median ms of {REPORT} frames): {} = {total:.3}",
parts.join(", ")
);
}
}
+193 -16
View File
@@ -3,7 +3,8 @@
//! Matrices follow GL's conventions (5.5): `gbufferProjection` maps view depth to clip z in
//! [-w, w], and the depth buffers packs read hold GL window depth.
use glam::{Mat4, Vec3, Vec4};
use glam::{DMat4, DVec3, Mat4, Vec3, Vec4};
use horizon_shaders::Shadow;
use super::Frame;
@@ -23,6 +24,15 @@ pub struct PackInputs {
pub hide_gui: bool,
/// The brightness option, 0..1.
pub brightness: f32,
/// The biome at the camera (3.4): registry id, `CAT_*`, `PPT_*`, temperature, downfall.
pub biome: i32,
pub biome_category: i32,
pub biome_precipitation: i32,
pub temperature: f32,
pub rainfall: f32,
/// `heldItemId`, `heldItemId2` (item.properties, 5.3) and `heldBlockLightValue(2)`.
pub held_items: [i32; 2],
pub held_light: [i32; 2],
}
/// One uniform's value: up to 16 floats or 3 integers.
@@ -134,43 +144,116 @@ pub const NAMES: &[&str] = &[
"heldBlockLightValue",
"heldBlockLightValue2",
"renderStage",
"biome",
"biome_category",
"biome_precipitation",
"temperature",
"rainfall",
"gbufferModelView",
"gbufferModelViewInverse",
"gbufferProjection",
"gbufferProjectionInverse",
"gbufferPreviousModelView",
"gbufferPreviousProjection",
"atlasSize",
"shadowModelView",
"shadowModelViewInverse",
"shadowProjection",
"shadowProjectionInverse",
];
/// Values carried from frame to frame.
pub struct FrameUniforms {
pub values: Vec<Value>,
/// The block atlas's size (`atlasSize`), 0 without one.
pub atlas: [u32; 2],
start: std::time::Instant,
last: Option<std::time::Instant>,
frame: u32,
previous: Option<(Vec3, Mat4, Mat4)>,
wetness: f32,
eye_smooth: [f32; 2],
/// The pack's shadow settings (7.1).
pub shadow: Shadow,
}
impl Default for FrameUniforms {
fn default() -> Self {
Self {
values: Vec::new(),
atlas: [0; 2],
start: std::time::Instant::now(),
last: None,
frame: 0,
previous: None,
wetness: 0.0,
eye_smooth: [0.0; 2],
shadow: Shadow::default(),
}
}
}
/// `(0, 100, 0)` on the frame the sky draws a body on: Y -90°, then X by its angle in degrees.
fn body(angle: f32) -> Vec3 {
(Mat4::from_rotation_y((-90.0f32).to_radians()) * Mat4::from_rotation_x(angle.to_radians()))
.transform_vector3(Vec3::new(0.0, 100.0, 0.0))
/// `(0, 100, 0)` on the frame the sky draws a body on: Y -90°, then X by its angle in degrees;
/// `sunPathRotation` (`tilt`, degrees) then turns the path about the world's X axis (7.1, OQ-6).
fn body(angle: f32, tilt: f32) -> Vec3 {
(tilt_matrix(tilt)
* Mat4::from_rotation_y((-90.0f32).to_radians())
* Mat4::from_rotation_x(angle.to_radians()))
.transform_vector3(Vec3::new(0.0, 100.0, 0.0))
}
/// `sunPathRotation`'s turn of the sky's bodies: `tilt` degrees about the world's X axis, so a
/// positive angle moves the noon sun toward +Z (south).
pub fn tilt_matrix(tilt: f32) -> Mat4 {
Mat4::from_rotation_x(tilt.to_radians())
}
/// The world direction of the shadow light (7.1): the sun by day, the moon by night.
fn shadow_light(frame: &Frame, shadow: &Shadow) -> Vec3 {
let sun_angle = (frame.sky.sun_angle / 360.0 + 0.25).rem_euclid(1.0);
let angle = if sun_angle < 0.5 {
frame.sky.sun_angle
} else {
frame.sky.moon_angle
};
body(angle, shadow.sun_path_rotation).normalize()
}
/// Distance from the snapped point to the shadow camera, toward the light: the middle of the
/// default near and far planes (OQ-6).
const SHADOW_EYE: f64 = 128.0;
/// The shadow camera (7.1; OQ-6, impl-plan.md): its view (player space to shadow view space)
/// and GL projection. The camera looks from the light, world +Z up (+Y when the light is near
/// Z); the point it centres moves in steps of `shadowIntervalSize` along the shadow view's
/// own axes, and it sits `SHADOW_EYE` blocks toward the light from it. Orthographic over
/// `shadowDistance` each side, or perspective with `shadowMapFov`.
pub fn shadow_camera(light: Vec3, camera: DVec3, shadow: &Shadow) -> (Mat4, Mat4) {
let light = light.as_dvec3();
let up = if light.z.abs() > 0.99 {
DVec3::Y
} else {
DVec3::Z
};
let rotation = DMat4::look_to_rh(DVec3::ZERO, -light, up);
let at = rotation.transform_vector3(camera);
let step = f64::from(shadow.interval);
let snapped = if step > 0.0 {
(at / step).floor() * step
} else {
at
};
let offset = at - snapped - DVec3::new(0.0, 0.0, SHADOW_EYE);
let view = (DMat4::from_translation(offset) * rotation).as_mat4();
let (near, far) = (shadow.near, shadow.far);
let projection = match shadow.fov {
Some(fov) => Mat4::perspective_rh_gl(fov.to_radians(), 1.0, near, far),
None => {
let d = shadow.distance;
Mat4::orthographic_rh_gl(-d, d, -d, d, near, far)
}
};
(view, projection)
}
/// `value` moved toward `target` with a half-life of `half_life` seconds over `dt` (5.6).
@@ -201,8 +284,9 @@ impl FrameUniforms {
let to_view = |v: Vec3| view.transform_vector3(v);
let sun_angle = (frame.sky.sun_angle / 360.0 + 0.25).rem_euclid(1.0);
let day = sun_angle < 0.5;
let sun = to_view(body(frame.sky.sun_angle));
let moon = to_view(body(frame.sky.moon_angle));
let tilt = self.shadow.sun_path_rotation;
let sun = to_view(body(frame.sky.sun_angle, tilt));
let moon = to_view(body(frame.sky.moon_angle, tilt));
// Half-lives are given in ticks (7.2); smoothing runs per frame in seconds (OQ-26).
let half_life = if inputs.rain > self.wetness {
600.0
@@ -214,14 +298,22 @@ impl FrameUniforms {
for (smoothed, target) in self.eye_smooth.iter_mut().zip(eye) {
*smoothed = smooth(*smoothed, target, 10.0 / 20.0, dt);
}
// Vanilla fades by the stronger of two linear fogs; a pack gets one: the pair (start
// and end together) of the one that is complete nearer (OQ-36). Mixing the nearer start
// of one with the nearer end of the other made fog begin at the camera on clear days.
let (fog_color, fog_start, fog_end) = match &frame.fog {
Some(f) => (
[f.color[0], f.color[1], f.color[2]],
f.environmental_start.min(f.render_distance_start),
f.environmental_end.min(f.render_distance_end),
),
Some(f) => {
let (start, end) = if f.environmental_end < f.render_distance_end {
(f.environmental_start, f.environmental_end)
} else {
(f.render_distance_start, f.render_distance_end)
};
([f.color[0], f.color[1], f.color[2]], start, end)
}
None => (frame.sky.fog_color, frame.distance * 0.9, frame.distance),
};
let light = shadow_light(frame, &self.shadow);
let (shadow_view, shadow_projection) = shadow_camera(light, frame.camera, &self.shadow);
let day_time = inputs.day_time.rem_euclid(24000) as i32;
let world_day = inputs.day_time.div_euclid(24000);
let seconds = (now - self.start).as_secs_f32() % 3600.0;
@@ -243,6 +335,11 @@ impl FrameUniforms {
"worldDay" => Value::i(&[world_day as i32]),
"moonPhase" => Value::i(&[world_day.rem_euclid(8) as i32]),
"frameCounter" => Value::i(&[self.frame as i32]),
"shadowModelView" => m4(shadow_view),
"shadowModelViewInverse" => m4(shadow_view.inverse()),
"shadowProjection" => m4(shadow_projection),
"shadowProjectionInverse" => m4(shadow_projection.inverse()),
"atlasSize" => Value::i(&[self.atlas[0] as i32, self.atlas[1] as i32]),
"frameTime" => Value::f(&[dt]),
"frameTimeCounter" => Value::f(&[seconds]),
"viewWidth" => Value::f(&[size[0] as f32]),
@@ -269,6 +366,11 @@ impl FrameUniforms {
"screenBrightness" => Value::f(&[inputs.brightness]),
"hideGUI" => Value::i(&[inputs.hide_gui as i32]),
"eyeBrightness" => Value::i(&eye.map(|v| v as i32)),
"biome" => Value::i(&[inputs.biome]),
"biome_category" => Value::i(&[inputs.biome_category]),
"biome_precipitation" => Value::i(&[inputs.biome_precipitation]),
"temperature" => Value::f(&[inputs.temperature]),
"rainfall" => Value::f(&[inputs.rainfall]),
"eyeBrightnessSmooth" => Value::i(&self.eye_smooth.map(|v| v.round() as i32)),
"gbufferModelView" => m4(view),
"gbufferModelViewInverse" => m4(view.inverse()),
@@ -276,8 +378,11 @@ impl FrameUniforms {
"gbufferProjectionInverse" => m4(projection.inverse()),
"gbufferPreviousModelView" => m4(previous_view),
"gbufferPreviousProjection" => m4(previous_projection),
// Held items wait for `item.properties` (5.3: 0 without the file); renderStage
// is NONE outside gbuffers draws.
"heldItemId" => Value::i(&[inputs.held_items[0]]),
"heldItemId2" => Value::i(&[inputs.held_items[1]]),
"heldBlockLightValue" => Value::i(&[inputs.held_light[0]]),
"heldBlockLightValue2" => Value::i(&[inputs.held_light[1]]),
// renderStage is NONE outside gbuffers draws.
_ => Value::i(&[0]),
}
};
@@ -299,6 +404,47 @@ impl FrameUniforms {
}
}
impl FrameUniforms {
/// Evaluates the pack's custom uniforms with this frame's values and puts them after
/// `NAMES`' values, in `custom.uniforms()` order.
pub fn eval_custom(&mut self, custom: &mut horizon_shaders::Custom) {
self.values.truncate(NAMES.len());
let values = &self.values;
let builtin = |name: &str| {
let v = values.get(index(name)?)?;
let n = components(name);
Some(match *v {
Value::F(f) => horizon_shaders::Val::vector(&f.map(f64::from)[..n]),
Value::I(i) => horizon_shaders::Val::vector(&i.map(f64::from)[..n.min(3)]),
})
};
let dt = match index("frameTime").and_then(|i| values.get(i)) {
Some(Value::F(f)) => f64::from(f[0]),
_ => 0.0,
};
let out = custom.eval(dt, &builtin);
self.values
.extend(out.iter().map(|v| Value::f(&v.v.map(|x| x as f32)[..v.n])));
}
}
/// How many components the uniform `name` has (16 for a matrix).
fn components(name: &str) -> usize {
match name {
"cameraPosition"
| "previousCameraPosition"
| "upPosition"
| "sunPosition"
| "moonPosition"
| "shadowLightPosition"
| "fogColor"
| "skyColor" => 3,
"eyeBrightness" | "eyeBrightnessSmooth" | "atlasSize" => 2,
n if n.starts_with("gbuffer") || n.starts_with("shadow") && n != "shadowAngle" => 16,
_ => 1,
}
}
/// The position of `name` in [`NAMES`].
pub fn index(name: &str) -> Option<usize> {
NAMES.iter().position(|n| *n == name)
@@ -323,7 +469,38 @@ mod tests {
#[test]
fn noon_is_straight_up_and_the_sun_sets_in_the_west() {
assert!(body(0.0).abs_diff_eq(Vec3::new(0.0, 100.0, 0.0), 1e-3));
assert!(body(90.0).abs_diff_eq(Vec3::new(-100.0, 0.0, 0.0), 1e-3));
assert!(body(0.0, 0.0).abs_diff_eq(Vec3::new(0.0, 100.0, 0.0), 1e-3));
assert!(body(90.0, 0.0).abs_diff_eq(Vec3::new(-100.0, 0.0, 0.0), 1e-3));
// sunPathRotation tilts noon toward +Z and leaves sunset on the horizon.
assert!(body(0.0, 30.0).abs_diff_eq(Vec3::new(0.0, 86.60254, 50.0), 1e-3));
assert!(body(90.0, 30.0).abs_diff_eq(Vec3::new(-100.0, 0.0, 0.0), 1e-3));
}
#[test]
fn the_shadow_camera_looks_down_from_the_light_in_steps() {
let shadow = Shadow::default();
let mut camera = DVec3::new(1000.3, 70.0, -20.7);
// Noon: the light is straight up.
let (view, projection) = shadow_camera(Vec3::Y, camera, &shadow);
let at = |p: Vec3| view.transform_point3(p);
// Straight down: a block below the player is farther from the light.
assert!(at(Vec3::new(0.0, -1.0, 0.0)).z < at(Vec3::ZERO).z);
// The player is less than a step from the centre, 128 blocks from the light.
let centre = at(Vec3::ZERO);
assert!(centre.x.abs() <= 2.0 && centre.y.abs() <= 2.0, "{centre}");
assert!((centre.z + 128.0).abs() < 1e-3, "{centre}");
// Moving within a step keeps the world where it was in the map.
camera.x = 1000.6;
let (moved, _) = shadow_camera(Vec3::Y, camera, &shadow);
let world = Vec3::new(5.0, -3.0, 9.0);
let shift = Vec3::new(0.3, 0.0, 0.0);
assert!(
moved
.transform_point3(world - shift)
.abs_diff_eq(at(world), 1e-3)
);
// shadowDistance blocks reach the map's edge.
let edge = projection.project_point3(Vec3::new(160.0, 0.0, -128.0));
assert!((edge.x.abs() - 1.0).abs() < 1e-4, "{edge}");
}
}
@@ -0,0 +1,264 @@
//! Rain and snow drawn by a shader pack's `gbuffers_weather` (spec 2.3): the game's weather
//! quads as entity vertices, their UV animation applied here rather than in Horizon's weather
//! shader, each kind textured from its own copy of its sprite so that the pack's `texture`
//! repeats it across the column as a standalone rain or snow texture would.
use crate::weather::{Time, Vertex as WeatherVertex};
use super::Vertex;
use super::pack_post::Weather;
/// What `gbuffers_weather` reads from a weather vertex: camera-relative position, the UV in
/// repeats of the sprite, colour (with vanilla's fade) and light. Weather has no normal; the
/// pack sees straight up.
pub fn inputs() -> horizon_shaders::GbuffersInputs {
let declarations =
"layout(location = 0) in vec3 hz_v_pos;\nlayout(location = 1) in vec2 hz_v_uv;\n\
layout(location = 2) in uint hz_v_overlay;\nlayout(location = 3) in vec4 hz_v_color;\n\
layout(location = 4) in uvec4 hz_v_light;\nlayout(location = 5) in vec4 hz_v_normal;\n"
.to_owned();
let body = " hz_Vertex = vec4(hz_v_pos, 1.0);\n \
hz_MultiTexCoord0 = vec4(hz_v_uv, 0.0, 1.0);\n \
hz_MultiTexCoord1 = vec4(float(hz_v_light.y), float(hz_v_light.x), 0.0, 1.0);\n \
hz_MultiTexCoord2 = hz_MultiTexCoord1;\n \
hz_Color = hz_v_color;\n \
hz_Normal = vec3(0.0, 1.0, 0.0);\n"
.to_owned();
let attributes = [
("vaPosition", "hz_Vertex.xyz"),
("vaUV0", "hz_v_uv"),
("vaUV2", "ivec2(hz_MultiTexCoord1.xy)"),
("vaColor", "hz_Color"),
("vaNormal", "hz_Normal"),
];
horizon_shaders::GbuffersInputs {
declarations,
body,
attributes: attributes
.iter()
.map(|&(n, v)| (n.to_owned(), v.to_owned()))
.collect(),
after: String::new(),
// Vanilla's weather drops texels below 0.1, as Horizon's own weather shader does.
alpha_test: Some(horizon_shaders::AlphaTest {
op: ">",
reference: 0.1,
}),
}
}
/// The UV phase of `v` at `time`: `weather_phase` of entity.wgsl, on the CPU.
pub fn phase(v: &WeatherVertex, time: Time) -> [f32; 2] {
let [ticks, fall_ticks, partial, _] = time.values;
let a = v.animation;
if v.snow == 0 {
let t = ticks + a[1] + partial;
return [0.0, (-t / 32.0 * a[0]) % 32.0];
}
let t = ticks + partial;
let du = t * 0.01 * a[2];
let dv = t * a[3] * 0.001;
let base = |lo: u32, hi: u32| f64::from_bits(u64::from(lo) | u64::from(hi) << 32);
let u = (base(v.bases[0], v.bases[1]) + f64::from(du)) as f32;
let v_base = (base(v.bases[2], v.bases[3]) + f64::from(dv)) as f32;
[u, -(fall_ticks + partial) / 512.0 + v_base]
}
/// One kind's sprite copied out of the shared atlas: the sprite's rectangle (bits) and its view.
type Sprite = Option<([u32; 4], wgpu::TextureView)>;
/// The pack's weather vertices and the rain and snow sprites, kept across frames.
pub struct PackWeather {
vertices: wgpu::Buffer,
capacity: usize,
scratch: Vec<Vertex>,
sprites: [Sprite; 2],
/// Bumped when a sprite is copied again.
generation: u64,
}
impl PackWeather {
pub fn new(device: &wgpu::Device) -> Self {
Self {
vertices: Self::buffer(device, 64),
capacity: 64,
scratch: Vec::new(),
sprites: [None, None],
generation: 0,
}
}
fn buffer(device: &wgpu::Device, capacity: usize) -> wgpu::Buffer {
device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Shader pack weather"),
size: (capacity * std::mem::size_of::<Vertex>()) as u64,
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
})
}
/// This frame's rain then snow (the game emits them in that order) as entity vertices, and
/// the sprites they read. `None` when there is none.
pub fn prepare(
&mut self,
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
uploads: &mut super::upload::Uploads,
atlas: &wgpu::Texture,
weather: &[WeatherVertex],
time: Time,
indices: &wgpu::Buffer,
) -> Option<Weather> {
if weather.is_empty() {
return None;
}
let rain = weather.iter().take_while(|v| v.snow == 0).count() as u32 / 4;
let snow = weather.len() as u32 / 4 - rain;
for (kind, first) in [(0, weather.first()), (1, weather.get(rain as usize * 4))] {
let Some(first) = first.filter(|v| v.snow as usize == kind) else {
continue;
};
let key = first.rect.map(f32::to_bits);
if self.sprites[kind].as_ref().is_none_or(|s| s.0 != key) {
let view = copy_sprite(device, encoder, atlas, first.rect);
self.sprites[kind] = Some((key, view));
self.generation += 1;
}
}
self.scratch.clear();
self.scratch.extend(weather.iter().map(|v| {
let [du, dv] = phase(v, time);
Vertex {
pos: v.pos,
uv: [v.uv[0] + du, v.uv[1] + dv],
layer: 0,
color: v.color,
light: v.light,
normal: [0; 4],
}
}));
if self.scratch.len() > self.capacity {
self.capacity = self.scratch.len().next_power_of_two();
self.vertices = Self::buffer(device, self.capacity);
}
uploads.buffer(
encoder,
&self.vertices,
0,
bytemuck::cast_slice(&self.scratch),
);
let view = |k: usize| self.sprites[k].as_ref().map(|s| s.1.clone());
Some(Weather {
vertices: self.vertices.clone(),
indices: indices.clone(),
quads: [0..rain, rain..rain + snow],
sprites: [view(0), view(1)],
generation: self.generation,
})
}
}
/// A texture holding the atlas's texels under `rect` (normalised x, y, width, height), as
/// Horizon's weather shader reads them (`weather_texel`).
fn copy_sprite(
device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
atlas: &wgpu::Texture,
rect: [f32; 4],
) -> wgpu::TextureView {
let size = [atlas.width() as f32, atlas.height() as f32];
let origin = [0, 1].map(|i| (rect[i] * size[i]).round() as u32);
let extent = [0, 1].map(|i| ((rect[i + 2] * size[i]).round() as u32).max(1));
let extent = [0, 1].map(|i| {
extent[i].min(
[atlas.width(), atlas.height()][i]
.saturating_sub(origin[i])
.max(1),
)
});
let size = wgpu::Extent3d {
width: extent[0],
height: extent[1],
depth_or_array_layers: 1,
};
let texture = device.create_texture(&wgpu::TextureDescriptor {
label: Some("Shader pack weather sprite"),
size,
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: atlas.format(),
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
view_formats: &[],
});
encoder.copy_texture_to_texture(
wgpu::TexelCopyTextureInfo {
texture: atlas,
mip_level: 0,
origin: wgpu::Origin3d {
x: origin[0],
y: origin[1],
z: 0,
},
aspect: wgpu::TextureAspect::All,
},
wgpu::TexelCopyTextureInfo {
texture: &texture,
mip_level: 0,
origin: wgpu::Origin3d::ZERO,
aspect: wgpu::TextureAspect::All,
},
size,
);
texture.create_view(&Default::default())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::weather::Parameters;
/// The CPU phase matches the game's own weather columns (`Parameters::column`), which
/// Horizon's weather shader is tested against.
#[test]
fn phase_matches_the_weather_columns() {
for i in 0..512i32 {
let x = i.wrapping_mul(45_238_971);
let z = i.wrapping_mul(-418_711).wrapping_add(i32::MIN);
let p = Parameters::new(x, z);
let bases = p.snow_base.map(f64::to_bits);
for ticks in [0, 511, 512, 131_071, 131_072, 1_000_003] {
let partial = [0.0, 0.5, 0.999][i as usize % 3];
for snow in [false, true] {
let column = p.column(snow, ticks, x, -64, 320, z, 0, partial);
let v = WeatherVertex {
pos: [0.0; 3],
uv: [0.0; 2],
rect: [0.0; 4],
animation: [
p.rain_speed,
p.rain_tick_offset,
p.snow_drift[0],
p.snow_drift[1],
],
bases: [
bases[0] as u32,
(bases[0] >> 32) as u32,
bases[1] as u32,
(bases[1] >> 32) as u32,
],
color: 0,
light: 0,
snow: u32::from(snow),
};
let [u, v] = phase(&v, Time::new(ticks, partial));
assert_eq!(
[u.to_bits(), v.to_bits()],
[column.u_offset.to_bits(), column.v_offset.to_bits()],
"x {x} z {z} ticks {ticks} snow {snow}"
);
}
}
}
}
}
+8 -2
View File
@@ -261,11 +261,17 @@ impl PlayerHealth {
self.hurt_animation_time = 10;
}
/// `LocalPlayer.hurtTo` with `flashOnSetHealth`: a drop below the current
/// health starts the hurt animation.
/// health starts the hurt animation; `damageCooldownTime` (20 on a drop,
/// 10 on a gain) is what lets `Hud.extractPlayerHealth` blink the hearts.
pub fn flash_health_change(&mut self, health: f32) {
let damage = self.health() - health;
if damage > 0.0 {
if damage <= 0.0 {
if damage < 0.0 {
self.hurt.cooldown = 10;
}
} else {
self.hurt.last_hurt = damage;
self.hurt.cooldown = 20;
self.animate_hurt();
}
}
+6
View File
@@ -851,6 +851,12 @@ impl HudBatch {
r.v1 = cv;
self.rect_uv(x, y, w, h, r, color);
}
/// Any four-cornered shape in one colour, corners in order round it.
pub fn fill_quad(&mut self, atlas: &HudAtlas, corners: [[f32; 2]; 4], color: u32) {
let w = atlas.white;
let uv = [(w.u0 + w.u1) / 2.0, (w.v0 + w.v1) / 2.0];
self.quad(corners, [uv; 4], color);
}
/// GuiGraphics.fillGradient: `top` to `bottom`, down the rectangle.
pub fn fill_gradient(
&mut self,
+9
View File
@@ -198,6 +198,15 @@ pub fn tick(m: &mut Mob, w: &MobWorld, events: &mut Vec<MobEvent>) {
m.extra.leash_spin = 0.0;
return;
};
// Leashable.tickLeash: a dying entity cannot interact with the level.
if !m.alive() {
events.push(MobEvent::LeashBreak {
mob: m.id,
drop: true,
sound: false,
});
return;
}
let Some(state) = holder_state(w, holder) else {
// The holder is gone: the lead drops.
if !matches!(holder, Holder::Player) {
+5
View File
@@ -3076,8 +3076,13 @@ mod tests {
if client_side {
w.player.health.flash_health_change(20.0);
assert_eq!(w.player.health.hurt_animation_time, 0);
assert_eq!(w.player.health.hurt.cooldown, 0);
w.player.health.flash_health_change(12.0);
assert_eq!(w.player.health.hurt_animation_time, 10);
// LocalPlayer.hurtTo's damageCooldownTime: the HUD's hearts blink.
assert_eq!(w.player.health.hurt.cooldown, 20);
w.player.health.flash_health_change(25.0);
assert_eq!(w.player.health.hurt.cooldown, 10);
}
}
}
-3
View File
@@ -3403,9 +3403,6 @@ mod tests {
assert_eq!(s.gui_scale, expected);
}
s.gui_scale = u32::MAX;
s.clamp_gui_scale(framebuffer);
assert_eq!(s.gui_scale, max);
s.gui_scale = u32::MAX;
Opt::GuiScale.cycle(&mut s, false, framebuffer);
assert_eq!(s.gui_scale, 0);
s.gui_scale = u32::MAX;
+73 -2
View File
@@ -8,7 +8,8 @@ use std::io::Read;
use std::{collections::BTreeSet, fs, io, path::Path, path::PathBuf};
// Bump when overlay/merge semantics change. Markers are disposable cache data.
const VERSION: u32 = 3;
// Version 3 could omit untouched vanilla directories on Windows (#1649, #1688).
const VERSION: u32 = 4;
#[derive(Default, Serialize, Deserialize)]
pub(super) struct Dependencies {
@@ -421,6 +422,73 @@ mod tests {
out
}
#[test]
#[cfg(not(unix))]
fn texture_only_packs_rebuild_incomplete_windows_v3_overlays() {
let f = Fixture::new();
let blockstate = "assets/minecraft/blockstates/oak_stairs.json";
let model = "assets/minecraft/models/block/oak_stairs.json";
let texture = "assets/minecraft/textures/block/stone.png";
let font = "assets/minecraft/textures/font/ascii.png";
f.write(&format!("vanilla/{blockstate}"), br#"{"variants":{}}"#);
f.write(&format!("vanilla/{model}"), br#"{"elements":[]}"#);
f.write(&format!("vanilla/{texture}"), b"vanilla texture");
f.write(&format!("vanilla/{font}"), b"vanilla font");
let folder = f.dir_pack("textures");
f.write(&format!("textures/{texture}"), b"pack texture");
f.write(
"textures.zip",
&archive(
&[
(
"pack.mcmeta",
br#"{"pack":{"description":"test","pack_format":97}}"#.to_vec(),
),
(texture, b"pack texture".to_vec()),
],
true,
),
);
let zip = packs::pack(
"zip".into(),
Text::empty(),
Source::Zip(f.0.join("textures.zip")),
)
.unwrap();
let vanilla = f.0.join("vanilla");
for pack in [folder, zip] {
let out = f.0.join(format!("cached-{}", pack.id));
let selected = std::slice::from_ref(&pack);
packs::build_overlay(&vanilla, selected, &out).unwrap();
let check = || {
for name in [blockstate, model, font] {
assert_eq!(
fs::read(out.join(name)).unwrap(),
fs::read(vanilla.join(name)).unwrap()
);
}
assert_eq!(fs::read(out.join(texture)).unwrap(), b"pack texture");
};
check();
// Before #1688, Windows silently omitted untouched directories.
// A v3 marker still validates because it checks only source files.
let marker_path = marker_path(&out);
let mut marker: Marker =
serde_json::from_slice(&fs::read(&marker_path).unwrap()).unwrap();
marker.version = 3;
for dir in ["blockstates", "models", "textures/font"] {
fs::remove_dir_all(out.join("assets/minecraft").join(dir)).unwrap();
}
fs::write(&marker_path, serde_json::to_vec(&marker).unwrap()).unwrap();
assert!(marker.dependencies.valid());
packs::build_overlay(&vanilla, selected, &out).unwrap();
check();
// The repaired overlay also remains complete on a cache hit.
packs::build_overlay(&vanilla, selected, &out).unwrap();
check();
}
}
#[test]
fn directory_inputs_config_and_owned_output_recovery() {
let f = Fixture::new();
@@ -456,7 +524,10 @@ mod tests {
let path = f.0.join(format!("high/{resource}"));
let original_time = fs::metadata(&path).unwrap().modified().unwrap();
fs::write(&path, br#"{"p":"c"}"#).unwrap();
fs::File::open(path)
// Windows requires a writable handle to restore the timestamp.
fs::OpenOptions::new()
.write(true)
.open(path)
.unwrap()
.set_times(fs::FileTimes::new().set_modified(original_time))
.unwrap();
+36 -10
View File
@@ -1212,10 +1212,7 @@ impl ParticleEngine {
requested: None,
names: Vec::new(),
rects: Vec::new(),
atlas: atlas
.iter()
.map(|(name, &rect)| (name.clone(), (rect, translucent.contains(name))))
.collect(),
atlas: HashMap::new(),
sets: HashMap::new(),
set_sprites: Vec::new(),
emitters: Vec::new(),
@@ -1225,6 +1222,34 @@ impl ParticleEngine {
made: Default::default(),
item_sprites: HashMap::new(),
};
engine.reload(root, atlas, translucent);
engine
}
/// `onResourceManagerReload`: sprite rects and sets come from the
/// reloaded atlas and pack; a live particle keeps drawing its sprite by
/// name or index.
pub fn reload(
&mut self,
root: &Path,
atlas: &HashMap<String, Rect>,
translucent: &HashSet<String>,
) {
self.atlas = atlas
.iter()
.map(|(name, &rect)| (name.clone(), (rect, translucent.contains(name))))
.collect();
self.rects = self
.names
.iter()
.map(|name| self.atlas.get(name).map(|&(rect, _)| rect))
.collect();
self.sets.clear();
self.set_sprites.clear();
self.item_sprites.clear();
self.load_sprites(root);
}
/// The sprite sets of every `particles/*.json` under `root`.
fn load_sprites(&mut self, root: &Path) {
let dir = root.join("assets/minecraft/particles");
for &ty in ParticleType::ALL {
let Ok(bytes) = std::fs::read(dir.join(format!("{}.json", ty.name()))) else {
@@ -1239,18 +1264,16 @@ impl ParticleEngine {
a.iter()
.filter_map(|t| t.as_str())
.map(|t| {
engine
.intern(&format!("particle/{}", t.trim_start_matches("minecraft:")))
self.intern(&format!("particle/{}", t.trim_start_matches("minecraft:")))
})
.collect()
})
.unwrap_or_default();
if !sprites.is_empty() {
engine.sets.insert(ty, engine.set_sprites.len() as u32);
engine.set_sprites.push(sprites);
self.sets.insert(ty, self.set_sprites.len() as u32);
self.set_sprites.push(sprites);
}
}
engine
}
fn intern(&mut self, name: &str) -> u32 {
if let Some(i) = self.names.iter().position(|n| n == name) {
@@ -1601,7 +1624,10 @@ impl ParticleEngine {
return;
}
if let Some(set) = p.set {
let sprites = &self.set_sprites[set as usize];
// A sprite set's index can outlive the reload that rebuilt them.
let Some(sprites) = self.set_sprites.get(set as usize) else {
return;
};
let lifetime = p.lifetime.max(1);
let index = (p.age.max(0) as i64 * (sprites.len() as i64 - 1) / i64::from(lifetime))
.clamp(0, sprites.len() as i64 - 1);
+12 -11
View File
@@ -572,6 +572,17 @@ fn merge_block_entity(original: &Tag, loaded: &Tag, current: &Tag) -> Tag {
}
merged
}
/// `BannerBlockEntity.loadAdditional` (and the `components` a block entity keeps).
pub fn decode_banner(tag: &Tag) -> crate::containers::Banner {
crate::containers::Banner {
layers: crate::banner::layers_from_nbt(tag.get("patterns")),
name: text(tag.get("CustomName")),
components: match tag.get("components") {
Some(Tag::Compound(c)) => c.clone(),
_ => Compound::new(),
},
}
}
pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::containers::BlockEntity)> {
use crate::containers::BlockEntity;
let int = |k: &str| number(tag.get(k)).map(|v| v as i32);
@@ -605,17 +616,7 @@ pub fn decode_block_entity(tag: &Tag) -> Option<((i32, i32, i32), crate::contain
return Some((pos, BlockEntity::Lectern(lectern)));
}
if id == "minecraft:banner" {
return Some((
pos,
BlockEntity::Banner(crate::containers::Banner {
layers: crate::banner::layers_from_nbt(tag.get("patterns")),
name: text(tag.get("CustomName")),
components: match tag.get("components") {
Some(Tag::Compound(c)) => c.clone(),
_ => Compound::new(),
},
}),
));
return Some((pos, BlockEntity::Banner(decode_banner(tag))));
}
if id == "minecraft:beacon" {
let beacon = crate::containers::Beacon {
+7
View File
@@ -413,6 +413,13 @@ impl SculkEntity {
spreader: SculkSpreader::default(),
}
}
/// Whether its block entity tick does nothing: no vibration chosen
/// or on its way, none waiting to be chosen, and no charge to spread.
pub fn idle(&self) -> bool {
self.vibration.current.is_none()
&& self.vibration.selector.current().is_none()
&& self.spreader.cursors.is_empty()
}
pub fn for_block(name: &str) -> Option<Self> {
Some(Self::new(match name {
"minecraft:sculk_sensor" => SculkKind::Sensor,
+26 -7
View File
@@ -104,7 +104,7 @@ pub struct Settings {
pub master_volume: f32,
/// Volumes of every other sound source, indexed like SOUND_SOURCES.
pub volumes: [f32; 11],
/// 0 = auto.
/// Requested scale (0 = auto); rendering caps it to the current framebuffer.
pub gui_scale: u32,
pub view_bobbing: bool,
/// Brightness 0..1 (gamma).
@@ -284,12 +284,6 @@ fn put_s(f: &mut OptionsFile, key: &str, v: &str) {
}
}
impl Settings {
/// `ClampingLazyMaxIntRange.validateValue`: clamp once the framebuffer is known.
pub fn clamp_gui_scale(&mut self, framebuffer: [i32; 2]) {
let max = crate::window::calculate_scale(framebuffer, 0, self.force_unicode) as u32;
self.gui_scale = self.gui_scale.min(max);
}
pub fn load(path: &Path) -> Self {
let horizon = path
.parent()
@@ -597,6 +591,31 @@ impl Settings {
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn gui_scale_survives_temporary_small_framebuffer() {
for requested in [0, 1, 2, 6] {
let settings = Settings::parse(&format!("guiScale:{requested}\n"));
// Hyprland's initial surface can be smaller than the fullscreen one.
for (framebuffer, maximum) in [([715, 860], 2), ([3400, 1913], 7)] {
let effective = crate::window::calculate_scale(
framebuffer,
settings.gui_scale as i32,
settings.force_unicode,
);
assert_eq!(
effective,
if requested == 0 {
maximum
} else {
(requested as i32).min(maximum)
}
);
let saved = Settings::parse(&settings.serialize());
assert_eq!(saved.gui_scale, requested);
}
}
}
#[test]
fn round_trips_vanilla_options_txt() {
let text = "version:4000\nfov:0.5\nrenderDistance:16\nmaxFps:260\nrenderClouds:\"fast\"\nkey_key.jump:key.keyboard.j\nsoundCategory_music:0.25\nresourcePacks:[\"vanilla\",\"file/x.zip\"]\nlang:fr_fr\nsomeFutureOption:42\n";
+105 -20
View File
@@ -128,6 +128,27 @@ fn text(nbt: &Compound, key: &str) -> Option<String> {
}
}
/// The client block entity for one of a chunk's generated block entities,
/// before a container's loot is unpacked: `StructureTemplate.placeInWorld`
/// hands the template's block entity NBT to the level's block entity.
fn generated_block_entity(block: &str, nbt: &Compound) -> Option<BlockEntity> {
let mut entity = BlockEntity::for_block(block)?;
match &mut entity {
// MonsterRoomFeature and the structures' setEntityId.
BlockEntity::Spawner(s) => {
**s = crate::mobs::spawner::Spawner::load(&Tag::Compound(nbt.clone()));
}
BlockEntity::TrialSpawner(s) => {
**s = crate::mobs::trial_spawner::TrialSpawner::load(&Tag::Compound(nbt.clone()));
}
BlockEntity::Vault(v) => **v = crate::vault::Vault::load(&Tag::Compound(nbt.clone())),
// BannerBlockEntity.loadAdditional: the End cities' black triangles.
BlockEntity::Banner(b) => *b = crate::save::decode_banner(&Tag::Compound(nbt.clone())),
_ => {}
}
Some(entity)
}
/// Client block entities for the generated block entities of a chunk.
pub fn block_entities(
chunk: &ProtoChunk,
@@ -137,19 +158,9 @@ pub fn block_entities(
for (pos, nbt) in &chunk.block_entities {
let [x, y, z] = *pos;
let block = chunk.block_name(x, y, z);
let Some(mut entity) = BlockEntity::for_block(block) else {
let Some(mut entity) = generated_block_entity(block, nbt) else {
continue;
};
// MonsterRoomFeature and the structures' setEntityId.
if let BlockEntity::Spawner(s) = &mut entity {
**s = crate::mobs::spawner::Spawner::load(&Tag::Compound(nbt.clone()));
}
if let BlockEntity::TrialSpawner(s) = &mut entity {
**s = crate::mobs::trial_spawner::TrialSpawner::load(&Tag::Compound(nbt.clone()));
}
if let BlockEntity::Vault(v) = &mut entity {
**v = crate::vault::Vault::load(&Tag::Compound(nbt.clone()));
}
if let (BlockEntity::Chest(slots), Some(table), Some(loot)) =
(&mut entity, text(nbt, "LootTable"), loot)
{
@@ -165,14 +176,10 @@ pub fn block_entities(
.iter_mut()
.zip(loot.fill(&table, seed, 27, Some(biome)))
{
*slot = stack.map(|s| {
let mut item = loot_item(&s);
// An ominous bottle's level (the default, 0, is no component).
if let Some(level) = s.ominous_amplifier.filter(|l| *l > 0) {
item.data_mut().ominous_amplifier = Some(level.clamp(0, 4) as u8);
}
item
});
// With what the rolls put on them: enchantments
// (enchant_with_levels in End city chests), potions and an
// ominous bottle's level.
*slot = stack.map(|s| loot_item_with_components(&s));
}
}
out.push(((x, y, z), entity));
@@ -211,7 +218,7 @@ pub fn unpack_entity_loot(
let slots: Vec<Option<ItemStack>> = loot
.fill(&table, seed, 27, Some(biome))
.into_iter()
.map(|s| s.map(|s| loot_item(&s)))
.map(|s| s.map(|s| loot_item_with_components(&s)))
.collect();
nbt.remove(&JavaString::from("LootTable"));
nbt.remove(&JavaString::from("LootTableSeed"));
@@ -224,6 +231,45 @@ mod tests {
use super::*;
use horizon_world::loot::{ExplorationMap, LootStack};
#[test]
fn placed_chest_loot_keeps_its_enchantments_and_potions() {
let stack =
|item: &str, enchantments: Vec<(String, i32)>, potion: Option<&str>| LootStack {
item: item.into(),
count: 1,
damage: 0,
enchantments,
potion: potion.map(str::to_owned),
map: false,
exploration: None,
ominous_amplifier: None,
};
// An End city chest's enchant_with_levels roll.
let boots = loot_item_with_components(&stack(
"minecraft:diamond_boots",
vec![
("minecraft:protection".into(), 3),
("minecraft:unbreaking".into(), 2),
],
None,
));
assert_eq!(boots.enchantments().len(), 2);
// A book's go into stored_enchantments.
let book = loot_item_with_components(&stack(
"minecraft:enchanted_book",
vec![("minecraft:mending".into(), 1)],
None,
));
assert!(book.enchantments().is_empty());
assert_eq!(book.stored_enchantments().len(), 1);
let arrow = loot_item_with_components(&stack(
"minecraft:tipped_arrow",
Vec::new(),
Some("minecraft:slowness"),
));
assert_eq!(arrow.potion(), Some("minecraft:slowness"));
}
#[test]
fn exploration_maps_wait_in_custom_data_until_searched() {
let mut stack = LootStack {
@@ -278,4 +324,43 @@ mod tests {
stack.exploration = None;
assert!(!has_pending_map(&loot_item(&stack)));
}
/// The End cities' tower tops save their banners' patterns in the
/// template; the placed banner must keep them (`EndCityPieces`).
#[test]
fn a_generated_banner_keeps_its_template_patterns() {
let patterns = Tag::List(vec![
Tag::compound([
("color", Tag::String("black".into())),
("pattern", Tag::String("minecraft:triangle_top".into())),
]),
Tag::compound([
("color", Tag::String("black".into())),
("pattern", Tag::String("minecraft:triangle_bottom".into())),
]),
]);
let nbt = Tag::compound([
("id", Tag::String("minecraft:banner".into())),
("patterns", patterns),
]);
let Tag::Compound(nbt) = nbt else {
unreachable!()
};
let Some(BlockEntity::Banner(banner)) =
generated_block_entity("minecraft:magenta_banner", &nbt)
else {
panic!("a banner block makes a banner block entity");
};
assert_eq!(banner.layers.len(), 2);
assert_eq!(&*banner.layers[0].pattern, "minecraft:triangle_top");
assert_eq!(&*banner.layers[1].pattern, "minecraft:triangle_bottom");
assert_eq!(&*banner.layers[0].color, "black");
// A banner the template saved without patterns stays bare.
let Some(BlockEntity::Banner(bare)) =
generated_block_entity("minecraft:white_banner", &Compound::new())
else {
panic!("a banner block makes a banner block entity");
};
assert!(bare.layers.is_empty());
}
}
+56 -2
View File
@@ -41,6 +41,10 @@ pub struct VanillaTerrain {
tick_states: Vec<u32>,
seed: i64,
dimension: String,
/// When the last proto chunk was generated, in milliseconds since
/// `created`: the ring search waits for a pause in generation.
last_proto: std::sync::atomic::AtomicU64,
created: std::time::Instant,
}
/// A proto chunk, or the position of one whose generation failed.
enum VanillaProto {
@@ -139,6 +143,8 @@ impl VanillaTerrain {
tick_states,
seed,
dimension: dimension.to_owned(),
last_proto: std::sync::atomic::AtomicU64::new(0),
created: std::time::Instant::now(),
})
}
/// A proto chunk's blocks, biomes, scheduled ticks and post-processing
@@ -272,9 +278,53 @@ impl VanillaTerrain {
pub fn origin(&self) -> crate::Result<ChunkPos> {
Ok(self.generator.origin()?)
}
/// Concentric ring positions of a structure set (strongholds), once known.
/// Concentric ring positions of a structure set (strongholds), searched
/// for now if no chunk needed them yet.
pub fn ring_positions(&self, set: &str) -> Option<Vec<ChunkPos>> {
self.generator.ring_positions(set)
let mut worker = self.query.lock().unwrap_or_else(|e| e.into_inner());
let worker = worker.get_or_insert_with(|| self.generator.worker());
worker.ring_positions(set)
}
/// Searches the concentric rings on a thread of their own, as vanilla's
/// background executor does, once generation pauses for two seconds
/// (at the latest a minute after the world opens) and in the idle
/// class: on a laptop's few cores, sharing them with the first chunks,
/// which don't need the rings, made those 3 s slower. An eye of ender
/// thrown later finds the rings ready, and a chunk or a query that
/// needs them first shares the remaining searches with this thread.
pub fn search_rings_behind(self: &Arc<Self>) {
const QUIET: u64 = 2_000;
const LATEST: u64 = 60_000;
let terrain = Arc::downgrade(self);
let spawned = std::thread::Builder::new()
.name("Ring search".into())
.spawn(move || {
horizon_threads::idle_current();
loop {
std::thread::sleep(std::time::Duration::from_millis(500));
// The world closed: nothing to search for.
let Some(terrain) = terrain.upgrade() else {
return;
};
let now = terrain.elapsed_ms();
let last = terrain
.last_proto
.load(std::sync::atomic::Ordering::Relaxed);
if now >= LATEST || (last > 0 && now - last >= QUIET) {
let _ = terrain
.generator
.worker()
.ring_positions("minecraft:strongholds");
return;
}
}
});
if let Err(e) = spawned {
log::warn!("ring search thread: {e}");
}
}
fn elapsed_ms(&self) -> u64 {
u64::try_from(self.created.elapsed().as_millis()).unwrap_or(u64::MAX)
}
}
/// The worldgen bundle at `dir`, loaded once and shared by every generator
@@ -323,6 +373,10 @@ impl ChunkGenerator for VanillaTerrain {
}
}
fn proto(&self, worker: &mut GeneratorWorker, x: i32, z: i32) -> Proto {
self.last_proto.store(
self.elapsed_ms().max(1),
std::sync::atomic::Ordering::Relaxed,
);
match worker.generate_proto(ChunkPos::new(x, z)) {
Ok(chunk) => Box::new(VanillaProto::Ready(Box::new(chunk))),
Err(e) => {
+1 -1
View File
@@ -38,7 +38,7 @@ wit_bindgen::generate!({
pub use exports::horizon::mods::events::{Guest as __Guest, Registration};
pub use exports::horizon::mods::ui_events::Guest as __UiEventsGuest;
pub use horizon::mods::{chat, command, game, hud, log, storage, ui};
pub use horizon::mods::{chat, command, game, hud, input, log, render, storage, ui};
/// The game's calls into a mod. Only the hooks [`Registration`] asks for
/// are called; the others may stay as their defaults.
+126
View File
@@ -171,6 +171,124 @@ interface ui-events {
settings-opened: func();
}
/// Capability `input` (experimental: the manifest needs
/// `experimental = ["input"]`): the use button on items the mod claims, and
/// the mod's own keys. Events wait for `poll`, at most 256.
interface input {
/// The main hand's stack.
record held-item {
/// `minecraft:spyglass`, `<mod>:<path>`.
id: string,
count: u32,
/// The hotbar slot, 0 to 8.
slot: u32,
}
record item-use {
item: held-item,
/// Game ticks the button was held (0 on `use-start`).
ticks: u32,
}
variant event {
/// The use button went down with a claimed item in the main hand.
/// The game does nothing else with the click: no placing, no eating,
/// no swing.
use-start(item-use),
/// It came up again, or the item left the hand, or a screen opened.
use-stop(item-use),
/// A key `register-key` named went down or up while playing (no
/// screen open). The game's own mapping on that key still runs.
key-down(string),
key-up(string),
}
/// The items whose use the mod handles instead of the game, by id (at
/// most 64). Replaces the previous list.
claim-items: func(ids: list<string>);
/// A key of the mod's: `name` comes back in `key-down` and `key-up`,
/// `label` says what it does, `key` is the key as options.txt writes
/// it (`key.keyboard.r`). At most 16; an unknown key is an error.
register-key: func(name: string, label: string, key: string) -> result<_, string>;
/// The main hand's stack, as of this tick; none when it is empty.
held: func() -> option<held-item>;
/// The events since the last call, oldest first.
poll: func() -> list<event>;
}
/// Capability `render` (experimental: the manifest needs
/// `experimental = ["render"]`): shapes the game draws for the mod with its
/// own renderer, kept until the mod replaces them (no call per frame). A mod
/// never supplies shader code.
interface render {
/// A rectangle in GUI pixels: the top left corner and the size.
record rect {
x: f32,
y: f32,
w: f32,
h: f32,
}
/// A point in GUI pixels from the screen's top left.
record point {
x: f32,
y: f32,
}
record fill-shape {
rect: rect,
/// 0xAARRGGBB.
color: u32,
}
/// Any four-cornered shape (a wheel's segment, an arrow): the corners
/// in order round it.
record quad-shape {
corners: tuple<point, point, point, point>,
/// 0xAARRGGBB.
color: u32,
}
record sprite-shape {
/// One of the game's GUI sprites, as `gui/sprites/` names them
/// (`hud/heart/full`, `widget/button`), the resource packs' versions
/// included. An unknown one draws nothing.
sprite: string,
rect: rect,
/// A tint, 0xAARRGGBB: 0xFFFFFFFF draws it as it is.
color: u32,
}
record item-shape {
/// `minecraft:diamond`, `<mod>:<path>`; an unknown one draws nothing.
item: string,
/// The icon's top left.
at: point,
/// 1.0 is the hotbar's 16 × 16.
scale: f32,
}
record text-shape {
/// Up to 256 characters, one line.
text: string,
at: point,
/// 0xRRGGBB, as `hud`'s lines.
color: u32,
/// Centred on `at.x` instead of starting there.
centered: bool,
shadow: bool,
}
variant shape {
fill(fill-shape),
quad(quad-shape),
sprite(sprite-shape),
item(item-shape),
text(text-shape),
}
/// Replaces the mod's HUD shapes: up to 1024, drawn every frame in
/// order over the HUD (after the hotbar, under chat and screens), hidden
/// with the HUD (F1). An empty list removes them.
set-hud: func(shapes: list<shape>);
/// The screen's size in GUI pixels (width, height), as of this tick.
gui-size: func() -> tuple<f32, f32>;
/// Shakes the camera: a jolt of `strength` (0 to 1, 1 the hardest) that
/// fades out over `seconds` (at most 10). Jolts add up to 1. The view
/// turns, the player doesn't, and the player's Distortion Effects option
/// scales it (0 turns it off).
shake: func(strength: f32, seconds: f32);
}
/// What the game calls. Only the hooks `init` asks for are ever called.
interface events {
record registration {
@@ -212,6 +330,8 @@ world horizon-mod {
world horizon-ui-mod {
include horizon-mod;
import ui;
import render;
import input;
export ui-events;
}
@@ -220,3 +340,9 @@ world ui-host {
import ui;
export ui-events;
}
/// The game's side of capability `render` (imports only).
world render-host {
import render;
import input;
}
+19 -2
View File
@@ -86,9 +86,15 @@ pub enum Capability {
/// A screen the mod owns and a settings page in Options > Mods, drawn
/// with the menus' own widgets (interface `ui`, calls `ui-events`).
Ui,
/// Shapes on the HUD and the camera's shake, drawn by the game's own
/// renderer (interface `render`).
Render,
/// The use button on items the mod claims, and its own keys
/// (interface `input`).
Input,
}
impl Capability {
pub const ALL: [Capability; 7] = [
pub const ALL: [Capability; 9] = [
Capability::GameRead,
Capability::Chat,
Capability::Hud,
@@ -96,6 +102,8 @@ impl Capability {
Capability::Command,
Capability::Registries,
Capability::Ui,
Capability::Render,
Capability::Input,
];
/// The WIT interface it grants, in `horizon:mods`.
pub fn interface(self) -> &'static str {
@@ -107,12 +115,17 @@ impl Capability {
Capability::Command => "command",
Capability::Registries => "registries",
Capability::Ui => "ui",
Capability::Render => "render",
Capability::Input => "input",
}
}
/// May change in any release: a mod uses it only with
/// `experimental = ["<name>"]` in its manifest.
pub fn is_experimental(self) -> bool {
matches!(self, Capability::Ui)
matches!(
self,
Capability::Ui | Capability::Render | Capability::Input
)
}
/// What the player reads before turning the mod on: "May <this>".
pub fn describe(self) -> &'static str {
@@ -124,6 +137,8 @@ impl Capability {
Capability::Command => "run commands as you, with your permissions",
Capability::Registries => "add blocks and items to your worlds",
Capability::Ui => "show its own screens and a settings page",
Capability::Render => "draw on your screen and shake the camera",
Capability::Input => "take over the use button on its own items, and add keys",
}
}
/// The capability a component import needs, `Ok(None)` for one every
@@ -156,6 +171,8 @@ impl fmt::Display for Capability {
Capability::Command => "command",
Capability::Registries => "registries",
Capability::Ui => "ui",
Capability::Render => "render",
Capability::Input => "input",
};
f.write_str(name)
}
+234
View File
@@ -40,6 +40,22 @@ pub use ui_bindings::horizon::mods::ui::{
ItemWidget, ListWidget, Screen as UiScreen, TextWidget, Widget as UiWidget,
};
use ui_bindings::{UiHost, horizon::mods::ui};
/// Capability `render`'s imports (docs/mods.md): the game draws the shapes.
mod render_bindings {
wasmtime::component::bindgen!({
path: "../horizon-mod-sdk/wit",
world: "render-host",
});
}
use render_bindings::horizon::mods::input;
/// Capability `input`'s records (WIT `interface input`).
pub use render_bindings::horizon::mods::input::{Event as InputEvent, HeldItem, ItemUse};
/// What capability `render` asks the game to draw (WIT `interface render`).
pub use render_bindings::horizon::mods::render::{
FillShape, ItemShape, Point as RenderPoint, QuadShape, Rect as RenderRect, Shape, SpriteShape,
TextShape,
};
use render_bindings::{RenderHost, horizon::mods::render};
/// A mod's linear memory cap.
const MEMORY: usize = 64 << 20;
@@ -70,6 +86,10 @@ const STORAGE_WRITE_BUDGET: u64 = 1 << 20;
pub struct Snapshot {
pub player: Option<Player>,
pub clock: Option<Clock>,
/// The screen in GUI pixels (capability `render`'s `gui-size`).
pub gui_size: (f32, f32),
/// The main hand's stack (capability `input`'s `held`).
pub held: Option<HeldItem>,
}
/// What mods asked the game to show since the last [`Mods::drain`].
@@ -89,6 +109,8 @@ pub enum Output {
OpenScreen { owner: usize },
/// `ui.close-screen`: the mod closed its own screen (no `closed` back).
CloseScreen { owner: usize },
/// `render.shake`: strength 0 to 1, fading out over `seconds` (≤ 10).
Shake { strength: f32, seconds: f32 },
}
/// A mod's text panel, drawn every frame until it changes.
@@ -156,6 +178,9 @@ struct State {
out: Vec<Output>,
panel: Option<Panel>,
ui: UiState,
/// Capability `render`'s HUD shapes, drawn until replaced.
shapes: Vec<Shape>,
input: InputState,
/// Capability `storage`'s folder; made on first `set`.
data_dir: PathBuf,
/// Bytes `storage::set` may still write before this hook call ends
@@ -234,6 +259,8 @@ impl Mods {
.map_err(|e| e.to_string())?;
UiHost::add_to_linker::<State, HasSelf<State>>(&mut linker, |s| s)
.map_err(|e| e.to_string())?;
RenderHost::add_to_linker::<State, HasSelf<State>>(&mut linker, |s| s)
.map_err(|e| e.to_string())?;
self.engine = Some((engine, linker));
}
Ok(self.engine.as_ref().expect("made above"))
@@ -293,6 +320,8 @@ impl Mods {
out: Vec::new(),
panel: None,
ui: UiState::default(),
shapes: Vec::new(),
input: InputState::default(),
data_dir,
storage_budget: STORAGE_WRITE_BUDGET,
limits: StoreLimitsBuilder::new()
@@ -484,6 +513,86 @@ impl Mods {
.iter()
.filter_map(|e| e.run.as_ref()?.store.data().panel.as_ref())
}
/// Some running mod claimed items (capability `input`).
pub fn claims_any(&self) -> bool {
self.inputs().any(|i| !i.claimed.is_empty())
}
/// Some running mod claimed the item `id`.
pub fn claims(&self, id: &str) -> bool {
self.inputs().any(|i| i.claimed.iter().any(|c| c == id))
}
/// Some running mod registered a key.
pub fn has_keys(&self) -> bool {
self.inputs().any(|i| !i.keys.is_empty())
}
/// The mods' keys: (mod name, key name, label, key), for Controls.
pub fn mod_keys(&self) -> impl Iterator<Item = (&str, &ModKey)> {
self.entries
.iter()
.filter_map(|e| e.run.as_ref())
.flat_map(|r| {
let d = r.store.data();
d.input.keys.iter().map(move |k| (d.name.as_str(), k))
})
}
/// The use button went down with `item`: `use-start` to each mod that
/// claimed it.
pub fn use_start(&mut self, item: &HeldItem) {
let event = InputEvent::UseStart(ItemUse {
item: item.clone(),
ticks: 0,
});
self.push_input(|i| i.claimed.contains(&item.id), &event);
}
/// The claimed use ended after `ticks`.
pub fn use_stop(&mut self, item: &HeldItem, ticks: u32) {
let event = InputEvent::UseStop(ItemUse {
item: item.clone(),
ticks,
});
self.push_input(|i| i.claimed.contains(&item.id), &event);
}
/// The key `key` (`key.keyboard.r`) went down or up: each mod with a
/// key on it hears its own name for it.
pub fn key(&mut self, key: &str, down: bool) {
for run in self.entries.iter_mut().filter_map(|e| e.run.as_mut()) {
let input = &mut run.store.data_mut().input;
let names: Vec<String> = input
.keys
.iter()
.filter(|k| k.key == key)
.map(|k| k.name.clone())
.collect();
for name in names {
input.push(if down {
InputEvent::KeyDown(name)
} else {
InputEvent::KeyUp(name)
});
}
}
}
fn inputs(&self) -> impl Iterator<Item = &InputState> {
self.entries
.iter()
.filter_map(|e| Some(&e.run.as_ref()?.store.data().input))
}
fn push_input(&mut self, to: impl Fn(&InputState) -> bool, event: &InputEvent) {
for run in self.entries.iter_mut().filter_map(|e| e.run.as_mut()) {
let input = &mut run.store.data_mut().input;
if to(input) {
input.push(event.clone());
}
}
}
/// The running mods' HUD shapes (capability `render`), each mod's in
/// its own order, mods in load order.
pub fn hud_shapes(&self) -> impl Iterator<Item = &Shape> {
self.entries
.iter()
.filter_map(|e| e.run.as_ref())
.flat_map(|r| &r.store.data().shapes)
}
/// The screen mod `i` last pushed with `ui.open-screen`, while it is up.
pub fn screen(&self, i: usize) -> Option<&UiScreen> {
self.entries
@@ -671,6 +780,131 @@ impl chat::Host for State {
}
}
}
/// A key a mod registered (capability `input`).
#[derive(Clone, Debug, PartialEq)]
pub struct ModKey {
/// The mod's own name for it, echoed in `key-down`.
pub name: String,
/// What it does, for Controls.
pub label: String,
/// `key.keyboard.r`.
pub key: String,
}
/// What capability `input` holds for one mod.
#[derive(Default)]
struct InputState {
claimed: Vec<String>,
keys: Vec<ModKey>,
events: std::collections::VecDeque<InputEvent>,
}
/// Events kept for `poll`, items claimed and keys, per mod.
const INPUT_EVENTS: usize = 256;
const CLAIMS: usize = 64;
const KEYS: usize = 16;
/// `key.keyboard.<name>` or `key.mouse.<name>`, as options.txt writes keys;
/// the game knows which names exist and ignores a key it has none for.
fn key_ok(key: &str) -> bool {
let rest = key
.strip_prefix("key.keyboard.")
.or_else(|| key.strip_prefix("key.mouse."));
rest.is_some_and(|r| {
(1..=32).contains(&r.len())
&& r.bytes()
.all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'.')
})
}
impl InputState {
fn push(&mut self, event: InputEvent) {
if self.events.len() == INPUT_EVENTS {
self.events.pop_front();
}
self.events.push_back(event);
}
}
impl input::Host for State {
fn claim_items(&mut self, ids: Vec<String>) {
self.input.claimed = ids.into_iter().take(CLAIMS).map(clip).collect();
}
fn register_key(&mut self, name: String, label: String, key: String) -> Result<(), String> {
if !key_ok(&key) {
return Err(format!(
"{key:?} is not a key as options.txt writes them (key.keyboard.r)"
));
}
let (name, label) = (clip(name), clip(label));
if let Some(k) = self.input.keys.iter_mut().find(|k| k.name == name) {
(k.label, k.key) = (label, key);
return Ok(());
}
if self.input.keys.len() == KEYS {
return Err(format!("a mod may register {KEYS} keys"));
}
self.input.keys.push(ModKey { name, label, key });
Ok(())
}
fn held(&mut self) -> Option<HeldItem> {
self.snapshot.held.clone()
}
fn poll(&mut self) -> Vec<InputEvent> {
self.input.events.drain(..).collect()
}
}
/// HUD shapes one mod may keep (capability `render`).
const SHAPES: usize = 1024;
/// The longest jolt `render.shake` makes, in seconds.
const SHAKE_SECONDS: f32 = 10.0;
impl render::Host for State {
fn set_hud(&mut self, shapes: Vec<Shape>) {
self.shapes = shapes
.into_iter()
.take(SHAPES)
.map(|shape| match shape {
Shape::Sprite(mut s) => {
s.sprite = clip(s.sprite);
Shape::Sprite(s)
}
Shape::Item(mut i) => {
i.item = clip(i.item);
i.scale = if i.scale.is_finite() {
i.scale.clamp(0.0, 16.0)
} else {
1.0
};
Shape::Item(i)
}
Shape::Text(mut t) => {
t.text = clip(t.text);
t.color &= 0xFF_FFFF;
Shape::Text(t)
}
other => other,
})
.collect();
}
fn gui_size(&mut self) -> (f32, f32) {
self.snapshot.gui_size
}
fn shake(&mut self, strength: f32, seconds: f32) {
let ok = |v: f32, max: f32| {
if v.is_finite() {
v.clamp(0.0, max)
} else {
0.0
}
};
let (strength, seconds) = (ok(strength, 1.0), ok(seconds, SHAKE_SECONDS));
if strength > 0.0 && seconds > 0.0 {
self.out.push(Output::Shake { strength, seconds });
}
}
}
impl command::Host for State {
fn run(&mut self, line: String) {
let queued = self
+96 -3
View File
@@ -2,7 +2,8 @@
//! examples and a guest
//! that misbehaves on command. Needs `rustup target add wasm32-unknown-unknown`.
use horizon_mods::{
Clock, Corner, Mods, Output, Package, Player, Snapshot, Status, manifest::componentize,
Clock, Corner, HeldItem, Mods, Output, Package, Player, Shape, Snapshot, Status,
manifest::componentize,
};
use std::{
path::{Path, PathBuf},
@@ -23,8 +24,8 @@ id = "test_ui_guest"
name = "Test UI Guest"
version = "0.1.0"
api = "0.1"
capabilities = ["chat", "ui"]
experimental = ["ui"]
capabilities = ["chat", "ui", "render", "input"]
experimental = ["ui", "render", "input"]
"#;
/// Builds the mods once and writes their `.hmod` files; returns the folder.
@@ -96,6 +97,8 @@ fn player() -> Snapshot {
game_time: 100,
day_time: 24000 + 6000,
}),
gui_size: (427.0, 240.0),
held: None,
}
}
@@ -453,6 +456,96 @@ fn ui_screens_settings_and_events() {
assert!(mods.screen(0).is_none());
}
#[test]
fn render_shapes_and_shakes() {
let mut mods = load("horizon_mods_test_ui_guest.hmod");
mods.set_snapshot(Snapshot {
gui_size: (427.0, 240.0),
held: None,
..Snapshot::default()
});
assert_eq!(mods.hud_shapes().count(), 0);
assert!(mods.command("render_hud"));
let shapes: Vec<_> = mods.hud_shapes().cloned().collect();
assert_eq!(shapes.len(), 5);
// The guest read `gui-size`; text is clipped to 256 characters.
let Shape::Text(t) = &shapes[4] else {
panic!("{:?}", shapes[4])
};
assert!(t.text.starts_with("gui 427x240 "), "{}", t.text);
assert_eq!(t.text.chars().count(), 256);
assert!(mods.command("render_clear"));
assert_eq!(mods.hud_shapes().count(), 0);
// One jolt, clamped; zero and NaN shake nothing.
mods.drain();
assert!(mods.command("render_shake"));
assert_eq!(
mods.drain(),
[Output::Shake {
strength: 1.0,
seconds: 10.0
}]
);
}
#[test]
fn input_claims_keys_and_events() {
let mut mods = load("horizon_mods_test_ui_guest.hmod");
let chat = |mods: &mut Mods| -> Vec<String> {
mods.drain()
.into_iter()
.filter_map(|o| match o {
Output::Chat { text, .. } => Some(text),
_ => None,
})
.collect()
};
assert!(!mods.claims_any() && !mods.has_keys());
assert!(mods.command("input_claim"));
let said = chat(&mut mods);
assert!(
said[0].starts_with("claimed; \"R\" is not a key"),
"{said:?}"
);
assert!(mods.claims("minecraft:stick") && !mods.claims("minecraft:stone"));
let keys: Vec<_> = mods
.mod_keys()
.map(|(m, k)| (m.to_owned(), k.key.clone()))
.collect();
assert_eq!(
keys,
[("Test UI Guest".to_owned(), "key.keyboard.r".to_owned())]
);
// The game feeds the events; the mod reads them in order with `poll`.
let stick = HeldItem {
id: "minecraft:stick".into(),
count: 3,
slot: 2,
};
mods.use_start(&stick);
mods.key("key.keyboard.r", true);
mods.key("key.keyboard.t", true);
mods.key("key.keyboard.r", false);
mods.use_stop(&stick, 12);
assert!(mods.command("input_poll"));
assert_eq!(
chat(&mut mods),
[
"use-start minecraft:stick 0",
"key-down wheel",
"key-up wheel",
"use-stop minecraft:stick 12"
]
);
// `held` reads the snapshot.
mods.set_snapshot(Snapshot {
held: Some(stick),
..Snapshot::default()
});
assert!(mods.command("input_held"));
assert_eq!(chat(&mut mods), ["holding minecraft:stick x3 in 2"]);
}
#[test]
fn content_only_mods_load_without_an_engine() {
let manifest = r#"
+96 -3
View File
@@ -1,11 +1,63 @@
//! A mod for the runtime's `ui` tests: `/ui_screen` opens a screen with one
//! of each widget, `/ui_settings` sets a settings page, `/ui_close` closes
//! the screen; the `ui-events` calls answer in chat so the host sees them.
//! `/render_hud`, `/render_clear` and `/render_shake` test `render`;
//! `/input_claim`, `/input_poll` and `/input_held` test `input`.
use horizon_mod_sdk::{
Mod, Registration, chat,
input::{self, Event},
render::{self, FillShape, ItemShape, Point, QuadShape, Rect, Shape, SpriteShape, TextShape},
ui::{self, ItemWidget, ListWidget, Screen, TextWidget, Widget},
};
/// One of each shape, the text too long by 44 characters.
fn shapes() -> Vec<Shape> {
let (w, h) = render::gui_size();
let p = |x, y| Point { x, y };
vec![
Shape::Fill(FillShape {
rect: Rect {
x: 4.0,
y: 4.0,
w: 60.0,
h: 20.0,
},
color: 0x80FF0000,
}),
Shape::Quad(QuadShape {
corners: (
p(w / 2.0, 10.0),
p(w / 2.0 + 20.0, 30.0),
p(w / 2.0, 50.0),
p(w / 2.0 - 20.0, 30.0),
),
color: 0xC000FF00,
}),
Shape::Sprite(SpriteShape {
sprite: "hud/heart/full".into(),
rect: Rect {
x: 70.0,
y: 4.0,
w: 18.0,
h: 18.0,
},
color: 0xFFFFFFFF,
}),
Shape::Item(ItemShape {
item: "minecraft:diamond".into(),
at: p(92.0, 4.0),
scale: 2.0,
}),
Shape::Text(TextShape {
text: format!("gui {w}x{h} {}", "x".repeat(300)),
at: p(w / 2.0, h / 2.0 - 30.0),
color: 0xFFFF55,
centered: true,
shadow: true,
}),
]
}
struct Guest;
fn widgets() -> Vec<Widget> {
@@ -30,9 +82,19 @@ fn widgets() -> Vec<Widget> {
impl Mod for Guest {
fn init() -> Result<(Self, Registration), String> {
let hooks = ["ui_screen", "ui_settings", "ui_close"]
.into_iter()
.fold(Registration::new(), Registration::command);
let hooks = [
"ui_screen",
"ui_settings",
"ui_close",
"render_hud",
"render_clear",
"render_shake",
"input_claim",
"input_poll",
"input_held",
]
.into_iter()
.fold(Registration::new(), Registration::command);
Ok((Guest, hooks))
}
fn command(&mut self, name: &str, _args: &str) -> Result<Option<String>, String> {
@@ -43,6 +105,37 @@ impl Mod for Guest {
}),
"ui_settings" => ui::set_settings(&widgets()),
"ui_close" => ui::close_screen(),
"render_hud" => render::set_hud(&shapes()),
"render_clear" => render::set_hud(&[]),
"input_claim" => {
input::claim_items(&["minecraft:stick".into()]);
input::register_key("wheel", "Open the wheel", "key.keyboard.r")?;
// Not a key: refused.
let bad = input::register_key("bad", "Bad", "R").unwrap_err();
chat::show(&format!("claimed; {bad}"));
}
"input_poll" => {
for event in input::poll() {
chat::show(&match event {
Event::UseStart(u) => format!("use-start {} {}", u.item.id, u.ticks),
Event::UseStop(u) => format!("use-stop {} {}", u.item.id, u.ticks),
Event::KeyDown(k) => format!("key-down {k}"),
Event::KeyUp(k) => format!("key-up {k}"),
});
}
}
"input_held" => {
let held = input::held().map_or("nothing".into(), |h| {
format!("{} x{} in {}", h.id, h.count, h.slot)
});
chat::show(&format!("holding {held}"));
}
// Clamped to (1, 10); the two after it shake nothing.
"render_shake" => {
render::shake(2.0, 99.0);
render::shake(0.0, 1.0);
render::shake(f32::NAN, 1.0);
}
_ => {}
}
Ok(None)
+4
View File
@@ -6,11 +6,15 @@ license = "MIT"
description = "Prepares Horizon's resources from the player's own Minecraft: imports and checks the pinned jars, runs the vanilla exporters, writes the resource folder"
[dependencies]
crc32fast = "1"
regex = { version = "1", default-features = false, features = ["std", "unicode-perl"] }
sha1 = "0.10"
sha2 = "0.10"
zip = { version = "2", default-features = false, features = ["deflate"] }
[target.'cfg(any(target_os = "linux", target_os = "macos"))'.dependencies]
libc = "0.2"
[build-dependencies]
sha2 = "0.10"
+35 -43
View File
@@ -143,31 +143,17 @@ pub(crate) fn import_copy(
algorithm: &str,
hint: &str,
) -> Result<PathBuf, String> {
fs::create_dir_all(destination.parent().unwrap()).map_err(|e| e.to_string())?;
if destination.exists() && digest(destination, algorithm)? == checksum {
return Ok(destination.to_path_buf());
}
if !source.is_file() {
return Err(format!("Missing {}. {hint}", source.display())
.trim()
.to_string());
}
let actual = digest(source, algorithm)?;
if actual != checksum {
return Err(format!(
"{} is not the pinned file: expected {algorithm} {checksum}, got {actual}",
source.display()
));
}
let temporary = destination.with_file_name(format!(
".{}.partial-{}",
destination.file_name().unwrap().to_string_lossy(),
std::process::id()
));
let copied = fs::copy(source, &temporary).and_then(|_| fs::rename(&temporary, destination));
let _ = fs::remove_file(&temporary);
copied.map_err(|e| format!("{}: {e}", destination.display()))?;
Ok(destination.to_path_buf())
crate::files::Import::stage(source, destination, checksum, algorithm, false)
.map_err(|error| {
if !source.is_file() {
format!("Missing {}. {hint}", source.display())
.trim()
.to_string()
} else {
error
}
})?
.commit()
}
/// The pinned version JSON from the launcher's versions/ directory. The launcher's copy wins
@@ -653,9 +639,17 @@ pub struct Artifacts {
/// Reuses checked imports from this root or another installed version beside it.
pub fn reuse_imported(root: &Path, log: Log) -> Result<bool, String> {
Ok(reuse_verified(root, log)?.is_some())
}
/// Keep this preparation's verified artifacts and client libraries for the exporters.
pub(crate) fn reuse_verified(
root: &Path,
log: Log,
) -> Result<Option<(Artifacts, Vec<PathBuf>)>, String> {
let root = fs::canonicalize(root).map_err(|e| format!("{}: {e}", root.display()))?;
let lock = Lock::read(&root)?;
let checked = |directory: PathBuf| -> Result<Vec<PathBuf>, String> {
let checked = |directory: PathBuf| -> Result<(Artifacts, Vec<PathBuf>), String> {
let candidate = Lock {
json: lock.json.clone(),
version: lock.version.clone(),
@@ -664,17 +658,9 @@ pub fn reuse_imported(root: &Path, log: Log) -> Result<bool, String> {
};
let found = verify(&candidate)?;
let client = client_libraries(&candidate, &found.manifest)?;
let mut files = vec![
candidate.directory.join("manifest.json"),
candidate.directory.join("jars/client.jar"),
candidate.directory.join("jars/server.jar"),
found.jars["server"].clone(),
];
files.extend(found.libraries);
files.extend(client);
Ok(files)
Ok((found, client))
};
if checked(lock.directory.clone()).is_ok() {
if let Ok((found, client_libraries)) = checked(lock.directory.clone()) {
if [
"prepared.json",
"reports/client-inventory.json",
@@ -683,8 +669,6 @@ pub fn reuse_imported(root: &Path, log: Log) -> Result<bool, String> {
.iter()
.any(|path| !lock.directory.join(path).is_file())
{
let found = verify(&lock)?;
let client_libraries = client_libraries(&lock, &found.manifest)?;
write_import_metadata(
&root,
&lock,
@@ -696,10 +680,10 @@ pub fn reuse_imported(root: &Path, log: Log) -> Result<bool, String> {
)?;
}
log(&format!("Using imported Minecraft {}", lock.version));
return Ok(true);
return Ok(Some((found, client_libraries)));
}
let Some(versions) = root.parent() else {
return Ok(false);
return Ok(None);
};
// Sibling discovery is intended for the launcher's versions/ folder.
let mut siblings: Vec<_> = fs::read_dir(versions)
@@ -711,9 +695,17 @@ pub fn reuse_imported(root: &Path, log: Log) -> Result<bool, String> {
siblings.sort();
for sibling in siblings {
let source = sibling.join(".local/minecraft").join(&lock.version);
let Ok(files) = checked(source.clone()) else {
let Ok((found, client)) = checked(source.clone()) else {
continue;
};
let mut files = vec![
source.join("manifest.json"),
source.join("jars/client.jar"),
source.join("jars/server.jar"),
found.jars["server"].clone(),
];
files.extend(found.libraries);
files.extend(client);
for file in files {
let relative = file.strip_prefix(&source).map_err(|e| e.to_string())?;
import_copy(
@@ -740,9 +732,9 @@ pub fn reuse_imported(root: &Path, log: Log) -> Result<bool, String> {
lock.version,
sibling.display()
));
return Ok(true);
return Ok(Some((found, client_libraries)));
}
Ok(false)
Ok(None)
}
pub fn verify(lock: &Lock) -> Result<Artifacts, String> {
+218
View File
@@ -0,0 +1,218 @@
//! Only original Horizon classes are packaged. The pinned jars remain player supplied.
use crate::*;
const SETTINGS: &str = "exporters-v1 --release -proc:none -encoding UTF-8";
const SERVER: &[&str] = &[
"VanillaHeightmapOracle",
"VanillaBlockLandingOracle",
"VanillaEntityAttributeOracle",
"VanillaPlayerHealthOracle",
"VanillaDamageSourceOracle",
"VanillaCollisionOracle",
"VanillaFaceVisibilityOracle",
"VanillaGameplayFactsExporter",
"VanillaEntityTypesExporter",
"VanillaBlockBehaviourExporter",
"VanillaCommandParseOracle",
"VanillaCreativeTabsExporter",
"VanillaSimpleBlockOracle",
"VanillaStructureBlockExporter",
"PrepareWorker",
];
const CLIENT: &[&str] = &[
"VanillaBlockStateBindingOracle",
"VanillaEntityModelExporter",
"VanillaMobDataExporter",
"PrepareWorker",
];
fn files(dir: &Path) -> Result<Vec<PathBuf>, String> {
let mut result = Vec::new();
for entry in fs::read_dir(dir).map_err(|e| format!("{}: {e}", dir.display()))? {
let path = entry.map_err(|e| e.to_string())?.path();
if path.is_dir() {
result.extend(files(&path)?);
} else {
result.push(path);
}
}
result.sort();
Ok(result)
}
// research-lock pins both jars and every accepted client manifest (which pins its libraries).
// artifacts::verify/client_libraries check those dependencies before any bundle is used.
fn key(root: &Path) -> Result<String, String> {
let mut hash = sha2::Sha256::new();
hash.update(SETTINGS);
// The launcher's bundled preparer may differ from the selected game's. Hash that
// version's compiler settings so a newer release still selects a runtime correctly.
let compiler = fs::read_to_string(root.join("crates/horizon-prepare/src/exporters.rs"))
.unwrap_or_else(|_| include_str!("exporters.rs").into());
hash.update(compiler.replace('\r', ""));
let mut sources = files(&root.join(PARITY))?;
sources.retain(|p| p.extension().is_some_and(|e| e == "java"));
sources.push(root.join("research-lock.json"));
for path in sources {
let data: Vec<_> = read(&path)?.into_iter().filter(|b| *b != b'\r').collect();
hash.update(format!(
"{}\0{}\0",
relative_display(&path, root)?.replace('\\', "/"),
data.len()
));
hash.update(data);
}
Ok(hex(&hash.finalize()))
}
fn outputs(dir: &Path) -> Result<Value, String> {
let mut hashes = Value::Object(Vec::new());
for path in files(dir)? {
if path.extension().is_some_and(|e| e == "class") {
let name = relative_display(&path, dir)?.replace('\\', "/");
// javac's sourcepath contains our sources only; enforce that at packaging too.
if !name.starts_with("server/dev/horizonlab/parity/")
&& !name.starts_with("client/dev/horizonlab/parity/")
{
return Err(format!("Non-Horizon class in exporter bundle: {name}"));
}
hashes.insert(&name, Value::Str(digest(&path, "sha256")?));
}
}
Ok(hashes)
}
fn valid(dir: &Path, key: &str) -> bool {
let Ok(manifest) = read_json(&dir.join("manifest.json")) else {
return false;
};
manifest.get("key").and_then(Value::as_str) == Some(key)
&& outputs(dir).is_ok_and(|hashes| {
!hashes.as_object().unwrap().is_empty() && manifest.get("classes") == Some(&hashes)
})
}
/// Whether the version ships a matching, intact bundle and needs only a Java runtime.
pub fn available(root: &Path) -> bool {
key(root).is_ok_and(|key| valid(&root.join("exporters"), &key))
}
pub(crate) fn classes(run: &Run) -> Result<PathBuf, String> {
let key = key(&run.root)?;
let shipped = run.root.join("exporters");
if valid(&shipped, &key) {
return Ok(shipped);
}
let cached = run.local.join("exporters").join(&key);
if valid(&cached, &key) {
return Ok(cached);
}
// Build privately: an interrupted compiler or another preparer cannot publish partial classes.
let destination = cached;
let cached = run
.local
.join("exporters")
.join(format!(".{key}-{}", std::process::id()));
if cached.exists() {
fs::remove_dir_all(&cached).map_err(|e| e.to_string())?;
}
mkdir(&cached)?;
let jdk = java::find(run.java_major, &[run.jdk.home()])?;
for (side, mains, cp) in [
("server", SERVER, &run.server_classpath),
("client", CLIENT, &run.client_classpath),
] {
(run.log)(&format!("Compiling {side} exporters (shared helpers once)"));
let classes = cached.join(side);
mkdir(&classes)?;
let log = run.log_file(&cached.join(format!("{side}.log")))?;
let mut args = vec![
"-encoding".into(),
"UTF-8".into(),
"-cp".into(),
cp.clone(),
"-sourcepath".into(),
arg(&run.root.join("mods/horizon/src/test/java")),
"-d".into(),
arg(&classes),
];
args.extend(mains.iter().map(|n| arg(&run.oracle(&format!("{n}.java")))));
jdk.javac(run.java_major, &args, &log)?;
let validate = vec![
"-Xverify:all".into(),
"-cp".into(),
format!(
"{}{}{}",
classes.display(),
if cfg!(windows) { ";" } else { ":" },
cp
),
"dev.horizonlab.parity.PrepareWorker".into(),
"validate".into(),
arg(&classes),
];
// No exporter executes here: resolve every class and its signatures against pinned jars.
run.jdk.java(&validate, None, &log)?;
}
let manifest = Value::Object(vec![
("key".into(), Value::Str(key.clone())),
("classes".into(), outputs(&cached)?),
]);
write_json(&cached.join("manifest.json"), &manifest)?;
if valid(&destination, &key) {
fs::remove_dir_all(&cached).map_err(|e| e.to_string())?;
} else {
if destination.exists() {
fs::remove_dir_all(&destination).map_err(|e| e.to_string())?;
}
fs::rename(&cached, &destination).map_err(|e| e.to_string())?;
}
Ok(destination)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn bundles_invalidate_sources_pins_and_damaged_classes() {
let root = std::env::temp_dir().join(format!("prepare-bundle-{}", std::process::id()));
let source = root.join(PARITY).join("VanillaHeightmapOracle.java");
mkdir(source.parent().unwrap()).unwrap();
write(&source, b"original\n").unwrap();
let compiler = root.join("crates/horizon-prepare/src/exporters.rs");
mkdir(compiler.parent().unwrap()).unwrap();
write(&compiler, b"--release 25 -proc:none").unwrap();
write(&root.join("research-lock.json"), b"pins").unwrap();
let original = key(&root).unwrap();
write(&compiler, b"--release 26 -proc:none").unwrap();
assert_ne!(key(&root).unwrap(), original);
write(&compiler, b"--release 25 -proc:none").unwrap();
write(&source, b"original\r\n").unwrap();
assert_eq!(key(&root).unwrap(), original);
write(&source, b"changed").unwrap();
assert_ne!(key(&root).unwrap(), original);
write(&source, b"original\n").unwrap();
write(&root.join("research-lock.json"), b"new dependencies").unwrap();
assert_ne!(key(&root).unwrap(), original);
write(&root.join("research-lock.json"), b"pins").unwrap();
let bundle = root.join("exporters");
let class = bundle.join("server/dev/horizonlab/parity/Helper.class");
mkdir(class.parent().unwrap()).unwrap();
write(&class, b"compiled").unwrap();
write_json(
&bundle.join("manifest.json"),
&Value::Object(vec![
("key".into(), Value::Str(original)),
("classes".into(), outputs(&bundle).unwrap()),
]),
)
.unwrap();
assert!(available(&root));
write(&class, b"damaged").unwrap();
assert!(!available(&root));
fs::remove_file(&class).unwrap();
assert!(!available(&root));
fs::remove_dir_all(root).unwrap();
}
}
+180
View File
@@ -0,0 +1,180 @@
//! Independent copies, using filesystem cloning when available. Never hard links: exporters
//! rewrite prepared resources in place. Checked imports publish only after verifying the copy.
use crate::{digest, hex};
use sha2::Digest;
use std::fs;
use std::io::{self, Read, Write};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicUsize, Ordering};
fn clone_file(from: &Path, to: &Path) -> io::Result<()> {
#[cfg(target_os = "linux")]
{
use std::os::fd::AsRawFd;
let source = fs::File::open(from)?;
let target = fs::File::create(to)?;
// SAFETY: FICLONE takes a source fd, both descriptors stay open for the call.
if unsafe { libc::ioctl(target.as_raw_fd(), libc::FICLONE, source.as_raw_fd()) } == 0 {
return Ok(());
}
Err(io::Error::last_os_error())
}
#[cfg(target_os = "macos")]
{
use std::ffi::CString;
use std::os::unix::ffi::OsStrExt;
let path = |p: &Path| {
CString::new(p.as_os_str().as_bytes())
.map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))
};
let (source, target) = (path(from)?, path(to)?);
// SAFETY: both paths are valid NUL-terminated strings for the duration of the call.
if unsafe { libc::clonefile(source.as_ptr(), target.as_ptr(), 0) } == 0 {
return Ok(());
}
Err(io::Error::last_os_error())
}
#[cfg(not(any(target_os = "linux", target_os = "macos")))]
{
let _ = (from, to);
Err(io::ErrorKind::Unsupported.into())
}
}
/// Copies an independent file, attempting a reflink first. The destination may be replaced.
pub fn clone_or_copy(from: &Path, to: &Path) -> io::Result<()> {
clone_file(from, to).or_else(|_| fs::copy(from, to).map(|_| ()))
}
fn copy_hash<D: Digest>(from: &Path, to: &Path) -> io::Result<String> {
let mut source = fs::File::open(from)?;
let mut target = fs::File::create(to)?;
let mut hash = D::new();
let mut buffer = vec![0; 64 * 1024];
loop {
let n = source.read(&mut buffer)?;
if n == 0 {
return Ok(hex(&hash.finalize()));
}
target.write_all(&buffer[..n])?;
hash.update(&buffer[..n]);
}
}
/// A verified replacement staged beside its destination. Dropping an unfinished set cleans
/// every temporary file, so a corrupt late panorama face cannot replace earlier placeholders.
pub(crate) struct Import {
temporary: Option<PathBuf>,
destination: PathBuf,
}
impl Import {
pub(crate) fn stage(
source: &Path,
destination: &Path,
checksum: &str,
algorithm: &str,
verified: bool,
) -> Result<Self, String> {
let mut import = Self {
temporary: None,
destination: destination.into(),
};
if verified || (destination.is_file() && digest(destination, algorithm)? == checksum) {
return Ok(import);
}
fs::create_dir_all(destination.parent().unwrap()).map_err(|e| e.to_string())?;
static COPIES: AtomicUsize = AtomicUsize::new(0);
let temporary = destination.with_file_name(format!(
".{}.partial-{}-{}",
destination.file_name().unwrap().to_string_lossy(),
std::process::id(),
COPIES.fetch_add(1, Ordering::Relaxed)
));
import.temporary = Some(temporary.clone());
let actual = if clone_file(source, &temporary).is_ok() {
digest(&temporary, algorithm)?
} else {
match algorithm {
"sha1" => copy_hash::<sha1::Sha1>(source, &temporary),
_ => copy_hash::<sha2::Sha256>(source, &temporary),
}
.map_err(|e| format!("{}: {e}", source.display()))?
};
if actual != checksum {
return Err(format!(
"{} is not the pinned file: expected {algorithm} {checksum}, got {actual}",
source.display()
));
}
Ok(import)
}
pub(crate) fn commit(mut self) -> Result<PathBuf, String> {
if let Some(temporary) = &self.temporary {
fs::rename(temporary, &self.destination)
.map_err(|e| format!("{}: {e}", self.destination.display()))?;
}
self.temporary = None;
Ok(self.destination.clone())
}
}
impl Drop for Import {
fn drop(&mut self) {
if let Some(temporary) = &self.temporary {
let _ = fs::remove_file(temporary);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn copies_are_independent_and_checked_before_publication() {
let dir = std::env::temp_dir().join(format!("horizon-file-copy-{}", std::process::id()));
fs::create_dir_all(&dir).unwrap();
let source = dir.join("source");
let target = dir.join("target");
let data = vec![42; 200_000]; // More than one streaming buffer.
fs::write(&source, &data).unwrap();
for algorithm in ["sha1", "sha256"] {
let checksum = digest(&source, algorithm).unwrap();
Import::stage(&source, &target, &checksum, algorithm, false)
.unwrap()
.commit()
.unwrap();
assert_eq!(digest(&target, algorithm).unwrap(), checksum);
fs::write(&target, b"old destination").unwrap();
assert_eq!(fs::read(&source).unwrap(), data);
assert!(Import::stage(&source, &target, "bad hash", algorithm, false).is_err());
assert_eq!(fs::read(&target).unwrap(), b"old destination");
// Explicitly exercise ordinary streaming copies even on a reflink filesystem.
let streamed = if algorithm == "sha1" {
copy_hash::<sha1::Sha1>(&source, &target).unwrap()
} else {
copy_hash::<sha2::Sha256>(&source, &target).unwrap()
};
assert_eq!(streamed, checksum);
assert_eq!(fs::read(&target).unwrap(), data);
}
clone_or_copy(&source, &target).unwrap();
fs::write(&target, b"rewrite").unwrap();
assert_eq!(fs::read(&source).unwrap(), data);
let staged = Import::stage(
&source,
&target,
&digest(&source, "sha1").unwrap(),
"sha1",
false,
)
.unwrap();
assert_eq!(fs::read_dir(&dir).unwrap().count(), 3);
drop(staged);
assert_eq!(fs::read_dir(&dir).unwrap().count(), 2);
fs::remove_dir_all(dir).unwrap();
}
}
+28 -17
View File
@@ -1,4 +1,4 @@
//! The JDK that compiles and runs the vanilla exporters. They call Mojang's own code, so they
//! Java discovery and execution for the vanilla exporters. They call Mojang's own code, so they
//! stay Java; everything around them is here.
use std::ffi::OsStr;
@@ -15,7 +15,7 @@ pub struct Jdk {
const TIMEOUT: Duration = Duration::from_secs(3600);
/// Exporters and JDK probes write to pipes or log files: on Windows they open no terminal.
fn command(program: impl AsRef<OsStr>) -> Command {
pub(crate) fn command(program: impl AsRef<OsStr>) -> Command {
let command = Command::new(program);
#[cfg(windows)]
let command = {
@@ -56,9 +56,9 @@ fn without_verbatim(path: PathBuf) -> PathBuf {
/// Resolve compiler symlinks before picking its sibling runtime. The first `java` on the
/// PATH may be an older, runtime-only install; it must not be paired with a newer `javac`.
fn path_jdks(path: &OsStr) -> Vec<PathBuf> {
fn path_homes(path: &OsStr, tool: &str) -> Vec<PathBuf> {
std::env::split_paths(path)
.map(|dir| executable(&dir, "javac"))
.map(|dir| executable(&dir, tool))
.filter(|javac| javac.is_file())
.map(real_path)
.filter_map(|javac| {
@@ -162,7 +162,7 @@ fn jdk_parents() -> Vec<PathBuf> {
/// The JDKs (folders with `bin/javac`) one level below `parents`; a macOS bundle's home is
/// its `Contents/Home`. Those named for `major` come first, then the others newest name first.
fn installed_jdks(parents: &[PathBuf], major: i64) -> Vec<PathBuf> {
fn installed_jdks(parents: &[PathBuf], major: i64, tool: &str) -> Vec<PathBuf> {
let mut homes: Vec<PathBuf> = parents
.iter()
.filter_map(|parent| fs::read_dir(parent).ok())
@@ -176,7 +176,7 @@ fn installed_jdks(parents: &[PathBuf], major: i64) -> Vec<PathBuf> {
entry.path()
}
})
.filter(|home| executable(&home.join("bin"), "javac").is_file())
.filter(|home| executable(&home.join("bin"), tool).is_file())
.collect();
let named = |home: &Path| {
home.iter().any(|part| {
@@ -191,8 +191,7 @@ fn installed_jdks(parents: &[PathBuf], major: i64) -> Vec<PathBuf> {
}
/// The Java runtimes the official launcher downloaded into `runtime` (a game directory's
/// `runtime` folder: `<component>/<platform>/<component>/`, a macOS one in `jre.bundle`). Mojang's
/// runtimes are whole JDKs, javac included, so a player who has run Minecraft has one already.
/// `runtime` folder: `<component>/<platform>/<component>/`, a macOS one in `jre.bundle`).
pub fn minecraft_runtimes(runtime: &Path) -> Vec<PathBuf> {
let children = |dir: &Path| -> Vec<PathBuf> {
let mut paths: Vec<PathBuf> = fs::read_dir(dir)
@@ -206,7 +205,7 @@ pub fn minecraft_runtimes(runtime: &Path) -> Vec<PathBuf> {
for platform in children(&component) {
let home = platform.join(component.file_name().unwrap_or_default());
for home in [home.join("jre.bundle/Contents/Home"), home] {
if executable(&home.join("bin"), "javac").is_file() {
if executable(&home.join("bin"), "java").is_file() {
homes.push(home);
break;
}
@@ -221,8 +220,18 @@ pub fn minecraft_runtimes(runtime: &Path) -> Vec<PathBuf> {
/// `/usr/libexec/java_home -v <major>` reports, else the homes in `more` (the launcher's pick,
/// Minecraft's own runtimes), else the folders installers use (`jdk_parents`).
pub fn find(major: i64, more: &[PathBuf]) -> Result<Jdk, String> {
find_tools(major, more, true)
}
/// Finds a compatible runtime; precompiled exporters do not need javac.
pub fn find_runtime(major: i64, more: &[PathBuf]) -> Result<Jdk, String> {
find_tools(major, more, false)
}
fn find_tools(major: i64, more: &[PathBuf], compiler: bool) -> Result<Jdk, String> {
let tool = if compiler { "javac" } else { "java" };
let need = format!(
"Java {major} is needed (a JDK with javac, e.g. Eclipse Temurin {major}). \
"Java {major} is needed ({tool}, e.g. Eclipse Temurin {major}). \
Install it, or set JAVA_HOME to it, and try again."
);
let mut candidates = Vec::new();
@@ -235,7 +244,7 @@ pub fn find(major: i64, more: &[PathBuf]) -> Result<Jdk, String> {
));
}
if let Some(path) = std::env::var_os("PATH") {
for home in path_jdks(&path) {
for home in path_homes(&path, tool) {
let bin = home.join("bin");
candidates.push((executable(&bin, "javac"), executable(&bin, "java"), "PATH"));
}
@@ -265,7 +274,7 @@ pub fn find(major: i64, more: &[PathBuf]) -> Result<Jdk, String> {
"Minecraft's Java",
));
}
for home in installed_jdks(&jdk_parents(), major) {
for home in installed_jdks(&jdk_parents(), major, tool) {
let bin = home.join("bin");
candidates.push((
executable(&bin, "javac"),
@@ -275,15 +284,16 @@ pub fn find(major: i64, more: &[PathBuf]) -> Result<Jdk, String> {
}
let mut problems = Vec::new();
for (javac, java, from) in candidates {
if !javac.is_file() || !java.is_file() {
if (compiler && !javac.is_file()) || !java.is_file() {
problems.push(format!(
"{from} ({}) has no javac and java",
"{from} ({}) has no compatible Java tools",
javac.parent().unwrap().display()
));
continue;
}
let checked = [(&javac, "javac"), (&java, "java")]
.into_iter()
.filter(|(_, name)| compiler || *name == "java")
.try_for_each(|(program, name)| {
let found = tool_major(program, name)?;
if i64::from(found) >= major {
@@ -298,7 +308,7 @@ pub fn find(major: i64, more: &[PathBuf]) -> Result<Jdk, String> {
}
}
if problems.is_empty() {
Err(format!("{need} No javac was found."))
Err(format!("{need} No {tool} was found."))
} else {
Err(format!("{need} Found: {}.", problems.join("; ")))
}
@@ -317,7 +327,7 @@ pub fn classpath<'a>(paths: impl IntoIterator<Item = &'a Path>) -> String {
impl Jdk {
/// The JDK's home, the folder above `bin` (what `JAVA_HOME` names).
pub fn home(&self) -> PathBuf {
self.javac
self.java
.parent()
.and_then(Path::parent)
.map(Path::to_path_buf)
@@ -424,6 +434,7 @@ mod tests {
dir.join("missing"),
],
25,
"javac",
);
assert_eq!(
found,
@@ -445,7 +456,7 @@ mod tests {
let make = |home: PathBuf, javac: bool| {
fs::create_dir_all(home.join("bin")).unwrap();
if javac {
fs::write(executable(&home.join("bin"), "javac"), b"").unwrap();
fs::write(executable(&home.join("bin"), "java"), b"").unwrap();
}
home
};
+123 -67
View File
@@ -11,12 +11,16 @@
//! run, keyed by the sha256 of their inputs and outputs recorded in the manifest, as before.
pub mod artifacts;
pub mod exporters;
mod files;
mod inventory;
pub mod java;
pub mod pyjson;
mod sounds;
mod survival;
mod worker;
pub use files::clone_or_copy;
pub use sounds::{fonts, languages, packs, panorama, sounds, BUILT_IN_PACKS};
use pyjson::Value;
@@ -74,7 +78,7 @@ pub fn sources_sha256(crate_dir: &Path) -> Option<String> {
pub struct Options {
/// The version folder (a release folder, or a checkout): research-lock.json, the exporters'
/// Java sources, and `.local/` where everything is written.
/// Java sources, optional precompiled `exporters/`, and `.local/` where everything is written.
pub root: PathBuf,
/// Import the pinned game files from the player's own copy first (`--prepare`).
pub import: bool,
@@ -83,7 +87,7 @@ pub struct Options {
pub minecraft_dir: Option<PathBuf>,
/// The pinned server jar the player downloaded (`--server-jar`, else HORIZON_SERVER_JAR).
pub server_jar: Option<PathBuf>,
/// The JDK to try after JAVA_HOME and the PATH (the launcher's pick, e.g. Minecraft's
/// The Java runtime to try after JAVA_HOME and the PATH (the launcher's pick, e.g. Minecraft's
/// own Java it downloaded from Mojang).
pub java_home: Option<PathBuf>,
}
@@ -302,6 +306,8 @@ struct Run<'a> {
server_classpath: String,
/// The client jar and its libraries: the classpath of the client-side exporters.
client_classpath: String,
bundles: std::cell::OnceCell<PathBuf>,
workers: std::cell::RefCell<[Option<worker::Worker>; 2]>,
previous: Value,
origin: Value,
log: Log<'a>,
@@ -310,6 +316,13 @@ struct Run<'a> {
const PARITY: &str = "mods/horizon/src/test/java/dev/horizonlab/parity";
impl Run<'_> {
fn bundle(&self) -> Result<&Path, String> {
if self.bundles.get().is_none() {
self.bundles.set(exporters::classes(self)?).unwrap();
}
Ok(self.bundles.get().unwrap())
}
fn oracle(&self, name: &str) -> PathBuf {
self.root.join(PARITY).join(name)
}
@@ -342,33 +355,31 @@ impl Run<'_> {
fs::File::create(path).map_err(|e| format!("{}: {e}", path.display()))
}
/// `javac --release <major> -proc:none -cp <classpath> [extra] -d <classes> <sources>`.
fn compile(
&self,
classpath: &str,
extra: &[String],
classes: &Path,
sources: &[&Path],
log: &fs::File,
) -> Result<(), String> {
let mut args = vec!["-cp".to_string(), classpath.to_string()];
args.extend_from_slice(extra);
args.push("-d".into());
args.push(classes.display().to_string());
args.extend(sources.iter().map(|s| s.display().to_string()));
self.jdk.javac(self.java_major, &args, log)
}
/// `java -Xmx<heap> -cp <classes>:<classpath> dev.horizonlab.parity.<main> <args>`.
fn run(
&self,
heap: &str,
classes: &Path,
classpath: &str,
main: &str,
args: &[String],
log: &fs::File,
log_path: &Path,
) -> Result<(), String> {
let side = usize::from(classpath == self.client_classpath);
let classes = self
.bundle()?
.join(if side == 1 { "client" } else { "server" });
if !matches!(
main,
"VanillaCommandParseOracle" | "VanillaCreativeTabsExporter"
) && std::env::var_os("HORIZON_PREPARE_ISOLATED").is_none()
{
let mut workers = self.workers.borrow_mut();
if workers[side].is_none() {
workers[side] = Some(worker::Worker::new(self, &classes, classpath)?);
}
return workers[side].as_mut().unwrap().run(main, args, log_path);
}
let separator = if cfg!(windows) { ";" } else { ":" };
let mut all = vec![
format!("-Xmx{heap}"),
@@ -380,7 +391,7 @@ impl Run<'_> {
self.jdk.java(&all, None, log)
}
/// Compiles `sources` into `classes` and runs each of `mains` with `args`, their output in
/// Runs each exporter from the verified shared bundle, with output in
/// the log at `log`: the shape of every exporter step.
#[allow(clippy::too_many_arguments)]
fn export(
@@ -388,7 +399,7 @@ impl Run<'_> {
what: &str,
classpath: &str,
classes: &Path,
sources: &[&Path],
_sources: &[&Path],
mains: &[&str],
heap: &str,
args: &[String],
@@ -398,10 +409,8 @@ impl Run<'_> {
mkdir(classes)?;
let file = self.log_file(log)?;
let fail = |e: String| format!("{e} while exporting {what}; see {}", log.display());
self.compile(classpath, &[], classes, sources, &file)
.map_err(fail)?;
for main in mains {
self.run(heap, classes, classpath, main, args, &file)
self.run(heap, classpath, main, args, &file, log)
.map_err(fail)?;
}
Ok(())
@@ -410,6 +419,15 @@ impl Run<'_> {
/// Prepares the resources; returns their folder (`.local/horizon-client/<version>`).
pub fn prepare(options: &Options, log: Log) -> Result<PathBuf, String> {
prepare_impl(options, log, false)
}
/// Release build tool: compile and link-check only Horizon's original exporter classes.
pub fn compile_exporters(options: &Options, log: Log) -> Result<PathBuf, String> {
prepare_impl(options, log, true)
}
fn prepare_impl(options: &Options, log: Log, compile_only: bool) -> Result<PathBuf, String> {
let root = &std::path::absolute(&options.root)
.map_err(|e| format!("{}: {e}", options.root.display()))?;
let lock = artifacts::Lock::read(root)?;
@@ -418,17 +436,29 @@ pub fn prepare(options: &Options, log: Log) -> Result<PathBuf, String> {
homes.extend(java::minecraft_runtimes(
&artifacts::minecraft_dir(options.minecraft_dir.as_deref()).join("runtime"),
));
let jdk = java::find(lock.java_major, &homes)?;
if options.import && !artifacts::reuse_imported(root, log)? {
artifacts::import(
root,
&lock,
options.minecraft_dir.as_deref(),
options.server_jar.as_deref(),
log,
)?;
}
let found = artifacts::verify(&lock)?;
let jdk = java::find_runtime(lock.java_major, &homes)?;
let reused = if options.import {
artifacts::reuse_verified(root, log)?
} else {
None
};
let (found, client_libraries) = match reused {
Some(checked) => checked,
None => {
if options.import {
artifacts::import(
root,
&lock,
options.minecraft_dir.as_deref(),
options.server_jar.as_deref(),
log,
)?;
}
let found = artifacts::verify(&lock)?;
let libraries = artifacts::client_libraries(&lock, &found.manifest)?;
(found, libraries)
}
};
let local = root.join(".local");
let resources = local.join("horizon-client").join(&lock.version);
mkdir(&resources)?;
@@ -454,7 +484,6 @@ pub fn prepare(options: &Options, log: Log) -> Result<PathBuf, String> {
} else {
Value::Object(Vec::new())
};
let client_libraries = artifacts::client_libraries(&lock, &found.manifest)?;
let run = Run {
root: root.clone(),
local,
@@ -465,10 +494,15 @@ pub fn prepare(options: &Options, log: Log) -> Result<PathBuf, String> {
client: found.jars["client"].clone(),
server_classpath: classpath_join(&found.jars["server"], &found.libraries),
client_classpath: classpath_join(&found.jars["client"], &client_libraries),
bundles: std::cell::OnceCell::new(),
workers: std::cell::RefCell::new([None, None]),
previous,
origin,
log,
};
if compile_only {
return Ok(run.bundle()?.to_path_buf());
}
steps(&run, &lock, &oracle, options.minecraft_dir.as_deref())?;
log(&format!(
"Prepared Horizon native-client resources: {}",
@@ -688,25 +722,9 @@ fn steps(
// and every data-pack resource (worldgen, recipes, loot tables, tags), and
// the vanilla pack's icon (`pack.png`) for the pack screen.
(run.log)("Copying the client's assets and data");
let mut count = 0usize;
let mut client = open_zip(&run.client)?;
let version = pyjson::loads(&zip_text(&mut client, "version.json")?)?;
for name in zip_names(&client) {
let wanted = name.starts_with("assets/") || name.starts_with("data/") || name == "pack.png";
if !wanted || name.ends_with('/') {
continue;
}
let relative = member_path(&name, "Invalid resource path")?;
let data = zip_bytes(&mut client, &name)?;
write_if_changed(&root.join(relative), &data)?;
count += 1;
}
// The JAR holds only gray 1x1 panorama placeholders and an empty Unifont
// 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);
let mut indexed = sounds::Assets::load(repo, minecraft, run.log);
let (version, count) = extract_client_resources(&run.client, root, indexed.as_mut().ok())?;
sounds::optional_imports(indexed.as_mut().map_err(|e| e.as_str()), run.log);
// One file each, exported again when the exporter or the jar it reads changed.
let single = |what: &str,
@@ -940,6 +958,54 @@ fn steps(
)
}
/// Check existing JAR assets by their ZIP size/CRC without inflating every member again.
/// Indexed panorama/font/language replacements have stronger SHA-1 checks and take precedence.
fn extract_client_resources(
jar: &Path,
root: &Path,
mut indexed: Option<&mut sounds::Assets>,
) -> Result<(Value, usize), String> {
let mut client = open_zip(jar)?;
let version = pyjson::loads(&zip_text(&mut client, "version.json")?)?;
let mut count = 0;
for name in zip_names(&client) {
if !(name.starts_with("assets/") || name.starts_with("data/") || name == "pack.png")
|| name.ends_with('/')
{
continue;
}
let relative = member_path(&name, "Invalid resource path")?;
count += 1;
if let Some(assets) = &mut indexed {
if assets.imported(&name)? {
continue;
}
}
let target = root.join(relative);
let member = client.by_name(&name).map_err(|e| e.to_string())?;
let (size, crc) = (member.size(), member.crc32());
drop(member);
if target.is_file() && fs::metadata(&target).map_err(|e| e.to_string())?.len() == size {
let mut file = fs::File::open(&target).map_err(|e| e.to_string())?;
let mut hash = crc32fast::Hasher::new();
let mut buffer = [0; 16 * 1024];
loop {
let n = file.read(&mut buffer).map_err(|e| e.to_string())?;
if n == 0 {
break;
}
hash.update(&buffer[..n]);
}
if hash.finalize() == crc {
continue;
}
}
mkdir(target.parent().unwrap())?;
write(&target, &zip_bytes(&mut client, &name)?)?;
}
Ok((version, count))
}
fn datagen_reports_missing(root: &Path) -> bool {
["items.json", "registries.json", "commands.json"]
.iter()
@@ -1126,7 +1192,6 @@ fn prepare_worldgen(run: &Run) -> Result<(), String> {
/// whose blocks are checked for survival or support (trees, flowers, grass, kelp, ...).
fn export_block_behavior(run: &Run, export: &Path) -> Result<(), String> {
(run.log)("Exporting block behavior (VanillaSimpleBlockOracle)");
let tests = run.root.join("mods/horizon/src/test/java");
let classes = export.join("classes");
mkdir(&classes)?;
let log_path = export.join("export.log");
@@ -1137,22 +1202,13 @@ fn export_block_behavior(run: &Run, export: &Path) -> Result<(), String> {
log_path.display()
)
};
// The oracle's helper classes are compiled on demand from the source path.
run.compile(
&run.server_classpath,
&["-sourcepath".into(), arg(&tests)],
&classes,
&[&tests.join("dev/horizonlab/parity/VanillaSimpleBlockOracle.java")],
&log,
)
.map_err(fail)?;
run.run(
"1G",
&classes,
&run.server_classpath,
"VanillaSimpleBlockOracle",
&["export".into(), arg(export)],
&log,
&log_path,
)
.map_err(fail)?;
let rules = survival::bind_definitions(
+7 -3
View File
@@ -16,6 +16,7 @@ const HELP: &str = "\
horizon-prepare: prepare Horizon's resources from your own Minecraft Java Edition
Usage: horizon-prepare [--prepare] [--server-jar PATH] [--minecraft-dir PATH] [--root PATH]
horizon-prepare compile-exporters [--root 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]
@@ -30,8 +31,9 @@ Usage: horizon-prepare [--prepare] [--server-jar PATH] [--minecraft-dir PATH] [-
--root PATH The Horizon folder to prepare (default: the folder this program is
in, else the nearest folder above the current one with research-lock.json)
Needs Minecraft played once from the official launcher, and Java (a JDK) of the version
research-lock.json pins: JAVA_HOME, else javac and java on the PATH.
Needs Minecraft played once from the official launcher, and Java of the version
research-lock.json pins. Releases use a runtime; development or changed exporters need a JDK.
compile-exporters builds and validates a release bundle from the already imported pinned jars.
The resources go to <root>/.local/horizon-client/<version>; pass that to horizon-client --resources.
horizon-prepare panorama repairs the classic menu background in existing resources without Java.
@@ -73,7 +75,7 @@ fn main() -> ExitCode {
let assets = args.next_if(|a| {
matches!(
a.to_str(),
Some("sounds" | "panorama" | "fonts" | "packs" | "languages")
Some("sounds" | "panorama" | "fonts" | "packs" | "languages" | "compile-exporters")
)
});
while let Some(arg) = args.next() {
@@ -132,6 +134,8 @@ fn main() -> ExitCode {
let _ = out.flush();
};
let result = match assets.as_deref().and_then(|a| a.to_str()) {
Some("compile-exporters") => horizon_prepare::compile_exporters(&options, &log)
.inspect(|dir| log(&dir.display().to_string())),
Some("sounds") => {
horizon_prepare::sounds(&options.root, options.minecraft_dir.as_deref(), &log)
}
+294 -68
View File
@@ -5,7 +5,8 @@
use crate::artifacts::{self, Lock};
use crate::pyjson::Value;
use crate::{digest, read_json, Log};
use crate::{digest, Log};
use std::collections::{HashMap, HashSet};
use std::fs;
use std::path::{Path, PathBuf};
@@ -18,8 +19,9 @@ fn launcher_assets(
lock: &Lock,
manifest: &Value,
minecraft: &Path,
cached_index: &Path,
log: Log,
) -> Result<(PathBuf, PathBuf), String> {
) -> Result<(PathBuf, PathBuf, Vec<u8>), String> {
let assets = minecraft.join("assets");
let info = manifest
.get("assetIndex")
@@ -33,7 +35,10 @@ fn launcher_assets(
if artifacts::safe_relative(id).is_none_or(|p| p.components().count() != 1) {
return Err(format!("Unsafe asset index id {id:?}"));
}
let index = assets.join("indexes").join(format!("{id}.json"));
let mut index = assets.join("indexes").join(format!("{id}.json"));
if !index.is_file() && cached_index.is_file() {
index = cached_index.to_path_buf();
}
if !index.is_file() {
let version = manifest.get("id").and_then(Value::as_str).unwrap_or("");
return Err(format!(
@@ -42,7 +47,8 @@ fn launcher_assets(
artifacts::launcher_hint(version)
));
}
let checksum = digest(&index, "sha1")?;
let bytes = fs::read(&index).map_err(|e| format!("{}: {e}", index.display()))?;
let checksum = crate::hex(&<sha1::Sha1 as sha1::Digest>::digest(&bytes));
if checksum != sha1 && !lock.asset_index_accepted(&checksum) {
log(&format!(
"{} is an asset index Horizon does not know yet (sha1 {checksum}); Mojang may have \
@@ -50,7 +56,7 @@ fn launcher_assets(
index.display()
));
}
Ok((assets, index))
Ok((assets, index, bytes))
}
/// Where the launcher's asset store keeps the object with this SHA-1.
@@ -61,24 +67,6 @@ fn object_path(assets: &Path, checksum: &str) -> Result<PathBuf, String> {
Ok(assets.join("objects").join(&checksum[..2]).join(checksum))
}
/// One verified object from the launcher's asset store (tools/lab.py `launcher_object`).
fn launcher_object(assets: &Path, checksum: &str) -> Result<PathBuf, String> {
let path = object_path(assets, checksum)?;
if !path.is_file() {
return Err(format!(
"Missing asset object {}. Play the pinned version once in your launcher.",
path.display()
));
}
if digest(&path, "sha1")? != checksum {
return Err(format!(
"Corrupt asset object {}; let the launcher repair it",
path.display()
));
}
Ok(path)
}
/// Whether the game plays this asset: sounds.json and everything under sounds/.
fn is_sound(name: &str) -> bool {
name == "minecraft/sounds.json" || name.starts_with("minecraft/sounds/")
@@ -127,26 +115,56 @@ fn is_language(name: &str) -> bool {
}
/// Full preparation can run from cached JARs without an official launcher install.
pub(crate) fn optional_assets(root: &Path, minecraft: Option<&Path>, log: Log) {
if let Err(error) = panorama(root, minecraft, log) {
log(&format!(
"Title panorama not imported: {error}; run horizon-prepare panorama later"
));
}
if let Err(error) = fonts(root, minecraft, log) {
log(&format!(
"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"
));
}
if let Err(error) = languages(root, minecraft, log) {
log(&format!(
"Languages not imported: {error}; run horizon-prepare languages later"
));
#[cfg(test)]
fn optional_assets(root: &Path, minecraft: Option<&Path>, log: Log) {
optional_imports(
Assets::load(root, minecraft, log)
.as_mut()
.map_err(|e| e.as_str()),
log,
);
}
pub(crate) fn optional_imports(mut assets: Result<&mut Assets, &str>, log: Log) {
for (wanted, label, required, failure, command) in [
(
is_panorama as fn(&str) -> bool,
"Panorama",
PANORAMA.as_slice(),
"Title panorama",
"panorama",
),
(
is_font,
"Font",
UNIFONT.as_slice(),
"Unifont glyphs",
"fonts",
),
(
is_built_in_pack,
"Built-in pack",
BUILT_IN_PACKS.as_slice(),
"Programmer Art and High Contrast",
"packs",
),
(
is_language,
"Language",
LANGUAGES.as_slice(),
"Languages",
"languages",
),
] {
let result = match &mut assets {
Ok(assets) => assets.copy(wanted, label, required, log).map(|_| ()),
Err(error) => Err(error.to_string()),
};
if let Err(error) = result {
log(&format!(
"{failure} not imported: {error}; run horizon-prepare {command} later"
));
}
}
}
@@ -207,29 +225,98 @@ fn copy_assets(
label: &str,
required: &[&str],
) -> Result<PathBuf, String> {
let lock = Lock::read(root)?;
let minecraft = artifacts::minecraft_dir(minecraft);
let manifest = artifacts::import_manifest(&lock, &minecraft)?;
let (store, index) = launcher_assets(&lock, &manifest, &minecraft, log)?;
let id = manifest
.get("id")
.and_then(Value::as_str)
.ok_or("The version JSON has no id")?;
let target = root.join(".local/horizon-client").join(id);
fs::create_dir_all(&target).map_err(|e| format!("{}: {e}", target.display()))?;
fs::copy(&index, target.join("asset-index.json"))
.map_err(|e| format!("{}: {e}", target.join("asset-index.json").display()))?;
let objects = read_json(&index)?;
let objects = objects
.get("objects")
.and_then(Value::as_object)
.ok_or_else(|| format!("{} has no objects", index.display()))?;
Assets::load(root, minecraft, log)?.copy(wanted_asset, label, required, log)
}
/// A preparation's index and verified destinations. Never persisted: a later invocation
/// checks the bytes again, including when repairing a corrupt prepared file.
pub(crate) struct Assets {
store: PathBuf,
target: PathBuf,
objects: Vec<(String, Value)>,
verified: HashSet<PathBuf>,
}
impl Assets {
pub(crate) fn load(root: &Path, minecraft: Option<&Path>, log: Log) -> Result<Self, String> {
let lock = Lock::read(root)?;
let minecraft = artifacts::minecraft_dir(minecraft);
let manifest = artifacts::import_manifest(&lock, &minecraft)?;
let target = root.join(".local/horizon-client").join(&lock.version);
let (store, index, bytes) = launcher_assets(
&lock,
&manifest,
&minecraft,
&target.join("asset-index.json"),
log,
)?;
let text = std::str::from_utf8(&bytes).map_err(|e| e.to_string())?;
let objects = crate::pyjson::loads(text)?;
let objects = objects
.get("objects")
.and_then(Value::as_object)
.ok_or_else(|| format!("{} has no objects", index.display()))?
.to_vec();
fs::create_dir_all(&target).map_err(|e| e.to_string())?;
crate::write_if_changed(&target.join("asset-index.json"), &bytes)?;
Ok(Self {
store,
target,
objects,
verified: HashSet::new(),
})
}
/// Preserve indexed replacements instead of overwriting them with JAR placeholders.
pub(crate) fn imported(&mut self, name: &str) -> Result<bool, String> {
let Some(name) = name.strip_prefix("assets/") else {
return Ok(false);
};
if !(is_panorama(name) || is_font(name) || is_language(name)) {
return Ok(false);
}
let Some((_, info)) = self.objects.iter().rev().find(|(n, _)| n == name) else {
return Ok(false);
};
let Some(hash) = info.get("hash").and_then(Value::as_str) else {
return Ok(false);
};
let destination = self.target.join("assets").join(name);
if destination.is_file() && digest(&destination, "sha1")? == hash {
self.verified.insert(destination);
return Ok(true);
}
Ok(false)
}
fn copy(
&mut self,
wanted_asset: fn(&str) -> bool,
label: &str,
required: &[&str],
log: Log,
) -> Result<PathBuf, String> {
copy_indexed(self, wanted_asset, label, required, log)
}
}
fn copy_indexed(
assets: &mut Assets,
wanted_asset: fn(&str) -> bool,
label: &str,
required: &[&str],
log: Log,
) -> Result<PathBuf, String> {
let objects = &assets.objects;
// A repeated name keeps its first place and its last value, as a Python dict does.
let mut wanted: Vec<(&str, &Value)> = Vec::new();
let mut positions = HashMap::new();
for (name, info) in objects.iter().filter(|(name, _)| wanted_asset(name)) {
match wanted.iter_mut().find(|(n, _)| n == name) {
Some(entry) => entry.1 = info,
None => wanted.push((name, info)),
if let Some(&position) = positions.get(name.as_str()) {
wanted[position] = (name.as_str(), info);
} else {
positions.insert(name.as_str(), wanted.len());
wanted.push((name, info));
}
}
for name in required {
@@ -251,21 +338,45 @@ fn copy_assets(
.ok_or_else(|| format!("{name} has no size in the asset index"))?;
let relative = artifacts::safe_relative(name)
.ok_or_else(|| format!("Unsafe asset name {name:?} in the asset index"))?;
let source = launcher_object(&store, hash)?;
copies.push((source, target.join("assets").join(relative), hash));
let source = object_path(&assets.store, hash)?;
let destination = assets.target.join("assets").join(relative);
let import = crate::files::Import::stage(
&source,
&destination,
hash,
"sha1",
assets.verified.contains(&destination),
)
.map_err(|error| {
if !source.is_file() {
format!(
"Missing asset object {}. Play the pinned version once in your launcher.",
source.display()
)
} else if error.contains(" is not the pinned file:") {
format!(
"Corrupt asset object {}; let the launcher repair it: {error}",
source.display()
)
} else {
error
}
})?;
copies.push((import, destination));
total += size;
}
// Check the entire set before replacing any placeholders: a missing late face
// must not leave a mixture of real textures and gray faces in either entry point.
for (source, destination, hash) in copies {
artifacts::import_copy(&source, &destination, hash, "sha1", "")?;
for (import, destination) in copies {
import.commit()?;
assets.verified.insert(destination);
}
log(&format!(
"{label} assets ready: {} files, {:.1} MB",
wanted.len(),
total as f64 / 1e6
));
Ok(target)
Ok(assets.target.clone())
}
#[cfg(test)]
@@ -680,6 +791,7 @@ mod tests {
"minecraft/sounds.json is missing from the asset index"
);
fs::remove_file(&index).unwrap();
fs::remove_file(f.root.join(".local/horizon-client/9.9/asset-index.json")).unwrap();
let error = f.run().unwrap_err();
assert!(
error.starts_with("Missing ") && error.contains("play 9.9 once"),
@@ -687,6 +799,120 @@ mod tests {
);
}
#[test]
fn late_corruption_discards_all_staged_replacements() {
let f = Fixture::new("late-corruption");
let target = f.root.join(".local/horizon-client/9.9/assets");
for name in PANORAMA {
let path = target.join(name);
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, b"placeholder").unwrap();
}
fs::write(f.object(FIRST_FACE + 6), b"bad overlay").unwrap();
assert!(panorama(&f.root, Some(&f.minecraft), &|_| {}).is_err());
for name in PANORAMA {
assert_eq!(fs::read(target.join(name)).unwrap(), b"placeholder");
}
assert_eq!(
fs::read_dir(target.join("minecraft/textures/gui/title/background"))
.unwrap()
.count(),
7
);
}
#[test]
fn one_index_snapshot_serves_every_import_and_reruns_repair_corruption() {
let f = Fixture::with_extras("snapshot", &PANORAMA, &[("pack.mcmeta", b"{}")]);
let mut assets = Assets::load(&f.root, Some(&f.minecraft), &|_| {}).unwrap();
fs::remove_file(f.minecraft.join("assets/indexes/7.json")).unwrap();
let lines = std::cell::RefCell::new(Vec::new());
optional_imports(Ok(&mut assets), &|line| {
lines.borrow_mut().push(line.to_string())
});
assert_eq!(lines.borrow().len(), 4);
assert!(lines
.borrow()
.iter()
.all(|line| line.contains("assets ready")));
assets
.copy(is_sound, "Sound", &["minecraft/sounds.json"], &|_| {})
.unwrap();
let sound = assets
.target
.join("assets/minecraft/sounds/ambient/cave1.ogg");
let time = fs::metadata(&sound).unwrap().modified().unwrap();
fs::remove_file(f.object(1)).unwrap();
f.run().unwrap(); // A verified destination works even without the source object/index.
assert_eq!(fs::metadata(&sound).unwrap().modified().unwrap(), time);
fs::write(&sound, b"corrupt").unwrap();
assert!(f.run().is_err()); // Verification never carries over to another invocation.
fs::write(f.object(1), &f.objects[1].1).unwrap();
f.run().unwrap();
assert_eq!(fs::read(sound).unwrap(), f.objects[1].1);
}
#[test]
fn jar_reruns_preserve_indexed_assets_and_repair_missing_or_corrupt_members() {
use std::io::Write;
let f = Fixture::with_extras(
"extract",
&PANORAMA,
&[
("pack.mcmeta", b"{}"),
("minecraft/lang/en_us.json", b"{\"indexed\":true}"),
],
);
optional_assets(&f.root, Some(&f.minecraft), &|_| {});
let target = f.root.join(".local/horizon-client/9.9");
let jar = f.root.join("client.jar");
let mut zip = zip::ZipWriter::new(fs::File::create(&jar).unwrap());
for (name, data) in [
("version.json", "{\"world_version\": 1}"),
(
"assets/minecraft/textures/gui/title/background/panorama_0.png",
"gray",
),
("assets/minecraft/font/include/unifont.json", "{}"),
("assets/minecraft/lang/en_us.json", "{}"),
("data/minecraft/test.json", "data"),
("pack.png", "icon"),
] {
zip.start_file(name, zip::write::SimpleFileOptions::default())
.unwrap();
zip.write_all(data.as_bytes()).unwrap();
}
zip.finish().unwrap();
let face = target.join("assets").join(PANORAMA[0]);
let time = fs::metadata(&face).unwrap().modified().unwrap();
// Preparing from cached JARs must also preserve full imports without the launcher.
fs::remove_dir_all(f.minecraft.join("assets")).unwrap();
for _ in 0..2 {
let mut assets = Assets::load(&f.root, Some(&f.minecraft), &|_| {}).unwrap();
let (_, count) =
crate::extract_client_resources(&jar, &target, Some(&mut assets)).unwrap();
assert_eq!(count, 5);
optional_imports(Ok(&mut assets), &|_| {});
assert_eq!(fs::read(&face).unwrap(), PANORAMA[0].as_bytes());
assert_eq!(fs::metadata(&face).unwrap().modified().unwrap(), time);
assert_eq!(
fs::read(target.join("assets").join(UNIFONT[0])).unwrap(),
f.objects[4].1
);
assert_eq!(
fs::read(target.join("assets/minecraft/lang/en_us.json")).unwrap(),
b"{\"indexed\":true}"
);
assert_eq!(
fs::read(target.join("data/minecraft/test.json")).unwrap(),
b"data"
);
assert_eq!(fs::read(target.join("pack.png")).unwrap(), b"icon");
fs::write(target.join("data/minecraft/test.json"), b"oops").unwrap();
fs::remove_file(target.join("pack.png")).unwrap();
}
}
#[test]
fn object_paths_come_from_real_hashes() {
let store = Path::new("assets");
+79
View File
@@ -0,0 +1,79 @@
//! A bounded request/reply channel to one initialized exporter JVM.
use crate::*;
use std::io::{BufRead, BufReader, Write};
use std::process::{Child, ChildStdin, Stdio};
use std::sync::mpsc::{self, Receiver};
pub(crate) struct Worker {
child: Child,
input: ChildStdin,
replies: Receiver<std::io::Result<String>>,
}
impl Worker {
pub(crate) fn new(run: &Run, classes: &Path, cp: &str) -> Result<Self, String> {
let log = run.log_file(&run.local.join(format!(
"{}-worker.log",
classes.file_name().unwrap().to_string_lossy()
)))?;
let mut child = java::command(&run.jdk.java)
.args([
"-Xmx2G",
"-cp",
&format!(
"{}{}{}",
classes.display(),
if cfg!(windows) { ";" } else { ":" },
cp
),
"dev.horizonlab.parity.PrepareWorker",
])
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(log)
.spawn()
.map_err(|e| e.to_string())?;
let input = child.stdin.take().unwrap();
let output = child.stdout.take().unwrap();
let (send, replies) = mpsc::channel();
std::thread::spawn(move || {
for line in BufReader::new(output).lines() {
if send.send(line).is_err() {
break;
}
}
});
Ok(Self {
child,
input,
replies,
})
}
pub(crate) fn run(&mut self, main: &str, args: &[String], log: &Path) -> Result<(), String> {
let task = Value::Array(vec![
Value::Str(arg(log)),
Value::Str(main.into()),
Value::Array(args.iter().cloned().map(Value::Str).collect()),
]);
writeln!(self.input, "{}", pyjson::dumps(&task, &pyjson::COMPACT))
.map_err(|e| e.to_string())?;
self.input.flush().map_err(|e| e.to_string())?;
let reply = self
.replies
.recv_timeout(std::time::Duration::from_secs(3600))
.map_err(|e| format!("Exporter JVM stopped or timed out: {e}"))?
.map_err(|e| e.to_string())?;
match pyjson::loads(&reply)?.as_str() {
Some("") => Ok(()),
_ => Err(format!("Exporter {main} failed: {reply}")),
}
}
}
impl Drop for Worker {
fn drop(&mut self) {
let _ = self.child.kill();
let _ = self.child.wait();
}
}
+14 -2
View File
@@ -25,13 +25,23 @@ fn selects_a_compatible_compiler_and_runtime() {
assert!(error.contains(&format!("java {runtime} (")), "{error}");
return;
}
let jdk = java::find(25, &[]).unwrap();
let expected = root.join(if scenario == "target-release" {
let jdk = if scenario == "runtime-only" {
java::find_runtime(25, &[])
} else {
java::find(25, &[])
}
.unwrap();
let expected = root.join(if scenario == "runtime-only" {
"jre25"
} else if scenario == "target-release" {
"newer"
} else {
"jdk25"
});
for (actual, name) in [(&jdk.javac, "javac"), (&jdk.java, "java")] {
if scenario == "runtime-only" && name == "javac" {
continue;
}
assert_eq!(
fs::canonicalize(actual).unwrap(),
fs::canonicalize(tool(&expected.join("bin"), name)).unwrap()
@@ -64,6 +74,7 @@ fn selects_a_compatible_compiler_and_runtime() {
);
for (home, compiler, runtime) in [
("jre21", None, "21.0.1"),
("jre25", None, "25.0.1"),
("jdk21", Some("21.0.1"), "21.0.1"),
("jdk25", Some("25.0.1"), "25.0.1"),
("mixed", Some("25.0.1"), "21.0.1"),
@@ -83,6 +94,7 @@ fn selects_a_compatible_compiler_and_runtime() {
}
fs::write(root.join("failing/bin/java.exit"), "7").unwrap();
let scenarios = vec![
("runtime-only", Some("jre25"), vec!["jre21", "jre25"]),
("older-runtime", None, vec!["jre21", "jdk25"]),
("older-jdk", None, vec!["jdk21", "jdk25"]),
("incompatible-home", Some("mixed"), vec!["jdk25"]),
+159
View File
@@ -0,0 +1,159 @@
//! The biome parameters and constants of custom uniform expressions (spec 3.4): `BIOME_<NAME>`,
//! `CAT_<NAME>` and `PPT_<NAME>`.
//!
//! Decisions (impl-plan.md, OQ-11):
//! - `biome` is the biome's index in the game's biome registry, which lists vanilla's biomes
//! sorted by identifier; `BIOME_<NAME>` is the index of `minecraft:<name>`. Names from before
//! the 1.18 renames map to the biome that replaced them. A `BIOME_` name that matches no biome
//! reads -1, so it never equals the player's biome.
//! - `biome_category` comes from the biome's name (categories left the game in 1.19).
use std::collections::HashMap;
/// `CAT_*`, in the order of their values.
pub const CATEGORIES: [&str; 17] = [
"NONE",
"TAIGA",
"EXTREME_HILLS",
"JUNGLE",
"MESA",
"PLAINS",
"SAVANNA",
"ICY",
"THE_END",
"BEACH",
"FOREST",
"OCEAN",
"DESERT",
"RIVER",
"SWAMP",
"MUSHROOM",
"NETHER",
];
/// Old biome names and the biomes that replaced them.
const LEGACY: &[(&str, &str)] = &[
("EXTREME_HILLS", "windswept_hills"),
("MOUNTAINS", "windswept_hills"),
("GRAVELLY_MOUNTAINS", "windswept_gravelly_hills"),
("WOODED_MOUNTAINS", "windswept_forest"),
("SHATTERED_SAVANNA", "windswept_savanna"),
("GIANT_TREE_TAIGA", "old_growth_pine_taiga"),
("GIANT_SPRUCE_TAIGA", "old_growth_spruce_taiga"),
("TALL_BIRCH_FOREST", "old_growth_birch_forest"),
("SNOWY_TUNDRA", "snowy_plains"),
("JUNGLE_EDGE", "sparse_jungle"),
("WOODED_BADLANDS_PLATEAU", "wooded_badlands"),
("STONE_SHORE", "stony_shore"),
("NETHER", "nether_wastes"),
];
/// The constants every pack sees: `CAT_*` and `PPT_*`, plus `BIOME_*` for `biomes` (the
/// registry's identifiers, in id order).
pub fn constants(biomes: &[&str]) -> HashMap<String, f64> {
let mut out: HashMap<String, f64> = CATEGORIES
.iter()
.enumerate()
.map(|(i, c)| (format!("CAT_{c}"), i as f64))
.collect();
for (i, p) in ["NONE", "RAIN", "SNOW"].iter().enumerate() {
out.insert(format!("PPT_{p}"), i as f64);
}
let index = |name: &str| {
biomes
.iter()
.position(|b| b.strip_prefix("minecraft:") == Some(name))
};
for (i, b) in biomes.iter().enumerate() {
if let Some(name) = b.strip_prefix("minecraft:") {
out.insert(format!("BIOME_{}", name.to_ascii_uppercase()), i as f64);
}
}
for (old, new) in LEGACY {
if let Some(i) = index(new) {
out.entry(format!("BIOME_{old}")).or_insert(i as f64);
}
}
out
}
/// `biome_category` of the biome `minecraft:<name>`.
pub fn category(name: &str) -> i32 {
let name = name.strip_prefix("minecraft:").unwrap_or(name);
let has = |words: &[&str]| words.iter().any(|w| name.contains(w));
let cat = if name == "the_void" {
"NONE"
} else if name == "the_end" || name.starts_with("end_") || name == "small_end_islands" {
"THE_END"
} else if has(&["nether", "crimson", "warped", "basalt", "soul_sand"]) {
"NETHER"
} else if has(&["ocean"]) {
"OCEAN"
} else if has(&["river"]) {
"RIVER"
} else if has(&["beach", "shore"]) {
"BEACH"
} else if has(&["swamp"]) {
"SWAMP"
} else if has(&["mushroom"]) {
"MUSHROOM"
} else if has(&["desert"]) {
"DESERT"
} else if has(&["badlands"]) {
"MESA"
} else if has(&["savanna"]) {
"SAVANNA"
} else if has(&["jungle"]) {
"JUNGLE"
} else if has(&["taiga"]) {
"TAIGA"
} else if has(&["windswept", "peaks", "slopes", "meadow", "grove"]) && name != "cherry_grove" {
"EXTREME_HILLS"
} else if has(&["frozen", "snowy", "ice"]) {
"ICY"
} else if has(&["forest", "garden", "cherry"]) {
"FOREST"
} else if has(&["plains"]) {
"PLAINS"
} else {
"NONE"
};
CATEGORIES.iter().position(|c| *c == cat).unwrap_or(0) as i32
}
/// `biome_precipitation`: none where the biome has none, else rain from temperature 0.15 up,
/// snow below it (spec 3.4).
pub fn precipitation(has_precipitation: bool, temperature: f32) -> i32 {
match (has_precipitation, temperature >= 0.15) {
(false, _) => 0,
(true, true) => 1,
(true, false) => 2,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn constants_categories_and_precipitation() {
let c = constants(&[
"minecraft:badlands",
"minecraft:pale_garden",
"minecraft:windswept_hills",
]);
assert_eq!(c["BIOME_PALE_GARDEN"], 1.0);
assert_eq!(c["BIOME_EXTREME_HILLS"], 2.0);
assert_eq!(c["CAT_NETHER"], 16.0);
assert_eq!(c["PPT_SNOW"], 2.0);
assert!(!c.contains_key("BIOME_SULFUR_CAVES"));
assert_eq!(category("minecraft:pale_garden"), 10);
assert_eq!(category("minecraft:deep_frozen_ocean"), 11);
assert_eq!(category("minecraft:snowy_taiga"), 1);
assert_eq!(category("minecraft:crimson_forest"), 16);
assert_eq!(category("minecraft:cherry_grove"), 10);
assert_eq!(precipitation(true, 0.0), 2);
assert_eq!(precipitation(true, 0.8), 1);
assert_eq!(precipitation(false, 2.0), 0);
}
}
+151
View File
@@ -0,0 +1,151 @@
//! `block.properties` (spec 4.1): `block.<id>=<block> <block> ...`, each block
//! `[namespace:]name` with optional state filters `:<property>=<v1>,<v2>`. Values in one filter
//! are alternatives; separate filters must all match. Names the game does not know are simply
//! never asked for. Block tags (`%tag`, tier E) are not read yet.
use crate::Properties;
#[derive(Clone, Debug, PartialEq)]
struct Rule {
id: i32,
/// `minecraft:stone`.
name: String,
filters: Vec<(String, Vec<String>)>,
}
/// The ids `block.properties` gives block states.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct BlockIds {
rules: Vec<Rule>,
/// Lines skipped and why.
pub notes: Vec<String>,
}
impl BlockIds {
pub fn parse(properties: &Properties) -> Self {
Self::parse_kind(properties, "block")
}
/// The same for `<kind>.<id>=` lines: `entity` in `entity.properties`, `item` in
/// `item.properties` (4.1); names there carry no state filters.
pub fn parse_kind(properties: &Properties, kind: &str) -> Self {
let mut out = Self::default();
let prefix = format!("{kind}.");
for e in &properties.entries {
let Some(id) = e.key.strip_prefix(prefix.as_str()) else {
continue;
};
let Ok(id) = id.parse::<i32>() else {
// `layer.*` (4.2) and other keys are not ids.
continue;
};
for word in e.value.split_whitespace() {
if word.starts_with('%') {
out.notes.push(format!(
"line {}: block tags are not read yet: {word}",
e.line
));
continue;
}
let (names, filters): (Vec<&str>, Vec<&str>) =
word.split(':').partition(|p| !p.contains('='));
let name = match names[..] {
[name] => format!("minecraft:{name}"),
[namespace, name] => format!("{namespace}:{name}"),
_ => {
out.notes
.push(format!("line {}: not a block name: {word}", e.line));
continue;
}
};
let filters = filters
.iter()
.filter_map(|f| f.split_once('='))
.map(|(k, v)| (k.to_owned(), v.split(',').map(str::to_owned).collect()))
.collect();
out.rules.push(Rule { id, name, filters });
}
}
out
}
/// The id of block `name` (`minecraft:stone`) in the state with `properties`. The rule with
/// the most filters that all match wins, then the first in the file (one name belongs to
/// one id; a filtered entry is the more specific one).
pub fn id<'a>(&self, name: &str, properties: impl Fn(&str) -> Option<&'a str>) -> Option<i32> {
self.rules
.iter()
.filter(|r| r.name == name)
.filter(|r| {
r.filters
.iter()
.all(|(k, vs)| properties(k).is_some_and(|v| vs.iter().any(|x| x == v)))
})
.min_by_key(|r| std::cmp::Reverse(r.filters.len()))
.map(|r| r.id)
}
/// Every name without state filters and its id (the first line naming it wins): what
/// `entity.properties` and `item.properties` hold.
pub fn plain(&self) -> std::collections::HashMap<String, i32> {
let mut out = std::collections::HashMap::new();
for r in self.rules.iter().filter(|r| r.filters.is_empty()) {
out.entry(r.name.clone()).or_insert(r.id);
}
out
}
pub fn is_empty(&self) -> bool {
self.rules.is_empty()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Macros;
#[test]
fn names_states_and_precedence() {
let text = "block.10=stone minecraft:dirt mod:thing \\\n grass_block:snowy=false\n\
block.11=grass_block\nblock.12=oak_leaves:persistent=true:distance=1,2 %leaves\n\
layer.translucent=glass\n";
let ids = BlockIds::parse(&Properties::parse(text, &Macros::standard()));
let none = |_: &str| None;
assert_eq!(ids.id("minecraft:stone", none), Some(10));
assert_eq!(ids.id("mod:thing", none), Some(10));
assert_eq!(ids.id("minecraft:glass", none), None);
let snowy = |s: &'static str| move |k: &str| (k == "snowy").then_some(s);
// The filtered entry is the more specific one.
assert_eq!(ids.id("minecraft:grass_block", snowy("false")), Some(10));
assert_eq!(ids.id("minecraft:grass_block", snowy("true")), Some(11));
let leaves = |p: &'static str, d: &'static str| {
move |k: &str| match k {
"persistent" => Some(p),
"distance" => Some(d),
_ => None,
}
};
assert_eq!(
ids.id("minecraft:oak_leaves", leaves("true", "2")),
Some(12)
);
assert_eq!(ids.id("minecraft:oak_leaves", leaves("true", "3")), None);
assert_eq!(ids.id("minecraft:oak_leaves", leaves("false", "1")), None);
assert_eq!(ids.notes.len(), 1, "{:?}", ids.notes);
}
#[test]
fn entity_lines_by_name() {
let text = "entity.10=zombie minecraft:husk\nentity.11=zombie mod:thing\nblock.5=stone\n";
let ids = BlockIds::parse_kind(&Properties::parse(text, &Macros::standard()), "entity");
let plain = ids.plain();
assert_eq!(
plain["minecraft:zombie"], 10,
"the first line naming it wins"
);
assert_eq!(plain["minecraft:husk"], 10);
assert_eq!(plain["mod:thing"], 11);
assert!(!plain.contains_key("minecraft:stone"));
}
}
+136
View File
@@ -118,9 +118,55 @@ impl Default for Buffer {
}
}
/// The shadow map's settings (6.3, 7.1), from `const` lines of the stage files.
#[derive(Clone, Debug, PartialEq)]
pub struct Shadow {
/// `shadowMapResolution`: the map's side in pixels.
pub resolution: u32,
/// `shadowDistance`: half the side of the area the map covers, in blocks.
pub distance: f32,
/// `shadowDistanceRenderMul`: when > 0, geometry beyond `distance × mul` is not drawn.
pub render_mul: f32,
/// `shadowIntervalSize`: the shadow camera moves in steps of this many blocks (0: none).
pub interval: f32,
/// `sunPathRotation`, degrees.
pub sun_path_rotation: f32,
/// `shadowMapFov`: a perspective projection of this many degrees instead of orthographic.
pub fov: Option<f32>,
/// `shadowNearPlane`, `shadowFarPlane`.
pub near: f32,
pub far: f32,
/// `shadowHardwareFiltering(0|1)`: shadowtex0/1 sampled with depth comparison.
pub hardware_filtering: [bool; 2],
/// `shadowcolor0/1`: format, cleared every frame, clear colour (default white).
pub colors: [Buffer; 2],
}
impl Default for Shadow {
fn default() -> Self {
let white = Buffer {
clear_color: Some([1.0; 4]),
..Buffer::default()
};
Self {
resolution: 1024,
distance: 160.0,
render_mul: -1.0,
interval: 2.0,
sun_path_rotation: 0.0,
fov: None,
near: 0.05,
far: 256.0,
hardware_filtering: [false; 2],
colors: [white.clone(), white],
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Config {
pub buffers: [Buffer; BUFFERS],
pub shadow: Shadow,
/// Conflicting or unreadable settings, as `file:line: message`.
pub notes: Vec<String>,
format_set: [bool; BUFFERS],
@@ -133,6 +179,7 @@ impl Default for Config {
fn default() -> Self {
Self {
buffers: std::array::from_fn(|_| Buffer::default()),
shadow: Shadow::default(),
notes: Vec::new(),
format_set: [false; BUFFERS],
seen: Vec::new(),
@@ -197,6 +244,9 @@ impl Config {
}
fn constant(&mut self, place: &str, ty: &str, name: &str, value: &str) {
if self.shadow_constant(ty, name, value) {
return;
}
let settings = [
("Format", "int"),
("ClearColor", "vec4"),
@@ -243,6 +293,70 @@ impl Config {
}
}
impl Config {
/// A shadow setting of 6.3 or 7.1; true when `name` is one (read or not).
fn shadow_constant(&mut self, ty: &str, name: &str, value: &str) -> bool {
let s = &mut self.shadow;
let float = |v: &mut f32| {
if let Some(n) = number(value) {
*v = n;
}
};
match name {
"shadowMapResolution" => {
if let Some(n) = number(value).filter(|n| *n >= 1.0) {
s.resolution = (n as u32).min(16384);
}
}
"shadowDistance" => float(&mut s.distance),
"shadowDistanceRenderMul" => float(&mut s.render_mul),
"shadowIntervalSize" => float(&mut s.interval),
"sunPathRotation" => float(&mut s.sun_path_rotation),
"shadowNearPlane" => float(&mut s.near),
"shadowFarPlane" => float(&mut s.far),
"shadowMapFov" => s.fov = number(value).filter(|f| *f > 0.0),
"shadowHardwareFiltering" => {
if let Some(b) = boolean(value) {
s.hardware_filtering = [b; 2];
}
}
"shadowHardwareFiltering0" | "shadowHardwareFiltering1" => {
if let Some(b) = boolean(value) {
s.hardware_filtering[usize::from(name.ends_with('1'))] = b;
}
}
_ => {
let color = ["shadowcolor0", "shadowcolor1", "shadowcolor"]
.iter()
.find_map(|b| Some((b, name.strip_prefix(b)?)));
let Some((buffer, setting)) = color else {
return false;
};
let b = &mut s.colors[usize::from(buffer.ends_with('1'))];
match (setting, ty) {
("Format", "int") => {
if let Some(f) = Format::parse(value) {
b.format = f;
}
}
("Clear", "bool") => {
if let Some(v) = boolean(value) {
b.clear = v;
}
}
("ClearColor", "vec4") => {
if let Some(c) = vec4(value) {
b.clear_color = Some(c);
}
}
_ => return false,
}
}
}
true
}
}
/// The buffers a fragment shader writes, from the last `DRAWBUFFERS` or `RENDERTARGETS` comment
/// of its live code, or `None` without one (then it writes buffers 0 to 7). 6.1.4.
pub fn draw_buffers(pp: &Preprocessed) -> Option<Vec<u32>> {
@@ -402,6 +516,28 @@ mod tests {
assert!(config.notes.is_empty(), "{:?}", config.notes);
}
#[test]
fn shadow_settings() {
let mut c = Config::default();
c.read(&stage(
"const int shadowMapResolution = 2048;\nconst float shadowDistance = 128.0f;\n\
const float sunPathRotation = -40.0;\nconst bool shadowHardwareFiltering = true;\n\
/* const int shadowcolor1Format = RGBA16F; */\nconst bool shadowcolor0Clear = false;\n",
));
let s = c.finish().shadow;
assert_eq!(
(s.resolution, s.distance, s.sun_path_rotation),
(2048, 128.0, -40.0)
);
assert_eq!(
(s.interval, s.fov, s.hardware_filtering),
(2.0, None, [true; 2])
);
assert!(!s.colors[0].clear && s.colors[1].clear);
assert_eq!(s.colors[1].format, Format::parse("RGBA16F").unwrap());
assert_eq!(s.colors[1].clear_color, Some([1.0; 4]));
}
#[test]
fn no_directive_and_conflicts() {
let pp = stage("void main() {}\n");
+611
View File
@@ -0,0 +1,611 @@
//! Custom uniforms and variables of `shaders.properties` (spec 3.4): `uniform.<type>.<name>` and
//! `variable.<type>.<name>` expressions, parsed once and evaluated on the CPU every frame in
//! file order. Uniforms reach every program; variables only later expressions.
//!
//! Decisions (impl-plan.md):
//! - OQ-25: numbers are doubles; booleans are 1 and 0; `%` is C's remainder (`fmod` floors);
//! comparisons and logic read the first component; a value takes its declared type at the
//! end (`int` truncates toward zero, `bool` is "not zero"). Unknown names read 0 and are
//! reported once.
//! - OQ-26: `smooth` runs per frame with the frame time; its fade times are seconds (1 by
//! default) to cover half of the remaining distance, `fadeIn` while rising, `fadeOut` while
//! falling. Each call keeps its own state, so the optional id is not needed.
use std::collections::{HashMap, HashSet};
use crate::Properties;
/// A value: up to 16 components (matrices only as names, for `m.row.column`).
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Val {
pub v: [f64; 16],
/// Components: 1 for a scalar.
pub n: usize,
}
impl Val {
pub fn scalar(x: f64) -> Self {
let mut v = [0.0; 16];
v[0] = x;
Self { v, n: 1 }
}
pub fn vector(c: &[f64]) -> Self {
let mut v = [0.0; 16];
v[..c.len()].copy_from_slice(c);
Self { v, n: c.len() }
}
fn x(&self) -> f64 {
self.v[0]
}
fn truth(&self) -> bool {
self.v[0] != 0.0
}
/// `f` per component; a scalar operand stretches to the other's size.
fn zip(self, o: Val, f: impl Fn(f64, f64) -> f64) -> Val {
let n = self.n.max(o.n).min(4);
let at = |a: &Val, i: usize| if a.n == 1 { a.v[0] } else { a.v[i] };
let mut out = Val::scalar(0.0);
out.n = n;
for i in 0..n {
out.v[i] = f(at(&self, i), at(&o, i));
}
out
}
fn map(self, f: impl Fn(f64) -> f64) -> Val {
let mut out = self;
for i in 0..self.n.min(4) {
out.v[i] = f(self.v[i]);
}
out
}
}
#[derive(Clone, Debug)]
enum Expr {
Num(f64),
/// A name and its component (`x`, `2`, `2.1` as row 2, column 1).
Name(String, Option<(usize, Option<usize>)>),
Call(String, Vec<Expr>, usize),
Neg(Box<Expr>),
Not(Box<Expr>),
Bin(&'static str, Box<Expr>, Box<Expr>),
}
#[derive(Debug)]
struct Item {
name: String,
ty: String,
uniform: bool,
expr: Expr,
}
/// The pack's custom uniforms and variables, with the state `smooth` and `random` keep.
#[derive(Debug, Default)]
pub struct Custom {
items: Vec<Item>,
/// `smooth` state per call site.
smooth: HashMap<usize, f64>,
seed: u64,
unknown: HashSet<String>,
/// `BIOME_*`, `CAT_*` and `PPT_*` (crate::biomes).
constants: HashMap<String, f64>,
/// Expressions that did not parse, and unknown names, as `key: message`.
pub notes: Vec<String>,
calls: usize,
}
impl Custom {
/// Reads every `uniform.*` and `variable.*` key of `properties`, in file order.
pub fn parse(properties: &Properties) -> Self {
let mut out = Custom {
seed: 0x9e37_79b9_7f4a_7c15,
constants: crate::biomes::constants(&[]),
..Default::default()
};
for e in &properties.entries {
let (uniform, rest) = match e.key.split_once('.') {
Some(("uniform", r)) => (true, r),
Some(("variable", r)) => (false, r),
_ => continue,
};
let Some((ty, name)) = rest.split_once('.') else {
continue;
};
if !matches!(ty, "float" | "int" | "bool" | "vec2" | "vec3" | "vec4") {
out.notes
.push(format!("{}: type `{ty}` is not supported", e.key));
continue;
}
match Parser::new(&e.value, &mut out.calls).expr_all() {
Ok(expr) => out.items.push(Item {
name: name.to_owned(),
ty: ty.to_owned(),
uniform,
expr,
}),
Err(m) => out.notes.push(format!("{}: {m}", e.key)),
}
}
out
}
/// Names the game's biomes (registry identifiers, in id order) for `BIOME_*`.
pub fn set_biomes(&mut self, biomes: &[&str]) {
self.constants = crate::biomes::constants(biomes);
}
/// The uniforms' names and declared types, in file order.
pub fn uniforms(&self) -> impl Iterator<Item = (&str, &str)> {
self.items
.iter()
.filter(|i| i.uniform)
.map(|i| (i.name.as_str(), i.ty.as_str()))
}
/// Evaluates everything for a frame `dt` seconds after the last; `builtin` gives the
/// values of the game's uniforms and constants (`BIOME_*`...). Returns the uniforms'
/// values, in the order of `uniforms`.
pub fn eval(&mut self, dt: f64, builtin: &dyn Fn(&str) -> Option<Val>) -> Vec<Val> {
let mut vars: HashMap<String, Val> = HashMap::new();
let mut out = Vec::new();
let items = std::mem::take(&mut self.items);
for item in &items {
let v = self.value(&item.expr, dt, &vars, builtin);
let v = match item.ty.as_str() {
"int" => Val::scalar(v.x().trunc()),
"bool" => Val::scalar(f64::from(u8::from(v.truth()))),
"float" => Val::scalar(v.x()),
t => {
let n = (t.as_bytes()[3] - b'0') as usize;
let mut v = v;
if v.n == 1 {
let x = v.v[0];
v.v[1..n].fill(x);
}
v.n = n;
v
}
};
vars.insert(item.name.clone(), v);
if item.uniform {
out.push(v);
}
}
self.items = items;
out
}
fn random(&mut self) -> f64 {
self.seed ^= self.seed << 13;
self.seed ^= self.seed >> 7;
self.seed ^= self.seed << 17;
(self.seed >> 11) as f64 / (1u64 << 53) as f64
}
fn value(
&mut self,
e: &Expr,
dt: f64,
vars: &HashMap<String, Val>,
builtin: &dyn Fn(&str) -> Option<Val>,
) -> Val {
let ev = |e: &Expr, s: &mut Self| s.value(e, dt, vars, builtin);
match e {
Expr::Num(x) => Val::scalar(*x),
Expr::Name(name, component) => {
let v = match name.as_str() {
"pi" => Some(Val::scalar(std::f64::consts::PI)),
"true" => Some(Val::scalar(1.0)),
"false" => Some(Val::scalar(0.0)),
n => vars
.get(n)
.copied()
.or_else(|| builtin(n))
.or_else(|| self.constants.get(n).map(|&x| Val::scalar(x))),
};
if v.is_none() && name.starts_with("BIOME_") {
if self.unknown.insert(name.clone()) {
self.notes
.push(format!("`{name}` names no biome; it reads -1"));
}
return Val::scalar(-1.0);
}
let Some(v) = v else {
if self.unknown.insert(name.clone()) {
self.notes.push(format!("`{name}` is unknown; it reads 0"));
}
return Val::scalar(0.0);
};
match component {
None => v,
// GLSL's m[column][row] is stored column after column.
Some((row, Some(column))) => Val::scalar(v.v[column * 4 + row]),
Some((i, None)) => Val::scalar(v.v[*i]),
}
}
Expr::Neg(a) => ev(a, self).map(|x| -x),
Expr::Not(a) => Val::scalar(f64::from(u8::from(!ev(a, self).truth()))),
Expr::Bin(op, a, b) => {
let (a, b) = (ev(a, self), ev(b, self));
let bool_ = |c: bool| Val::scalar(f64::from(u8::from(c)));
match *op {
"+" => a.zip(b, |x, y| x + y),
"-" => a.zip(b, |x, y| x - y),
"*" => a.zip(b, |x, y| x * y),
"/" => a.zip(b, |x, y| x / y),
"%" => a.zip(b, |x, y| x % y),
"<" => bool_(a.x() < b.x()),
"<=" => bool_(a.x() <= b.x()),
">" => bool_(a.x() > b.x()),
">=" => bool_(a.x() >= b.x()),
"==" => bool_(a.x() == b.x()),
"!=" => bool_(a.x() != b.x()),
"&&" => bool_(a.truth() && b.truth()),
_ => bool_(a.truth() || b.truth()),
}
}
Expr::Call(f, args, site) => {
let a: Vec<Val> = args.iter().map(|e| ev(e, self)).collect();
let arg = |i: usize| a.get(i).copied().unwrap_or(Val::scalar(0.0));
let x = arg(0).x();
let one = |g: fn(f64) -> f64| arg(0).map(g);
match f.as_str() {
"sin" => one(f64::sin),
"cos" => one(f64::cos),
"tan" => one(f64::tan),
"asin" => one(f64::asin),
"acos" => one(f64::acos),
"atan" if a.len() == 2 => Val::scalar(x.atan2(arg(1).x())),
"atan" => one(f64::atan),
"atan2" => Val::scalar(x.atan2(arg(1).x())),
"torad" | "radians" => one(f64::to_radians),
"todeg" | "degrees" => one(f64::to_degrees),
"min" => a
.iter()
.copied()
.reduce(|p, q| p.zip(q, f64::min))
.unwrap_or(arg(0)),
"max" => a
.iter()
.copied()
.reduce(|p, q| p.zip(q, f64::max))
.unwrap_or(arg(0)),
"clamp" => arg(0).zip(arg(1), f64::max).zip(arg(2), f64::min),
"abs" => one(f64::abs),
"floor" => one(f64::floor),
"ceil" => one(f64::ceil),
"exp" => one(f64::exp),
"exp2" => one(f64::exp2),
"exp10" => one(|v| 10f64.powf(v)),
"frac" => one(|v| v - v.floor()),
"log" if a.len() == 2 => Val::scalar(arg(1).x().log(x)),
"log" => one(f64::ln),
"log2" => one(f64::log2),
"log10" => one(f64::log10),
"sqrt" => one(f64::sqrt),
"round" => one(f64::round),
"signum" | "sign" => one(|v| if v == 0.0 { 0.0 } else { v.signum() }),
"pow" => arg(0).zip(arg(1), f64::powf),
"fmod" => arg(0).zip(arg(1), |p, q| p - q * (p / q).floor()),
"lerp" => arg(1).zip(arg(2), |p, q| p + (q - p) * x),
"mix" => arg(0).zip(arg(1), |p, q| p + (q - p) * arg(2).x()),
"edge" => Val::scalar(if arg(1).x() < x { 0.0 } else { 1.0 }),
"random" if a.len() == 2 => Val::scalar(x + (arg(1).x() - x) * self.random()),
"random" => Val::scalar(self.random()),
"randomInt" if a.len() == 2 => {
Val::scalar((x + (arg(1).x() - x) * self.random()).floor())
}
"randomInt" => Val::scalar((self.random() * f64::from(i32::MAX)).floor()),
"if" | "ifb" => {
let mut i = 0;
while i + 1 < a.len() {
if a[i].truth() {
return a[i + 1];
}
i += 2;
}
a.last().copied().unwrap_or(Val::scalar(0.0))
}
"smooth" => {
let (val, fade_in, fade_out) = match a.len() {
4 => (arg(1).x(), arg(2).x(), arg(3).x()),
3 => (x, arg(1).x(), arg(2).x()),
2 => (x, arg(1).x(), arg(1).x()),
_ => (x, 1.0, 1.0),
};
let state = self.smooth.entry(*site).or_insert(val);
let fade = if val > *state { fade_in } else { fade_out };
if fade > 0.0 {
*state = val + (*state - val) * 0.5f64.powf(dt / fade);
} else {
*state = val;
}
Val::scalar(*state)
}
"print" => arg(2),
"between" => {
Val::scalar(f64::from(u8::from(x >= arg(1).x() && x <= arg(2).x())))
}
"equals" => {
Val::scalar(f64::from(u8::from((x - arg(1).x()).abs() <= arg(2).x())))
}
"in" => Val::scalar(f64::from(u8::from(a[1..].iter().any(|v| v.x() == x)))),
"vec2" | "vec3" | "vec4" => {
let n = (f.as_bytes()[3] - b'0') as usize;
let mut c: Vec<f64> = a.iter().flat_map(|v| v.v[..v.n].to_vec()).collect();
if c.len() == 1 {
c = vec![c[0]; n];
}
c.resize(n, 0.0);
Val::vector(&c)
}
_ => {
if self.unknown.insert(f.clone()) {
self.notes.push(format!("`{f}()` is unknown; it gives 0"));
}
Val::scalar(0.0)
}
}
}
}
}
}
struct Parser<'a> {
tokens: Vec<String>,
at: usize,
calls: &'a mut usize,
}
const OPERATORS: [&str; 18] = [
"||", "&&", "==", "!=", "<=", ">=", "<", ">", "+", "-", "*", "/", "%", "!", "(", ")", ",", ".",
];
impl<'a> Parser<'a> {
fn new(text: &str, calls: &'a mut usize) -> Self {
let mut tokens = Vec::new();
let b = text.as_bytes();
let mut i = 0;
while i < b.len() {
let c = b[i] as char;
if c.is_whitespace() {
i += 1;
} else if c.is_ascii_digit()
|| (c == '.'
&& b.get(i + 1).is_some_and(u8::is_ascii_digit)
&& !tokens
.last()
.is_some_and(|t: &String| t == "." || is_name(t)))
{
let start = i;
while i < b.len()
&& (b[i].is_ascii_alphanumeric()
|| b[i] == b'.'
|| ((b[i] == b'-' || b[i] == b'+') && matches!(b[i - 1], b'e' | b'E')))
{
i += 1;
}
tokens.push(text[start..i].to_owned());
} else if c.is_ascii_alphabetic() || c == '_' {
let start = i;
while i < b.len() && (b[i].is_ascii_alphanumeric() || b[i] == b'_') {
i += 1;
}
tokens.push(text[start..i].to_owned());
} else {
let op = OPERATORS
.iter()
.find(|o| text[i..].starts_with(**o))
.map_or(&text[i..i + c.len_utf8()], |o| o);
i += op.len();
tokens.push(op.to_owned());
}
}
Parser {
tokens,
at: 0,
calls,
}
}
fn peek(&self) -> Option<&str> {
self.tokens.get(self.at).map(String::as_str)
}
fn eat(&mut self, t: &str) -> bool {
let hit = self.peek() == Some(t);
self.at += usize::from(hit);
hit
}
fn expr_all(&mut self) -> Result<Expr, String> {
let e = self.binary(0)?;
match self.peek() {
None => Ok(e),
Some(t) => Err(format!("unexpected `{t}`")),
}
}
/// Precedence levels from the loosest: `||`, `&&`, equality, relations, sums, products.
fn binary(&mut self, level: usize) -> Result<Expr, String> {
const LEVELS: [&[&str]; 6] = [
&["||"],
&["&&"],
&["==", "!="],
&["<", "<=", ">", ">="],
&["+", "-"],
&["*", "/", "%"],
];
if level == LEVELS.len() {
return self.unary();
}
let mut left = self.binary(level + 1)?;
while let Some(op) = self
.peek()
.and_then(|t| LEVELS[level].iter().find(|o| **o == t))
{
self.at += 1;
let right = self.binary(level + 1)?;
left = Expr::Bin(op, Box::new(left), Box::new(right));
}
Ok(left)
}
fn unary(&mut self) -> Result<Expr, String> {
if self.eat("-") {
return Ok(Expr::Neg(Box::new(self.unary()?)));
}
if self.eat("!") {
return Ok(Expr::Not(Box::new(self.unary()?)));
}
self.eat("+");
self.primary()
}
fn primary(&mut self) -> Result<Expr, String> {
let Some(t) = self.peek().map(str::to_owned) else {
return Err("the expression ends early".into());
};
self.at += 1;
if t == "(" {
let e = self.binary(0)?;
return if self.eat(")") {
Ok(e)
} else {
Err("missing `)`".into())
};
}
if t.starts_with(|c: char| c.is_ascii_digit() || c == '.') {
return t
.trim_end_matches(['f', 'F'])
.parse()
.map(Expr::Num)
.map_err(|_| format!("bad number `{t}`"));
}
if !is_name(&t) {
return Err(format!("unexpected `{t}`"));
}
if self.eat("(") {
let mut args = Vec::new();
if !self.eat(")") {
loop {
args.push(self.binary(0)?);
if self.eat(")") {
break;
}
if !self.eat(",") {
return Err(format!("missing `)` after the arguments of `{t}`"));
}
}
}
*self.calls += 1;
return Ok(Expr::Call(t, args, *self.calls));
}
let component = if self.eat(".") {
let c = self.peek().map(str::to_owned).ok_or("nothing after `.`")?;
self.at += 1;
let index = |s: &str| match s {
"x" | "r" | "s" | "0" => Some(0),
"y" | "g" | "t" | "1" => Some(1),
"z" | "b" | "p" | "2" => Some(2),
"w" | "a" | "q" | "3" => Some(3),
_ => None,
};
Some(match c.split_once('.') {
Some((r, col)) => (
index(r).ok_or(format!("bad component `{c}`"))?,
Some(index(col).ok_or(format!("bad component `{c}`"))?),
),
None => (index(&c).ok_or(format!("bad component `{c}`"))?, None),
})
} else {
None
};
Ok(Expr::Name(t, component))
}
}
fn is_name(t: &str) -> bool {
t.starts_with(|c: char| c.is_ascii_alphabetic() || c == '_')
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Macros;
fn custom(text: &str) -> Custom {
Custom::parse(&Properties::parse(text, &Macros::standard()))
}
#[test]
fn expressions_follow_c_precedence_and_file_order() {
let mut c = custom(
"variable.float.a = 1 + 2 * 3 - 4 % 3\n\
uniform.float.b = a / 2\n\
uniform.bool.c = a > 5 && !(b < 1) || false\n\
uniform.int.d = -7 / 2\n\
uniform.vec3.e = vec3(a, cameraPosition.y, 2) * 2\n\
uniform.float.f = if(a < 0, 1, a < 7, 2, 3) + clamp(fmod(-1, 4), 0, 2.5) + min(4, 2, 3)\n\
uniform.float.g = gbufferModelView.1.0 + frac(sunAngle - 0.25) + pi * 0\n\
uniform.float.h = unknownThing + in(biome, 3, BIOME_DESERT)\n\
uniform.int.i = biome == BIOME_PALE_GARDEN || biome == BIOME_OLD\n\
uniform.int.j = CAT_OCEAN + PPT_RAIN\n",
);
c.set_biomes(&["minecraft:beach", "minecraft:desert"]);
assert!(c.notes.is_empty(), "{:?}", c.notes);
let names: Vec<_> = c.uniforms().map(|u| u.0).collect();
assert_eq!(names, ["b", "c", "d", "e", "f", "g", "h", "i", "j"]);
let builtin = |n: &str| match n {
"cameraPosition" => Some(Val::vector(&[1.0, 64.0, 2.0])),
"sunAngle" => Some(Val::scalar(0.125)),
"biome" => Some(Val::scalar(1.0)),
"gbufferModelView" => {
let mut m = Val::scalar(0.0);
m.v[1] = 9.0; // column 0, row 1
m.n = 16;
Some(m)
}
_ => None,
};
let v = c.eval(0.016, &builtin);
let x: Vec<f64> = v.iter().map(|v| v.v[0]).collect();
assert_eq!(
x,
[
3.0,
1.0,
-3.0,
12.0,
2.0 + 2.5 + 2.0,
9.0 + 0.875,
1.0,
0.0,
12.0
]
);
assert_eq!(&v[3].v[..3], &[12.0, 128.0, 4.0]);
assert_eq!(
c.notes,
[
"`unknownThing` is unknown; it reads 0",
"`BIOME_PALE_GARDEN` names no biome; it reads -1",
"`BIOME_OLD` names no biome; it reads -1"
]
);
}
#[test]
fn smooth_halves_the_distance_per_fade_time() {
let mut c = custom("uniform.float.s = smooth(1, target, 2, 0.5)\n");
let mut target = 0.0;
let mut run = |t: f64, dt: f64| {
target = t;
c.eval(dt, &|n: &str| (n == "target").then(|| Val::scalar(target)))[0].v[0]
};
assert_eq!(run(0.0, 0.0), 0.0);
assert!((run(1.0, 2.0) - 0.5).abs() < 1e-9, "rising: fadeIn");
assert!((run(0.0, 0.5) - 0.25).abs() < 1e-9, "falling: fadeOut");
}
#[test]
fn bad_expressions_are_reported() {
let c = custom("uniform.float.a = (1 + \nuniform.mat4.m = 1\nuniform.float.ok = 2\n");
assert_eq!(c.uniforms().count(), 1);
assert_eq!(c.notes.len(), 2, "{:?}", c.notes);
}
}
+16 -5
View File
@@ -12,27 +12,38 @@
//! - [`load_post`]: a dimension's `prepare`, `deferred`, `composite` and `final` programs, in order (2.1).
//! - [`Macros`] and [`eval_condition`]: the macros packs test, and the `#if` arithmetic (1.5).
mod biomes;
mod block_ids;
mod condition;
mod config;
mod custom;
mod discover;
mod lang;
mod macros;
mod options;
mod pack;
mod post;
mod preprocess;
mod properties;
mod translate;
pub use biomes::{category as biome_category, precipitation as biome_precipitation};
pub use block_ids::BlockIds;
pub use condition::eval_condition;
pub use config::{BUFFERS, Buffer, Config, Format, Kind, buffer_index, draw_buffers};
pub use config::{BUFFERS, Buffer, Config, Format, Kind, Shadow, buffer_index, draw_buffers};
pub use custom::{Custom, Val};
pub use discover::{Found, discover};
pub use lang::Lang;
pub use macros::{MC_VERSION, Macros, RENDER_STAGES};
pub use macros::{MC_VERSION, Macros, RENDER_STAGES, render_stage};
pub use options::switches_on;
pub use pack::{Pack, PackError};
pub use post::{Group, Post, PostProgram, dimension_folder, load_post};
pub use post::{
Blend, CELESTIAL_BLEND, Factor, GameInputs, Group, Post, PostProgram, TRANSLUCENT_BLEND,
dimension_folder, load_post,
};
pub use preprocess::{Diagnostic, Origin, Preprocessed, preprocess};
pub use properties::{Entry, Note, Properties};
pub use translate::{
Error, GbuffersInputs, Interface, Program, Sampler, Target, Uniform, translate_composite,
translate_gbuffers,
AlphaTest, DRAW_UNIFORMS, Error, GbuffersInputs, Interface, Program, Sampler, Target, Uniform,
translate_composite, translate_gbuffers,
};
+8
View File
@@ -60,6 +60,14 @@ pub const RENDER_STAGES: [&str; 24] = [
"HAND_TRANSLUCENT",
];
/// The value of `MC_RENDER_STAGE_<name>` (OQ-7: its index in `RENDER_STAGES`).
pub fn render_stage(name: &str) -> u32 {
RENDER_STAGES
.iter()
.position(|s| *s == name)
.unwrap_or_else(|| panic!("no render stage {name}")) as u32
}
impl Macros {
/// The standard macros that need no renderer (spec 1.5.1): `MC_VERSION`, this system's
/// `MC_OS_*`, the GL and GLSL versions Horizon's translation accepts, the render stages and
+103
View File
@@ -0,0 +1,103 @@
//! Switch options (spec 8.1), as far as program-enable expressions (3.3) need them: which are on
//! by default. A switch is `#define NAME` (on) or `//#define NAME` (off) with nothing after the
//! name but a comment, in any stage or included file of the pack. Packs keep their options in
//! included `.glsl` files (or files of any name a source includes) and test them elsewhere
//! (OQ-13), so the test the spec asks for (`#ifdef NAME` / `#ifndef NAME`) may be in any file
//! of the pack.
use std::collections::BTreeSet;
use crate::Pack;
const SOURCES: [&str; 8] = ["vsh", "fsh", "gsh", "csh", "tcs", "tes", "glsl", "inc"];
/// The switch options that are on by default.
pub fn switches_on(pack: &Pack) -> BTreeSet<String> {
let (mut on, mut off, mut tested) = (BTreeSet::new(), BTreeSet::new(), BTreeSet::new());
let files = pack.all_files();
let source = |path: &str| SOURCES.contains(&path.rsplit_once('.').map_or("", |(_, e)| e));
let texts: Vec<(&String, String)> = files
.iter()
.filter(|p| source(p))
.filter_map(|p| Some((p, pack.read_text(p)?)))
.collect();
// Files of other names count when a source includes them (`#include "shaders.settings"`).
let included: BTreeSet<&str> = texts
.iter()
.flat_map(|(_, t)| t.lines())
.filter_map(|l| l.trim().strip_prefix("#include"))
.map(|r| r.trim().trim_matches(|c| c == '"' || c == '<' || c == '>'))
.map(|r| r.rsplit('/').next().unwrap_or(r))
.collect();
let extra: Vec<(&String, String)> = files
.iter()
.filter(|p| !source(p) && included.contains(p.rsplit('/').next().unwrap_or(p)))
.filter_map(|p| Some((p, pack.read_text(p)?)))
.collect();
for (_, text) in texts.iter().chain(&extra) {
for line in text.lines() {
let line = line.trim();
let (commented, rest) = match line.strip_prefix("//") {
Some(rest) => (true, rest.trim_start()),
None => (false, line),
};
let Some((directive, rest)) = rest
.strip_prefix('#')
.map(str::trim_start)
.and_then(|r| r.split_once(|c: char| c.is_whitespace()))
else {
continue;
};
let mut words = rest.split_whitespace();
let Some(name) = words.next() else { continue };
match directive {
"ifdef" | "ifndef" if !commented => _ = tested.insert(name.to_owned()),
"define" if words.next().is_none_or(|w| w.starts_with("//")) => {
let set = if commented { &mut off } else { &mut on };
set.insert(name.to_owned());
}
_ => {}
}
}
}
// Defined both ways is ambiguous (8.1): it keeps its default only where it is on everywhere.
on.retain(|name| tested.contains(name) && !off.contains(name));
on
}
#[cfg(test)]
mod tests {
use super::*;
use crate::pack::tests::zip;
#[test]
fn switches_need_a_test_and_no_value() {
let pack = Pack::from_zip_bytes(
"P.zip",
zip(&[
(
"shaders/lib/settings.glsl",
" #define AO // ambient occlusion\n//#define BLOOM\n#define LEVEL 2 //[1 2]\n\
#define SPLIT\n#define UNTESTED\n",
),
(
"shaders/world0/deferred.fsh",
"#ifdef AO\n#endif\n#ifndef BLOOM\n#endif\n#ifdef SPLIT\n#endif\n#ifdef LEVEL\n#endif\n",
),
("shaders/world-1/deferred.fsh", "//#define SPLIT\n"),
(
"shaders/final.fsh",
"#include \"shaders.settings\"\n#ifdef GODRAYS\n#endif\n",
),
("shaders/shaders.settings", " #define GODRAYS //Toggle\n"),
("shaders/notes.settings", "#define NOT_INCLUDED\n#ifdef NOT_INCLUDED\n"),
("shaders/shaders.properties", "#define NOT_SOURCE\n#ifdef NOT_SOURCE\n"),
]),
)
.unwrap();
assert_eq!(
switches_on(&pack),
BTreeSet::from(["AO".to_owned(), "GODRAYS".to_owned()])
);
}
}
+33
View File
@@ -167,6 +167,39 @@ impl Pack {
names.sort();
names
}
/// Every file of the pack, by its path inside `shaders`, sorted.
pub fn all_files(&self) -> Vec<String> {
let mut names = match &self.files {
Files::Folder(root) => {
let mut names = Vec::new();
let mut dirs = vec![String::new()];
while let Some(dir) = dirs.pop() {
for e in fs::read_dir(root.join(&dir))
.into_iter()
.flatten()
.flatten()
{
let name = e.file_name().to_string_lossy().into_owned();
let path = if dir.is_empty() {
name
} else {
format!("{dir}/{name}")
};
match e.file_type() {
Ok(t) if t.is_dir() => dirs.push(path),
Ok(t) if t.is_file() => names.push(path),
_ => {}
}
}
}
names
}
Files::Zip { entries, .. } => entries.keys().cloned().collect(),
};
names.sort();
names
}
}
/// `a/./b/../c` → `a/c`; `None` for a path that climbs out of `shaders`.
+482 -16
View File
@@ -10,7 +10,10 @@
//! - A program that fails to translate is reported and treated as missing (2.5).
//! - Terrain draws with the first program of its fallback chain that loads (2.3).
use std::collections::BTreeSet;
use crate::config::{self, Config};
use crate::custom::Custom;
use crate::{GbuffersInputs, Macros, Pack, Preprocessed, Program, Properties, Target};
use crate::{eval_condition, preprocess, translate_composite, translate_gbuffers};
@@ -21,10 +24,67 @@ pub enum Group {
Deferred,
Composite,
Final,
/// A gbuffers program: the game draws its geometry with it.
/// A gbuffers program: the game draws its geometry with it, before deferred.
Gbuffers,
/// A gbuffers program drawing translucent geometry, after deferred (2.1).
Translucent,
}
/// A blend factor of `blend.<program>` (3.2), as GL names it.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Factor {
Zero,
One,
SrcColor,
OneMinusSrcColor,
DstColor,
OneMinusDstColor,
SrcAlpha,
OneMinusSrcAlpha,
DstAlpha,
OneMinusDstAlpha,
SrcAlphaSaturate,
}
impl Factor {
fn parse(word: &str) -> Option<Self> {
Some(match word {
"ZERO" => Self::Zero,
"ONE" => Self::One,
"SRC_COLOR" => Self::SrcColor,
"ONE_MINUS_SRC_COLOR" => Self::OneMinusSrcColor,
"DST_COLOR" => Self::DstColor,
"ONE_MINUS_DST_COLOR" => Self::OneMinusDstColor,
"SRC_ALPHA" => Self::SrcAlpha,
"ONE_MINUS_SRC_ALPHA" => Self::OneMinusSrcAlpha,
"DST_ALPHA" => Self::DstAlpha,
"ONE_MINUS_DST_ALPHA" => Self::OneMinusDstAlpha,
"SRC_ALPHA_SATURATE" => Self::SrcAlphaSaturate,
_ => return None,
})
}
}
/// Source and destination factors for colour, then for alpha.
pub type Blend = [Factor; 4];
/// The default blend of translucent geometry (3.2).
pub const TRANSLUCENT_BLEND: Blend = [
Factor::SrcAlpha,
Factor::OneMinusSrcAlpha,
Factor::One,
Factor::OneMinusSrcAlpha,
];
/// `gbuffers_water` and its fallbacks (2.3).
const WATER: [&str; 5] = [
"gbuffers_water",
"gbuffers_terrain",
"gbuffers_textured_lit",
"gbuffers_textured",
"gbuffers_basic",
];
/// `gbuffers_terrain` and its fallbacks (2.3).
const TERRAIN: [&str; 4] = [
"gbuffers_terrain",
@@ -33,6 +93,77 @@ const TERRAIN: [&str; 4] = [
"gbuffers_basic",
];
/// `gbuffers_skybasic` and its fallback (2.3).
const SKY: [&str; 2] = ["gbuffers_skybasic", "gbuffers_basic"];
/// `gbuffers_skytextured` and its fallbacks (2.3).
const SKY_TEXTURED: [&str; 3] = [
"gbuffers_skytextured",
"gbuffers_textured",
"gbuffers_basic",
];
/// `gbuffers_entities` and its fallbacks (2.3).
const ENTITIES: [&str; 4] = [
"gbuffers_entities",
"gbuffers_textured_lit",
"gbuffers_textured",
"gbuffers_basic",
];
/// `gbuffers_block` and its fallbacks (2.3).
const BLOCK: [&str; 5] = [
"gbuffers_block",
"gbuffers_terrain",
"gbuffers_textured_lit",
"gbuffers_textured",
"gbuffers_basic",
];
/// `gbuffers_clouds`: no fallback, the game draws its clouds otherwise (OQ-3).
const CLOUDS: [&str; 1] = ["gbuffers_clouds"];
/// `gbuffers_hand` and its fallbacks (2.3).
const HAND: [&str; 4] = [
"gbuffers_hand",
"gbuffers_textured_lit",
"gbuffers_textured",
"gbuffers_basic",
];
/// `gbuffers_weather` and its fallbacks (2.3).
const WEATHER: [&str; 4] = [
"gbuffers_weather",
"gbuffers_textured_lit",
"gbuffers_textured",
"gbuffers_basic",
];
/// `gbuffers_entities_translucent` and its fallbacks (2.3).
const ENTITIES_TRANSLUCENT: [&str; 5] = [
"gbuffers_entities_translucent",
"gbuffers_entities",
"gbuffers_textured_lit",
"gbuffers_textured",
"gbuffers_basic",
];
/// `gbuffers_particles` and its fallbacks (2.3).
const PARTICLES: [&str; 4] = [
"gbuffers_particles",
"gbuffers_textured_lit",
"gbuffers_textured",
"gbuffers_basic",
];
/// The sun and moon's default blend: added to the sky, as vanilla draws them.
pub const CELESTIAL_BLEND: Blend = [
Factor::SrcAlpha,
Factor::One,
Factor::One,
Factor::OneMinusSrcAlpha,
];
const GROUPS: [(Group, &str); 4] = [
(Group::Prepare, "prepare"),
(Group::Deferred, "deferred"),
@@ -49,6 +180,11 @@ pub struct PostProgram {
pub buffers: Vec<u32>,
/// `flip.<name>.<buffer>`: buffers forced to flip (true) or kept (false) after this program.
pub flips: Vec<(u32, bool)>,
/// How a gbuffers program's output blends into its buffers; `None` writes them.
pub blend: Option<Blend>,
/// Bit n: `colortex<n>MipmapEnabled` in its fragment stage, so buffer n's mip chain is
/// regenerated right before it (6.1.7; not for gbuffers programs).
pub mipmaps: u16,
}
pub struct Post {
@@ -60,6 +196,32 @@ pub struct Post {
pub composite_pre: Vec<(u32, bool)>,
/// What draws solid and cutout terrain, when the game asked for it and one loads.
pub terrain: Option<PostProgram>,
/// What draws translucent terrain (water, stained glass) after deferred.
pub water: Option<PostProgram>,
/// What draws the sky (disc, sunset, stars, void) before terrain.
pub sky: Option<PostProgram>,
/// What draws the sun and moon, between the sunset and the stars.
pub sky_textured: Option<PostProgram>,
/// What draws entities, after terrain.
pub entities: Option<PostProgram>,
/// What draws block entities, after terrain.
pub block: Option<PostProgram>,
/// What draws translucent entities (name tags, shadows), after the others.
pub entities_translucent: Option<PostProgram>,
/// What draws particles.
pub particles: Option<PostProgram>,
/// What draws the game's clouds.
pub clouds: Option<PostProgram>,
/// What draws rain and snow, after deferred.
pub weather: Option<PostProgram>,
/// What draws the first-person hand and held items.
pub hand: Option<PostProgram>,
/// Translucent entities draw after deferred (`separateEntityDraws`, 3.2).
pub translucent_late: bool,
/// Particles draw after deferred (`particles.ordering`, `particles.before.deferred`, 3.2).
pub particles_late: bool,
/// The custom uniforms of `shaders.properties` (3.4).
pub custom: Custom,
pub config: Config,
/// Programs skipped and why, as `program: message` or `file:line: message`.
pub notes: Vec<String>,
@@ -76,14 +238,31 @@ pub fn dimension_folder(pack: &Pack, id: i32) -> String {
}
}
/// Loads the post-processing programs of `folder` and, given the game's terrain vertices, the
/// program terrain draws with.
/// The game's geometry a pack may draw with its gbuffers programs: each kind's vertex inputs,
/// when the game can draw it with a pack.
#[derive(Clone, Debug, Default)]
pub struct GameInputs {
pub terrain: Option<GbuffersInputs>,
pub sky: Option<GbuffersInputs>,
pub celestial: Option<GbuffersInputs>,
/// Entities and block entities (one vertex format).
pub entities: Option<GbuffersInputs>,
/// The clouds' mesh.
pub clouds: Option<GbuffersInputs>,
/// Rain and snow.
pub weather: Option<GbuffersInputs>,
/// The first-person hand and held items.
pub hand: Option<GbuffersInputs>,
}
/// Loads the post-processing programs of `folder` and, for the geometry `inputs` describes, the
/// gbuffers programs it draws with.
pub fn load_post(
pack: &Pack,
folder: &str,
properties: &Properties,
macros: &Macros,
terrain: Option<&GbuffersInputs>,
inputs: &GameInputs,
) -> Post {
let mut post = Post {
folder: folder.to_owned(),
@@ -91,6 +270,19 @@ pub fn load_post(
deferred_pre: flips(properties, "deferred_pre"),
composite_pre: flips(properties, "composite_pre"),
terrain: None,
water: None,
sky: None,
sky_textured: None,
entities: None,
block: None,
entities_translucent: None,
particles: None,
clouds: None,
weather: None,
hand: None,
translucent_late: false,
particles_late: false,
custom: Custom::parse(properties),
config: Config::default(),
notes: Vec::new(),
};
@@ -99,6 +291,7 @@ pub fn load_post(
folder,
properties,
macros,
switches: crate::switches_on(pack),
post: &mut post,
};
for (group, base) in GROUPS {
@@ -119,13 +312,128 @@ pub fn load_post(
}
}
}
if let Some(inputs) = terrain {
loader.post.terrain = TERRAIN.iter().find_map(|name| {
loader.load(name.to_string(), Group::Gbuffers, |v, f| {
translate_gbuffers(v, f, Target::Buffers, inputs)
let mut gbuffers = |names: &[&str], group, inputs: &GbuffersInputs| {
names.iter().find_map(|name| {
// `alphaTest.<program>` replaces the geometry's default test (OQ-23).
let key = properties.get(&format!("alphaTest.{name}"));
let test = key.and_then(|v| crate::AlphaTest::parse(v.trim()));
let mut inputs = inputs.clone();
if let Some(test) = test {
inputs.alpha_test = test;
}
loader.load(name.to_string(), group, |v, f| {
translate_gbuffers(v, f, Target::Buffers, &inputs)
})
})
};
// The sky blends as vanilla draws its sunset fan and stars unless `blend.*` says otherwise.
let sky = inputs
.sky
.as_ref()
.and_then(|i| gbuffers(&SKY, Group::Gbuffers, i));
let sky = sky.map(|mut p| {
p.blend = blend(properties, &p.name).unwrap_or(Some(TRANSLUCENT_BLEND));
p
});
let celestial = inputs.celestial.as_ref();
let sky_textured = celestial.and_then(|i| gbuffers(&SKY_TEXTURED, Group::Gbuffers, i));
let sky_textured = sky_textured.map(|mut p| {
p.blend = blend(properties, &p.name).unwrap_or(Some(CELESTIAL_BLEND));
p
});
// Entities and block entities draw without blending, as terrain does and as vanilla's
// cutout entity types do, unless `blend.*` says otherwise (OQ-23).
let entity_blend = |p: Option<PostProgram>| {
p.map(|mut p| {
p.blend = blend(properties, &p.name).flatten();
p
})
};
let (entities, block) = match &inputs.entities {
Some(i) => (
entity_blend(gbuffers(&ENTITIES, Group::Gbuffers, i)),
entity_blend(gbuffers(&BLOCK, Group::Gbuffers, i)),
),
None => (None, None),
};
// Translucent entities and particles blend (OQ-23). Particles keep vanilla's alpha cut at
// 0.1; translucent entities lose only fully transparent texels (a shadow fades out).
let translucent =
|names: &[&str],
cut: f32,
gbuffers: &mut dyn FnMut(&[&str], &GbuffersInputs) -> Option<PostProgram>| {
let i = inputs.entities.as_ref()?;
let mut i = i.clone();
i.alpha_test = Some(crate::AlphaTest {
op: ">",
reference: cut,
});
gbuffers(names, &i).map(|mut p| {
p.blend = blend(properties, &p.name).unwrap_or(Some(TRANSLUCENT_BLEND));
p
})
};
let mut gbuffers_dyn = |names: &[&str], i: &GbuffersInputs| gbuffers(names, Group::Gbuffers, i);
let entities_translucent = translucent(&ENTITIES_TRANSLUCENT, 0.0, &mut gbuffers_dyn);
let particles = translucent(&PARTICLES, 0.1, &mut gbuffers_dyn);
// Clouds blend, as vanilla's do (OQ-23).
let clouds = inputs
.clouds
.as_ref()
.and_then(|i| gbuffers_dyn(&CLOUDS, i));
let clouds = clouds.map(|mut p| {
p.blend = blend(properties, &p.name).unwrap_or(Some(TRANSLUCENT_BLEND));
p
});
// Rain and snow draw after deferred and blend, as vanilla's do (OQ-23).
let weather = inputs
.weather
.as_ref()
.and_then(|i| gbuffers(&WEATHER, Group::Translucent, i));
let weather = weather.map(|mut p| {
p.blend = blend(properties, &p.name).unwrap_or(Some(TRANSLUCENT_BLEND));
p
});
// The hand draws as entities do: no blending unless `blend.*` says otherwise (OQ-23).
let hand = inputs
.hand
.as_ref()
.and_then(|i| gbuffers(&HAND, Group::Gbuffers, i))
.map(|mut p| {
p.blend = blend(properties, &p.name).flatten();
p
});
if let Some(inputs) = &inputs.terrain {
let terrain = gbuffers(&TERRAIN, Group::Gbuffers, inputs);
// gbuffers_water falls back to gbuffers_terrain's chain (2.3).
let water = gbuffers(&WATER, Group::Translucent, inputs);
loader.post.terrain = terrain;
loader.post.water = water.map(|mut p| {
p.blend = blend(properties, &p.name).unwrap_or(Some(TRANSLUCENT_BLEND));
p
});
if let Some(p) = &mut loader.post.terrain {
p.blend = blend(properties, &p.name).flatten();
}
}
loader.post.sky = sky;
loader.post.sky_textured = sky_textured;
loader.post.entities = entities;
loader.post.block = block;
loader.post.entities_translucent = entities_translucent;
loader.post.particles = particles;
loader.post.clouds = clouds;
loader.post.weather = weather;
loader.post.hand = hand;
let flag = |key: &str| properties.get(key).map(|v| v.trim() == "true");
loader.post.translucent_late = flag("separateEntityDraws").unwrap_or(false);
// `after` when the pack has a deferred program, else `mixed`; ours are all translucent, so
// `mixed` draws them after deferred too.
loader.post.particles_late = match properties.get("particles.ordering").map(str::trim) {
Some("before") => false,
Some(_) => true,
None => !flag("particles.before.deferred").unwrap_or(false),
};
post.config = std::mem::take(&mut post.config).finish();
post
}
@@ -135,6 +443,7 @@ struct Loader<'a> {
folder: &'a str,
properties: &'a Properties,
macros: &'a Macros,
switches: BTreeSet<String>,
post: &'a mut Post,
}
@@ -156,7 +465,13 @@ impl Loader<'_> {
if !self.pack.exists(&fsh) || !self.pack.exists(&vsh) {
return None;
}
if !enabled(self.properties, self.folder, &name, self.macros) {
if !enabled(
self.properties,
self.folder,
&name,
self.macros,
&self.switches,
) {
return None;
}
if self.pack.exists(&path("gsh")) {
@@ -191,12 +506,24 @@ impl Loader<'_> {
self.post.config.read(&vertex);
self.post.config.read(&fragment);
let buffers = config::draw_buffers(&fragment).unwrap_or_else(|| (0..8).collect());
let mipmaps = match group {
Group::Gbuffers | Group::Translucent => 0,
_ => {
let mut own = Config::default();
own.read(&fragment);
(own.buffers.iter().enumerate())
.filter(|b| b.1.mipmap)
.fold(0, |m, (i, _)| m | 1 << i)
}
};
Some(PostProgram {
flips: flips(self.properties, &name),
name,
group,
program,
buffers,
blend: None,
mipmaps,
})
}
}
@@ -215,8 +542,14 @@ fn diagnostics(pp: &Preprocessed) -> Vec<String> {
}
/// `program.<name>.enabled` (or `program.<folder>/<name>.enabled`): a boolean expression over
/// switch options (3.3). An option is on when its macro is defined.
fn enabled(properties: &Properties, folder: &str, name: &str, macros: &Macros) -> bool {
/// switch options (3.3): those on by default (8.1) and the defined macros.
fn enabled(
properties: &Properties,
folder: &str,
name: &str,
macros: &Macros,
switches: &BTreeSet<String>,
) -> bool {
let keys = [
format!("program.{folder}/{name}.enabled"),
format!("program.{name}.enabled"),
@@ -230,6 +563,7 @@ fn enabled(properties: &Properties, folder: &str, name: &str, macros: &Macros) -
match token {
"true" => condition.push('1'),
"false" => condition.push('0'),
t if switches.contains(t) => condition.push('1'),
t if t.starts_with(|c: char| c.is_alphabetic() || c == '_') => {
condition.push_str(&format!("defined({t})"));
}
@@ -239,6 +573,20 @@ fn enabled(properties: &Properties, folder: &str, name: &str, macros: &Macros) -
eval_condition(&condition, macros).ok() != Some(0)
}
/// `blend.<program>`: `Some(None)` for `off`, `Some(factors)`, or `None` when absent or not
/// four known factors.
fn blend(properties: &Properties, program: &str) -> Option<Option<Blend>> {
let value = properties.get(&format!("blend.{program}"))?.trim();
if value == "off" {
return Some(None);
}
let factors: Vec<Factor> = value
.split_whitespace()
.map(Factor::parse)
.collect::<Option<_>>()?;
Some(Some(factors.try_into().ok()?))
}
/// `flip.<program>.<buffer>=<bool>` keys of one program.
fn flips(properties: &Properties, program: &str) -> Vec<(u32, bool)> {
let prefix = format!("flip.{program}.");
@@ -280,7 +628,8 @@ mod tests {
("shaders/deferred.vsh", VSH),
(
"shaders/deferred.fsh",
"#version 120\nvoid main() { gl_FragColor = vec4(1.0); }\n",
"#version 120\nconst bool colortex5MipmapEnabled = true;\n\
void main() { gl_FragColor = vec4(1.0); }\n",
),
("shaders/composite1.fsh", FSH),
("shaders/composite3.vsh", VSH),
@@ -307,11 +656,18 @@ mod tests {
);
assert_eq!(dimension_folder(&pack, 0), "");
assert_eq!(dimension_folder(&pack, -1), "world-1");
let post = load_post(&pack, "", &properties, &Macros::standard(), None);
let post = load_post(
&pack,
"",
&properties,
&Macros::standard(),
&GameInputs::default(),
);
let names: Vec<&str> = post.programs.iter().map(|p| p.name.as_str()).collect();
assert_eq!(names, ["deferred", "composite", "composite2", "final"]);
let p = &post.programs;
assert_eq!(p[0].buffers, (0..8).collect::<Vec<_>>());
assert_eq!((p[0].mipmaps, p[1].mipmaps), (1 << 5, 0));
assert_eq!(p[1].buffers, [3]);
assert_eq!(p[1].flips, [(3, false)]);
assert_eq!(p[2].flips, [(4, true)]);
@@ -327,13 +683,123 @@ mod tests {
let mut macros = Macros::standard();
macros.define("HQ", "");
let post = load_post(&pack, "world-1", &properties, &macros, None);
let post = load_post(
&pack,
"world-1",
&properties,
&macros,
&GameInputs::default(),
);
let names: Vec<&str> = post.programs.iter().map(|p| p.name.as_str()).collect();
assert_eq!(names, ["final"]);
let post = load_post(&pack, "", &properties, &macros, None);
let post = load_post(&pack, "", &properties, &macros, &GameInputs::default());
assert!(post.programs.iter().any(|p| p.name == "composite3"));
}
/// Water falls back to the terrain chain and blends by default, as the sky does; entities
/// and block entities fall back along theirs; `blend.*` overrides.
#[test]
fn water_falls_back_to_terrain_and_blends() {
let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/packs/terrain-test");
let pack = Pack::open(&dir).unwrap();
let macros = Macros::standard();
let inputs = crate::GbuffersInputs {
declarations: "layout(location = 0) in vec3 hz_v_pos;".into(),
body: " hz_Vertex = vec4(hz_v_pos, 1.0);\n hz_Color = vec4(1.0);\n".into(),
..Default::default()
};
let inputs = GameInputs {
terrain: Some(inputs.clone()),
sky: Some(inputs.clone()),
celestial: Some(inputs.clone()),
entities: Some(inputs.clone()),
clouds: Some(inputs.clone()),
weather: Some(inputs.clone()),
hand: Some(inputs),
};
let post = load_post(&pack, "", &Properties::default(), &macros, &inputs);
let (terrain, water) = (post.terrain.unwrap(), post.water.unwrap());
assert_eq!((terrain.group, terrain.blend), (Group::Gbuffers, None));
assert_eq!(water.name, "gbuffers_terrain");
let sky = post.sky.unwrap();
assert_eq!(
(sky.name.as_str(), sky.group, sky.blend),
(
"gbuffers_skybasic",
Group::Gbuffers,
Some(TRANSLUCENT_BLEND)
)
);
// gbuffers_skytextured falls back to gbuffers_textured, then gbuffers_basic.
let sun = post.sky_textured.unwrap();
assert_eq!(
(sun.name.as_str(), sun.blend),
("gbuffers_textured", Some(CELESTIAL_BLEND))
);
assert_eq!(
(water.group, water.blend),
(Group::Translucent, Some(TRANSLUCENT_BLEND))
);
// Entities fall back to gbuffers_textured, block entities to gbuffers_terrain; both
// draw without blending.
let (entities, block) = (post.entities.unwrap(), post.block.unwrap());
assert_eq!(
(entities.name.as_str(), entities.blend),
("gbuffers_textured", None)
);
assert_eq!(
(block.name.as_str(), block.blend),
("gbuffers_terrain", None)
);
// Translucent entity parts and particles blend; particles draw after deferred unless
// the pack says otherwise, translucent entities before unless `separateEntityDraws`.
let (translucent, particles) = (
post.entities_translucent.as_ref().unwrap(),
post.particles.as_ref().unwrap(),
);
assert_eq!(
(translucent.name.as_str(), translucent.blend),
("gbuffers_textured", Some(TRANSLUCENT_BLEND))
);
assert_eq!(particles.blend, Some(TRANSLUCENT_BLEND));
assert!(post.particles_late && !post.translucent_late);
// gbuffers_clouds has no fallback (OQ-3): without it the game draws its clouds.
assert!(post.clouds.is_none());
// The hand falls back to gbuffers_textured and does not blend.
let hand = post.hand.as_ref().unwrap();
assert_eq!(
(hand.name.as_str(), hand.group, hand.blend),
("gbuffers_textured", Group::Gbuffers, None)
);
// Weather falls back to gbuffers_textured, after deferred, blended.
let weather = post.weather.as_ref().unwrap();
assert_eq!(
(weather.name.as_str(), weather.group, weather.blend),
(
"gbuffers_textured",
Group::Translucent,
Some(TRANSLUCENT_BLEND)
)
);
let ordering = Properties::parse(
"particles.ordering = before\nseparateEntityDraws = true\n",
&macros,
);
let post = load_post(&pack, "", &ordering, &macros, &inputs);
assert!(!post.particles_late && post.translucent_late);
let properties = Properties::parse(
"blend.gbuffers_terrain = ONE ONE ZERO ONE\nblend.gbuffers_water = off\n",
&macros,
);
let terrain_blend = blend(&properties, "gbuffers_terrain");
assert_eq!(
terrain_blend,
Some(Some([Factor::One, Factor::One, Factor::Zero, Factor::One]))
);
assert_eq!(blend(&properties, "gbuffers_water"), Some(None));
assert_eq!(blend(&properties, "gbuffers_basic"), None);
}
#[test]
fn horizons_test_pack_loads() {
let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/packs/post-test");
@@ -345,7 +811,7 @@ mod tests {
&dimension_folder(&pack, 0),
&properties,
&macros,
None,
&GameInputs::default(),
);
assert!(post.notes.is_empty(), "{:?}", post.notes);
let names: Vec<&str> = post.programs.iter().map(|p| p.name.as_str()).collect();
+298 -10
View File
@@ -45,8 +45,19 @@ pub struct Interface {
pub samplers: Vec<Sampler>,
/// The fragment stage's output locations.
pub outputs: Vec<u32>,
/// A gbuffers program reads `DRAW_UNIFORMS`: the block at set 2, binding 0, set per draw.
pub draw: bool,
}
/// The uniforms a gbuffers program reads per draw (5.3's "D"), in a block of their own
/// (`HzDraw`, std140: three ints, a pad, a vec4; 32 bytes) the game sets for each draw.
pub const DRAW_UNIFORMS: [(&str, &str); 4] = [
("renderStage", "int"),
("entityId", "int"),
("blockEntityId", "int"),
("entityColor", "vec4"),
];
#[derive(Clone, Debug, PartialEq)]
pub struct Uniform {
pub name: String,
@@ -98,6 +109,43 @@ pub struct GbuffersInputs {
/// The value of each attribute a pack may declare (`mc_Entity`, `vaPosition`...), as a GLSL
/// expression of the declared type's size; an attribute not listed reads zero.
pub attributes: Vec<(String, String)>,
/// GLSL statements run last in `main`, with `gl_Position` in wgpu's clip space.
pub after: String,
/// The alpha test applied to output 0 (`gl_FragData[0]`, `gl_FragColor`), the loader's
/// (3.2 `alphaTest.<program>`): `None` keeps every fragment.
pub alpha_test: Option<AlphaTest>,
}
/// A fragment stays when its output 0's alpha compares to `reference` as `op` says (a GLSL
/// comparison operator, `true` for GL's `ALWAYS`, `false` for `NEVER`).
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct AlphaTest {
pub op: &'static str,
pub reference: f32,
}
impl AlphaTest {
/// `alphaTest.<program>`'s value: `off`, or a GL comparison and a reference.
pub fn parse(value: &str) -> Option<Option<Self>> {
let mut words = value.split_whitespace();
let func = words.next()?;
if func == "off" {
return Some(None);
}
let op = match func.trim_start_matches("GL_") {
"NEVER" => "false",
"LESS" => "<",
"EQUAL" => "==",
"LEQUAL" => "<=",
"GREATER" => ">",
"NOTEQUAL" => "!=",
"GEQUAL" => ">=",
"ALWAYS" => return Some(None),
_ => return None,
};
let reference = words.next()?.parse().ok()?;
Some(Some(Self { op, reference }))
}
}
/// Translates a composite-style program (`composite`, `deferred`, `final`...).
@@ -170,6 +218,17 @@ fn translate(
samplers.insert(name.clone(), ty.clone());
}
}
// Per-draw values move to their own block; another type than the documented one keeps
// the frame's block (and reads zero).
let mut draw = false;
if gbuffers.is_some() {
for (name, ty) in DRAW_UNIFORMS {
if uniforms.get(name).is_some_and(|t| t == ty) {
uniforms.remove(name);
draw = true;
}
}
}
let samplers: Vec<Sampler> = samplers
.into_iter()
.enumerate()
@@ -180,13 +239,30 @@ fn translate(
})
.collect();
// Varyings by name: the vertex outputs, then fragment inputs the vertex stage lacks.
// Varyings by name: the vertex outputs, then fragment inputs the vertex stage lacks. A
// matrix or array travels as one varying per column or element (`varying_parts`).
let mut locations: BTreeMap<String, (u32, String)> = BTreeMap::new();
let mut split: BTreeMap<String, (String, Vec<(String, String)>)> = BTreeMap::new();
for var in v.outs.iter().chain(&f.ins) {
let next = locations.len() as u32;
locations
.entry(var.name.clone())
.or_insert((next, var.decl.clone()));
if locations.contains_key(&var.name) || split.contains_key(&var.name) {
continue;
}
match varying_parts(&var.decl) {
Some((global, parts)) => {
let mut copies = Vec::new();
for (k, (decl, access)) in parts.into_iter().enumerate() {
let part = format!("hz_v_{}_{k}", var.name);
let next = locations.len() as u32;
locations.insert(part.clone(), (next, decl));
copies.push((part, access));
}
split.insert(var.name.clone(), (global, copies));
}
None => {
let next = locations.len() as u32;
locations.insert(var.name.clone(), (next, var.decl.clone()));
}
}
}
let header = |stage: &Stage| {
@@ -203,6 +279,12 @@ fn translate(
.unwrap();
}
h.push_str(" };\n");
if draw {
h.push_str(
"layout(set = 2, binding = 0) uniform HzDraw { int renderStage; int entityId; \
int blockEntityId; int hz_draw_pad; vec4 entityColor; };\n",
);
}
for s in &samplers {
let (texture, sampler) = split_sampler(&s.ty);
writeln!(
@@ -225,6 +307,9 @@ fn translate(
)
.unwrap();
}
for (name, (global, _)) in &split {
writeln!(h, "{}", global.replace("@", name)).unwrap();
}
if let (Some(inputs), ShaderStage::Vertex) = (gbuffers, stage.kind) {
h.push_str(&inputs.declarations);
h.push('\n');
@@ -262,9 +347,16 @@ fn translate(
for name in &v.inits {
writeln!(vertex_main, " {name} = hz_init_{name}();").unwrap();
}
vertex_main.push_str(" hz_main();\n");
for (name, (_, copies)) in &split {
for (part, access) in copies {
writeln!(vertex_main, " {part} = {name}{access};").unwrap();
}
}
write!(
vertex_main,
" hz_main();\n gl_Position = vec4(gl_Position.x, {flip}gl_Position.y, (gl_Position.z + gl_Position.w) * 0.5, gl_Position.w);\n}}\n"
" gl_Position = vec4(gl_Position.x, {flip}gl_Position.y, (gl_Position.z + gl_Position.w) * 0.5, gl_Position.w);\n{}}}\n",
gbuffers.map_or("", |g| &g.after)
)
.unwrap();
let mut fragment_main = String::from("\nvoid main() {\n");
@@ -278,10 +370,31 @@ fn translate(
Target::Buffers => " hz_FragCoord = gl_FragCoord;\n",
});
}
for (name, (_, copies)) in &split {
for (part, access) in copies {
writeln!(fragment_main, " {name}{access} = {part};").unwrap();
}
}
for name in &f.inits {
writeln!(fragment_main, " {name} = hz_init_{name}();").unwrap();
}
fragment_main.push_str(" hz_main();\n}\n");
fragment_main.push_str(" hz_main();\n");
// With `out` variables the pack tests alpha itself.
if let Some(t) = gbuffers.and_then(|g| g.alpha_test)
&& f.outputs.contains(&0)
&& !f.frag_outs.iter().any(|(n, _)| *n == 0)
{
match t.op {
"false" => fragment_main.push_str(" discard;\n"),
op => writeln!(
fragment_main,
" if (!(hz_out0.a {op} {:?})) {{ discard; }}",
t.reference
)
.unwrap(),
}
}
fragment_main.push_str("}\n");
let v_text = format!(
"{}{}{vertex_main}",
@@ -327,10 +440,57 @@ fn translate(
uniforms,
samplers,
outputs,
draw,
},
})
}
/// A matrix or array varying (`flat mat3 @[2];`): wgpu's stage interfaces take only scalars
/// and vectors (WGSL), so it becomes a private global (`mat3 @[2];`) and one varying per
/// column or element, each with the qualifiers and how to reach it (`[1][2]`). `None` for
/// scalars and vectors, and for sizes that are not plain numbers.
fn varying_parts(decl: &str) -> Option<(String, Vec<(String, String)>)> {
let (before, after) = decl.split_once('@')?;
let mut words: Vec<&str> = before.split_whitespace().collect();
let ty = words.pop()?;
let qualifiers: String = words.iter().map(|w| format!("{w} ")).collect();
let array = after.trim().trim_end_matches(';').trim();
let mut sizes = Vec::new();
let mut rest = array;
while let Some(r) = rest.strip_prefix('[') {
let (n, r) = r.split_once(']')?;
sizes.push(n.trim().parse::<usize>().ok()?);
rest = r.trim_start();
}
if !rest.is_empty() {
return None;
}
// matC or matCxR: C columns of R rows.
let column = ty.strip_prefix("mat").and_then(|d| {
let (c, r) = d.split_once('x').unwrap_or((d, d));
Some((c.parse::<usize>().ok()?, r.parse::<usize>().ok()?))
});
if sizes.is_empty() && column.is_none() {
return None;
}
let part_ty = column.map_or(ty.to_owned(), |(_, r)| format!("vec{r}"));
if let Some((c, _)) = column {
sizes.push(c);
}
let count: usize = sizes.iter().product();
let parts = (0..count)
.map(|mut k| {
let mut access = String::new();
for &size in sizes.iter().rev() {
access.insert_str(0, &format!("[{}]", k % size));
k /= size;
}
(format!("{qualifiers}{part_ty} @;"), access)
})
.collect();
Some((format!("{ty} @{array};"), parts))
}
/// `sampler2DShadow` → (`texture2D`, `samplerShadow`); `isampler3D` → (`itexture3D`, `sampler`).
pub(super) fn split_sampler(ty: &str) -> (String, &'static str) {
let shadow = ty.ends_with("Shadow");
@@ -394,7 +554,11 @@ fn compile(stage: &Stage, text: &str, header_lines: usize) -> Result<naga::Modul
/// The uniform block's size and member offsets, from naga's layout.
fn block_layout(module: &naga::Module) -> (u32, Vec<(String, u32)>) {
for (_, var) in module.global_variables.iter() {
if var.space != naga::AddressSpace::Uniform {
let frame = var
.binding
.as_ref()
.is_some_and(|b| b.group == 0 && b.binding == 0);
if var.space != naga::AddressSpace::Uniform || !frame {
continue;
}
if let naga::TypeInner::Struct { members, span } = &module.types[var.ty].inner {
@@ -472,6 +636,21 @@ mod tests {
assert_eq!(i.outputs, [0, 1]);
}
/// naga drops non-constant global initializers: they run in our `main`, one per declarator,
/// converting as GLSL's initialization does.
#[test]
fn global_initializers_read_uniforms() {
let fsh = "#version 120\nuniform float rainStrength;\nuniform ivec2 atlasSize;\n\
vec2 size = atlasSize;\nvec3 a = vec3(rainStrength), b = a * 2.0, c;\n\
const float k = rainStrength > 0.5 ? 1.0 : 0.0;\nfloat w[] = float[](rainStrength, 1.0);\n\
void main() { c = b; gl_FragColor = vec4(a + c, size.x * k + w[0]); }\n";
let p = program(
&[("composite.vsh", VSH_120), ("composite.fsh", fsh)],
Target::Window,
);
assert!(p.is_ok(), "{:?}", p.err());
}
#[test]
fn core_programs_translate() {
let vsh = "#version 330 core\nin vec3 vaPosition;\nin vec2 vaUV0;\nuniform mat4 modelViewMatrix, projectionMatrix;\n\
@@ -523,6 +702,79 @@ mod tests {
}
}
/// Code after an unconditional `discard` (BSL's `gbuffers_clouds` with its own clouds on)
/// or `return;` still makes a valid module.
#[test]
fn code_after_discard_or_return_translates() {
let vsh = "#version 120\nvoid main() { gl_Position = ftransform(); }\n";
for fsh in [
"#version 120\nuniform sampler2D texture;\nvoid main() {\n discard;\n vec4 c = texture2D(texture, vec2(0.5));\n gl_FragData[0] = c;\n}\n",
"#version 120\nvoid main() {\n gl_FragData[0] = vec4(1.0);\n return;\n gl_FragData[0] = vec4(0.5);\n}\n",
] {
let files = [
("shaders/gbuffers_clouds.vsh", vsh),
("shaders/gbuffers_clouds.fsh", fsh),
];
let pack = Pack::from_zip_bytes("P.zip", zip(&files)).unwrap();
let m = Macros::standard();
let inputs = GbuffersInputs {
body: " hz_Vertex = vec4(0.0, 0.0, 0.0, 1.0);\n".into(),
..Default::default()
};
translate_gbuffers(
&preprocess(&pack, "gbuffers_clouds.vsh", &m),
&preprocess(&pack, "gbuffers_clouds.fsh", &m),
Target::Buffers,
&inputs,
)
.unwrap_or_else(|e| panic!("{fsh}: {e:?}"));
}
}
#[test]
fn the_alpha_test_discards_below_its_reference() {
assert_eq!(
AlphaTest::parse("GREATER 0.1"),
Some(Some(AlphaTest {
op: ">",
reference: 0.1
}))
);
assert_eq!(AlphaTest::parse("off"), Some(None));
assert_eq!(AlphaTest::parse("GL_ALWAYS 0"), Some(None));
assert_eq!(AlphaTest::parse("SOMETIMES 0.5"), None);
let vsh = "#version 120\nvoid main() { gl_Position = ftransform(); }\n";
let legacy = "#version 120\nvoid main() { gl_FragData[0] = vec4(0.5); }\n";
let outs =
"#version 330\nlayout(location = 0) out vec4 c;\nvoid main() { c = vec4(0.5); }\n";
for (fsh, kills) in [(legacy, true), (outs, false)] {
let files = [
("shaders/gbuffers_entities.vsh", vsh),
("shaders/gbuffers_entities.fsh", fsh),
];
let pack = Pack::from_zip_bytes("P.zip", zip(&files)).unwrap();
let m = Macros::standard();
let inputs = GbuffersInputs {
body: " hz_Vertex = vec4(0.0, 0.0, 0.0, 1.0);\n".into(),
alpha_test: AlphaTest::parse("GREATER 0.1").unwrap(),
..Default::default()
};
let p = translate_gbuffers(
&preprocess(&pack, "gbuffers_entities.vsh", &m),
&preprocess(&pack, "gbuffers_entities.fsh", &m),
Target::Buffers,
&inputs,
)
.unwrap_or_else(|e| panic!("{e:?}"));
let functions = p.fragment.functions.iter().map(|(_, f)| f);
let kill = functions
.chain([&p.fragment.entry_points[0].function])
.any(|f| format!("{:?}", f.body).contains("Kill"));
// With `out` variables the pack tests alpha itself.
assert_eq!(kill, kills, "{fsh}");
}
}
#[test]
fn gbuffers_programs_read_the_games_vertices() {
let vsh = "#version 120\nattribute vec4 mc_Entity;\nattribute vec2 mc_midTexCoord;\nvarying vec2 uv;\nvarying vec2 light;\n\
@@ -531,9 +783,9 @@ mod tests {
light = (gl_TextureMatrix[1] * gl_MultiTexCoord1).xy;\n color = gl_Color;\n \
normal = normalize(gl_NormalMatrix * gl_Normal);\n id = mc_Entity.x + mc_midTexCoord.x;\n}\n";
let fsh = "#version 120\nuniform sampler2D texture;\nuniform sampler2D lightmap;\nuniform mat4 gbufferModelView;\n\
varying vec2 uv;\nvarying vec2 light;\nvarying vec4 color;\nvarying vec3 normal;\nvarying float id;\n\
uniform int renderStage;\nvarying vec2 uv;\nvarying vec2 light;\nvarying vec4 color;\nvarying vec3 normal;\nvarying float id;\n\
void main() {\n vec4 c = texture2D(texture, uv) * texture2D(lightmap, light) * color;\n \
/* DRAWBUFFERS:02 */\n gl_FragData[0] = c * gl_FragCoord.z;\n \
/* DRAWBUFFERS:02 */\n gl_FragData[0] = c * gl_FragCoord.z * float(renderStage);\n \
gl_FragData[1] = vec4(normal * 0.5 + 0.5, id);\n}\n";
let files: Vec<(String, &str)> =
[("gbuffers_terrain.vsh", vsh), ("gbuffers_terrain.fsh", fsh)]
@@ -549,6 +801,7 @@ mod tests {
hz_MultiTexCoord1 = vec4(240.0, 240.0, 0.0, 1.0);\n hz_Color = vec4(1.0);\n hz_Normal = vec3(0.0, 1.0, 0.0);\n"
.into(),
attributes: vec![("mc_midTexCoord".into(), "vec2(game_uv) / 32768.0".into())],
..Default::default()
};
let p = translate_gbuffers(
&preprocess(&pack, "gbuffers_terrain.vsh", &m),
@@ -571,6 +824,14 @@ mod tests {
assert!(names.contains(&name), "{name} missing from {names:?}");
}
assert_eq!(p.interface.outputs, vec![0, 1]);
// renderStage is set per draw, in its own block.
assert!(p.interface.draw && !names.contains(&"renderStage"));
let per_draw = p.fragment.global_variables.iter().any(|(_, v)| {
v.binding
.as_ref()
.is_some_and(|b| b.group == 2 && b.binding == 0)
});
assert!(per_draw);
let inputs: Vec<&str> = p.vertex.entry_points[0]
.function
.arguments
@@ -583,6 +844,33 @@ mod tests {
);
}
#[test]
fn matrix_and_array_varyings_travel_in_parts() {
let vsh = "#version 120\nvarying mat3 tbn;\nflat varying ivec2 ids[2];\nvarying mat2x3 m[2];\n\
void main() {\n gl_Position = ftransform();\n tbn = mat3(2.0);\n \
ids[1] = ivec2(3);\n m[1][0] = vec3(4.0);\n}\n";
let fsh = "#version 120\nvarying mat3 tbn;\nflat varying ivec2 ids[2];\nvarying mat2x3 m[2];\n\
void main() { gl_FragColor = vec4(tbn[2] + m[1][0], float(ids[1].x)); }\n";
let p = program(
&[("composite.vsh", vsh), ("composite.fsh", fsh)],
Target::Buffers,
)
.unwrap_or_else(|e| panic!("{e:?}"));
let inputs = p.fragment.entry_points[0].function.arguments.len();
// 3 columns + 2 elements + 2 x 2 columns, and the fragment position.
assert!(inputs >= 9, "{inputs} inputs");
assert_eq!(
varying_parts("flat ivec2 @[2];").unwrap().1,
[
("flat ivec2 @;".to_owned(), "[0]".to_owned()),
("flat ivec2 @;".to_owned(), "[1]".to_owned())
]
);
assert_eq!(varying_parts("mat2x3 @[2];").unwrap().1[3].1, "[1][1]");
assert!(varying_parts("vec4 @;").is_none());
assert!(varying_parts("vec4 @[N];").is_none());
}
#[test]
fn locals_may_hide_a_sampler() {
let fsh = "#version 120\nuniform sampler2D specular;\nstruct M { float specular; };\n\
@@ -190,6 +190,13 @@ impl Stage<'_> {
}
let replaced: Option<String> = match t {
"main" if depth == 0 && called => Some("hz_main".into()),
// naga's frontend leaves the code after an unconditional `discard` or `return;`
// unreachable but half-built (a module that fails validation): behind an `if`
// it stays reachable as far as naga knows.
"discard" => Some("if (true) discard".into()),
"return" if next(i).is_some_and(|j| self.tokens[j] == ";") => {
Some("if (true) return".into())
}
// GLSL's `modf`, which naga's frontend lacks.
"modf" if called => Some("hz_modf".into()),
"texture2D" | "texture1D" | "texture3D" | "textureCube" if called => {
+95 -21
View File
@@ -338,41 +338,115 @@ impl<'p> Stage<'p> {
}
}
/// A global `T name = a ? b : c;`: naga can't evaluate a conditional at global scope, so
/// the initializer becomes a function of ours on the same line (`T name; T hz_init_name() {
/// return a ? b : c; }`), called by our `main` before the pack's.
/// A global `T name = a ? b : c;` or, without `const`, any initialized global: naga only
/// evaluates constant initializers at global scope (a conditional is not one; GL drivers
/// also take uniforms and other globals there), so each initializer becomes a function of
/// ours on the same line (`T a; T hz_init_a() { return T(...); } T b; ...`), called by our
/// `main` before the pack's, in file order. The return converts as GLSL's initialization
/// does (`vec2 v = ivec2(...)`).
pub(super) fn initializer(&mut self, words: &[usize], to: usize) {
let text = |i: usize| self.tokens[i];
let Some(eq) = words.iter().position(|&i| text(i) == "=") else {
return;
};
if !words[eq..].iter().any(|&i| text(i) == "?")
|| words[..eq].iter().any(|&i| text(i) == ",")
{
// Declarators, split at top-level commas: (first word, `=` if any, end).
let mut declarators = Vec::new();
let (mut begin, mut nesting, mut assign) = (0, 0i32, None);
for (n, &i) in words.iter().enumerate() {
match text(i) {
"(" | "[" | "{" => nesting += 1,
")" | "]" | "}" => nesting -= 1,
"=" if nesting == 0 && assign.is_none() => assign = Some(n),
"," if nesting == 0 => {
declarators.push((begin, assign.take(), n));
begin = n + 1;
}
_ => {}
}
}
declarators.push((begin, assign, words.len()));
let constant = words[..eq].iter().any(|&i| text(i) == "const");
let conditional =
|d: &(usize, Option<usize>, usize)| words[d.0..d.2].iter().any(|&i| text(i) == "?");
if constant && !declarators.iter().any(conditional) {
return;
}
let Some(name_at) = words[..eq].iter().rposition(|&i| is_ident(text(i))) else {
// The first declarator's name ends the type.
let first_end = declarators[0].1.unwrap_or(declarators[0].2);
let Some(name_at) = words[..first_end].iter().rposition(|&i| is_ident(text(i))) else {
return;
};
let name = text(words[name_at]).to_owned();
let array: String = words[name_at + 1..eq].iter().map(|&i| text(i)).collect();
let ty: Vec<&str> = words[..name_at]
.iter()
.map(|&i| text(i))
.filter(|&t| t != "const")
.collect();
let Some(ty) = ty.last() else { return };
// The type, with a `vec3[]`'s count written in.
let mut ty = String::new();
for &i in &words[..name_at] {
match text(i) {
"const" => {}
"]" if ty.ends_with('[') => match self.array_length(i) {
Some(n) => write!(ty, "{n}]").unwrap(),
None => return,
},
t if ty.is_empty() || t == "[" => ty.push_str(t),
// Qualifiers before the type (`highp`...): the type is the last word.
t => ty = t.to_owned(),
}
}
if ty.is_empty() {
return;
}
let mut replaced = Vec::new();
let mut names = Vec::new();
for (n, &(begin, assign, end)) in declarators.iter().enumerate() {
let name_at = if n == 0 { name_at } else { begin };
let name = text(words[name_at]).to_owned();
if !is_ident(&name) {
return;
}
let stop = assign.unwrap_or(end);
let mut array: String = words[name_at + 1..stop].iter().map(|&i| text(i)).collect();
if array == "[]" {
// `T x[] = T[](a, b)`: the count is written in, as the rewrite does for the name.
match assign.and_then(|a| self.array_length(words[a - 1])) {
Some(n) => array = format!("[{n}]"),
None => return,
}
}
let next = if n + 1 < declarators.len() {
format!(" {ty}")
} else {
String::new()
};
let end_token = words.get(end).copied().unwrap_or(to);
match assign {
Some(a) => {
// Scalars, vectors and matrices convert; arrays and structs must match.
let scalar = array.is_empty()
&& !ty.contains('[')
&& (matches!(ty.as_str(), "float" | "int" | "uint" | "bool")
|| ty.contains("vec")
|| ty.starts_with("mat"));
let (open, close) = if scalar {
(format!("{ty}("), ")")
} else {
(String::new(), "")
};
replaced.push((
words[a],
format!("; {ty}{array} hz_init_{name}() {{ return {open}"),
));
replaced.push((end_token, format!("{close}; }}{next}")));
names.push(name);
}
None if n + 1 < declarators.len() => replaced.push((end_token, format!(";{next}"))),
None => {}
}
}
for &i in &words[..name_at] {
if text(i) == "const" {
self.removed.push(i..i + 1);
}
}
self.replaced.insert(
words[eq],
format!("; {ty}{array} hz_init_{name}() {{ return"),
);
self.replaced.insert(to, "; }".into());
self.inits.push(name);
self.replaced.extend(replaced);
self.inits.extend(names);
}
/// A function definition or prototype: remember which parameters are samplers.
@@ -0,0 +1,11 @@
# terrain-test
Horizon's own shader pack for testing gbuffers terrain (written for Horizon, no other pack's code).
`gbuffers_terrain` draws blocks from the atlas with their vertex colour and lightmap, tinted by
the lightmap coordinate's sky light (cooler where the sky is hidden); `mc_midTexCoord` marks each
face's centre with a dot; leaves (id 1 in `block.properties`) are yellow, and any stage but solid terrain (translucent terrain falls back to it)
is red. `gbuffers_skybasic` draws the sky in its vertex colour, a little greener, with magenta
stars and a dark red void; `gbuffers_textured` (the fallback of `gbuffers_skytextured`) the sun,
and the moon tinted green. `composite` puts the depth buffer's view-space distance into the blue
channel of the far half. Copy the folder into `shaderpacks/` and run the game with
`HORIZON_SHADER_PACK=terrain-test`.
@@ -0,0 +1,3 @@
# Leaves draw yellow in gbuffers_terrain.
block.1=oak_leaves spruce_leaves birch_leaves jungle_leaves acacia_leaves dark_oak_leaves \
mangrove_leaves cherry_leaves azalea_leaves flowering_azalea_leaves pale_oak_leaves
@@ -0,0 +1,19 @@
#version 120
uniform sampler2D colortex0;
uniform sampler2D depthtex0;
uniform mat4 gbufferProjectionInverse;
uniform float far;
varying vec2 texcoord;
void main() {
vec3 color = texture2D(colortex0, texcoord).rgb;
if (texcoord.x > 0.5) {
float depth = texture2D(depthtex0, texcoord).r;
vec4 view = gbufferProjectionInverse * vec4(vec3(texcoord, depth) * 2.0 - 1.0, 1.0);
color.b = clamp(length(view.xyz / view.w) / far, 0.0, 1.0);
}
/* DRAWBUFFERS:0 */
gl_FragData[0] = vec4(color, 1.0);
}
@@ -0,0 +1,8 @@
#version 120
varying vec2 texcoord;
void main() {
gl_Position = ftransform();
texcoord = gl_MultiTexCoord0.xy;
}
@@ -0,0 +1,15 @@
#version 120
uniform int renderStage;
varying vec4 glcolor;
void main() {
vec4 color = glcolor;
// Stars magenta, the void dark red, the sky disc a little greener: each stage is told apart.
if (renderStage == MC_RENDER_STAGE_STARS) color.rgb = vec3(1.0, 0.0, 1.0);
if (renderStage == MC_RENDER_STAGE_VOID) color.rgb = vec3(0.3, 0.0, 0.0);
if (renderStage == MC_RENDER_STAGE_SKY) color.g = min(color.g + 0.2, 1.0);
/* DRAWBUFFERS:0 */
gl_FragData[0] = color;
}
@@ -0,0 +1,8 @@
#version 120
varying vec4 glcolor;
void main() {
gl_Position = ftransform();
glcolor = gl_Color;
}
@@ -0,0 +1,28 @@
#version 120
uniform sampler2D texture;
uniform sampler2D lightmap;
uniform ivec2 atlasSize;
uniform int renderStage;
varying vec2 texcoord;
varying vec2 lmcoord;
varying vec2 mid;
varying vec4 glcolor;
varying float blockId;
void main() {
vec4 color = texture2D(texture, texcoord) * glcolor;
if (color.a < 0.1) discard;
color.rgb *= texture2D(lightmap, lmcoord).rgb;
// Less sky light: bluer.
color.rgb = mix(color.rgb * vec3(0.6, 0.7, 1.2), color.rgb, lmcoord.y);
// Leaves (block.properties' id 1) yellow.
if (abs(blockId - 1.0) < 0.5) color.rgb = vec3(color.g, color.g, 0.0);
// A dot at the face's centre, one texel wide.
if (length((texcoord - mid) * vec2(atlasSize)) < 1.0) color.rgb = vec3(1.0, 0.0, 1.0);
// Any other stage than solid terrain (translucent terrain falls back here): red.
if (renderStage != MC_RENDER_STAGE_TERRAIN_SOLID) color.rgb = vec3(1.0, 0.0, 0.0);
/* DRAWBUFFERS:0 */
gl_FragData[0] = color;
}
@@ -0,0 +1,19 @@
#version 120
attribute vec4 mc_midTexCoord;
attribute vec4 mc_Entity;
varying vec2 texcoord;
varying vec2 lmcoord;
varying vec2 mid;
varying vec4 glcolor;
varying float blockId;
void main() {
gl_Position = ftransform();
texcoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
lmcoord = (gl_TextureMatrix[1] * gl_MultiTexCoord1).xy;
mid = mc_midTexCoord.xy;
glcolor = gl_Color;
blockId = mc_Entity.x;
}
@@ -0,0 +1,15 @@
#version 120
uniform sampler2D texture;
uniform int renderStage;
varying vec2 texcoord;
varying vec4 glcolor;
void main() {
vec4 color = texture2D(texture, texcoord) * glcolor;
// The moon tinted green: the sun and the moon are told apart.
if (renderStage == MC_RENDER_STAGE_MOON) color.rb *= 0.3;
/* DRAWBUFFERS:0 */
gl_FragData[0] = color;
}
@@ -0,0 +1,10 @@
#version 120
varying vec2 texcoord;
varying vec4 glcolor;
void main() {
gl_Position = ftransform();
texcoord = (gl_TextureMatrix[0] * gl_MultiTexCoord0).xy;
glcolor = gl_Color;
}
+24 -8
View File
@@ -167,21 +167,37 @@ fn real_packs_read() {
declarations: "layout(location = 0) in vec3 hz_v_pos;".into(),
body: " hz_Vertex = vec4(hz_v_pos, 1.0);\n hz_Color = vec4(1.0);\n".into(),
attributes: vec![("mc_Entity".into(), "vec4(-1.0)".into())],
..Default::default()
};
let post = load_post(
&pack,
&folder,
&shaders,
&Macros::standard(),
Some(&terrain),
);
let inputs = horizon_shaders::GameInputs {
terrain: Some(terrain.clone()),
sky: Some(terrain.clone()),
celestial: Some(terrain.clone()),
entities: Some(terrain.clone()),
clouds: Some(terrain.clone()),
weather: Some(terrain.clone()),
hand: Some(terrain),
};
let post = load_post(&pack, &folder, &shaders, &Macros::standard(), &inputs);
println!(
" dimension {id} (folder `{folder}`): {} post programs, terrain {:?}, {} notes, {:.0} ms",
" dimension {id} (folder `{folder}`): {} post programs, terrain {:?}, water {:?}, sky {:?} {:?}, entities {:?} {:?}, {} notes, {:.0} ms",
post.programs.len(),
post.terrain.as_ref().map(|t| &t.name),
post.water.as_ref().map(|t| &t.name),
post.sky.as_ref().map(|t| &t.name),
post.sky_textured.as_ref().map(|t| &t.name),
post.entities.as_ref().map(|t| &t.name),
post.block.as_ref().map(|t| &t.name),
post.notes.len() + post.config.notes.len(),
start.elapsed().as_secs_f64() * 1000.0
);
let mut custom = post.custom;
custom.eval(0.016, &|_| None);
println!(
" {} custom uniforms; notes: {:?}",
custom.uniforms().count(),
custom.notes.iter().take(4).collect::<Vec<_>>()
);
for n in post.notes.iter().chain(&post.config.notes).take(12) {
println!(" {n}");
}
+1 -1
View File
@@ -6,7 +6,7 @@ license.workspace = true
rust-version = "1.85"
description = "Scheduling hints for the game's threads: the OS calls the crates that forbid unsafe code can't make"
[target.'cfg(any(target_vendor = "apple", target_os = "linux"))'.dependencies]
[target.'cfg(any(target_vendor = "apple", target_os = "linux", target_os = "android"))'.dependencies]
libc = "0.2"
[target.'cfg(windows)'.dependencies]
+63 -9
View File
@@ -45,8 +45,8 @@ fn favour() -> bool {
/// behind the server thread and the render thread (`behind_server`).
static HELPERS_BEHIND: AtomicBool = AtomicBool::new(false);
/// How many nice levels a helper thread goes below the process on Linux.
#[cfg(target_os = "linux")]
/// How many nice levels a helper thread goes below the process on Linux and Android.
#[cfg(any(target_os = "linux", target_os = "android"))]
const BEHIND: i32 = 10;
/// From now on, the helper threads that call `behind_server` as they start
@@ -58,7 +58,7 @@ pub fn put_helpers_behind() {
/// Called by a helper thread as it starts (world generation, lighting and
/// meshing, a connection's packet writer): work no tick or frame waits for.
/// Once `put_helpers_behind` was called, on Linux, where the server and
/// Once `put_helpers_behind` was called, on Linux and Android, where the server and
/// render threads can't be raised (`favour_current`), the helper lowers
/// itself instead, which an unprivileged thread may: 10 nice levels below
/// the process, or, where nice runs out (a game started under nice 10 or
@@ -69,10 +69,10 @@ pub fn behind_server() -> bool {
HELPERS_BEHIND.load(Ordering::Relaxed) && behind()
}
#[cfg(target_os = "linux")]
#[cfg(any(target_os = "linux", target_os = "android"))]
fn behind() -> bool {
// SAFETY: these read and set the calling thread's own nice value or
// policy (who 0, pid 0 is the calling thread on Linux); `param` lives
// policy (who 0, pid 0 is the calling thread on Linux and Android); `param` lives
// across the call.
unsafe {
let nice = libc::getpriority(libc::PRIO_PROCESS as _, 0);
@@ -85,11 +85,47 @@ fn behind() -> bool {
}
}
#[cfg(not(target_os = "linux"))]
#[cfg(not(any(target_os = "linux", target_os = "android")))]
fn behind() -> bool {
false
}
/// Run the calling thread only on a core nothing else wants: work that may
/// take seconds and that nothing waits for yet (the stronghold rings while a
/// world opens). The idle class on Linux, background quality of service on
/// macOS, idle priority on Windows. Whether the OS took it.
pub fn idle_current() -> bool {
idle()
}
#[cfg(target_os = "linux")]
fn idle() -> bool {
let param = libc::sched_param { sched_priority: 0 };
// SAFETY: sets the calling thread's own policy (pid 0); `param` lives
// across the call.
unsafe { libc::sched_setscheduler(0, libc::SCHED_IDLE, &param) == 0 }
}
#[cfg(target_vendor = "apple")]
fn idle() -> bool {
// SAFETY: sets the calling thread's own QoS class; no pointers.
unsafe { libc::pthread_set_qos_class_self_np(libc::qos_class_t::QOS_CLASS_BACKGROUND, 0) == 0 }
}
#[cfg(windows)]
fn idle() -> bool {
use windows_sys::Win32::System::Threading::{
GetCurrentThread, SetThreadPriority, THREAD_PRIORITY_IDLE,
};
// SAFETY: GetCurrentThread's pseudo handle needs no closing.
unsafe { SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_IDLE) != 0 }
}
#[cfg(not(any(target_os = "linux", target_vendor = "apple", windows)))]
fn idle() -> bool {
false
}
#[cfg(test)]
mod tests {
/// The hint holds on the platforms that take it.
@@ -117,12 +153,12 @@ mod tests {
}
/// A helper goes behind only once a dedicated server asks for it, and
/// then, on Linux, 10 nice levels below the process or in the idle class.
/// then, on Linux and Android, 10 nice levels below the process or in the idle class.
#[test]
fn helpers_go_behind_only_when_asked() {
assert!(!std::thread::spawn(super::behind_server).join().unwrap());
super::put_helpers_behind();
#[cfg(target_os = "linux")]
#[cfg(any(target_os = "linux", target_os = "android"))]
std::thread::spawn(|| {
// SAFETY: reads the calling thread's own nice value.
let before = unsafe { libc::getpriority(libc::PRIO_PROCESS as _, 0) };
@@ -142,7 +178,25 @@ mod tests {
})
.join()
.unwrap();
#[cfg(not(target_os = "linux"))]
#[cfg(not(any(target_os = "linux", target_os = "android")))]
assert!(!std::thread::spawn(super::behind_server).join().unwrap());
}
/// The idle hint holds on the three platforms.
#[test]
fn idling_a_thread_takes() {
let took = std::thread::spawn(super::idle_current).join().unwrap();
assert_eq!(
took,
cfg!(any(target_os = "linux", target_vendor = "apple", windows))
);
#[cfg(target_os = "linux")]
std::thread::spawn(|| {
assert!(super::idle_current());
// SAFETY: reads the calling thread's own policy.
assert_eq!(unsafe { libc::sched_getscheduler(0) }, libc::SCHED_IDLE);
})
.join()
.unwrap();
}
}
+78 -18
View File
@@ -13,10 +13,10 @@ use std::{
io::Write,
path::PathBuf,
sync::{
OnceLock,
Mutex, OnceLock,
atomic::{AtomicU64, Ordering},
},
time::UNIX_EPOCH,
time::{SystemTime, UNIX_EPOCH},
};
const MAGIC: &[u8; 8] = b"HZBEHAV\0";
@@ -149,22 +149,7 @@ fn fingerprint(registry: &BlockRegistry, root: &Path) -> io::Result<[u8; 32]> {
.duration_since(UNIX_EPOCH)
.map_err(|e| invalid(e.to_string()))?;
hasher.update(modified.as_nanos().to_le_bytes());
for relative in [
"facts.json",
"block-behaviours.json",
"gameplay-facts.json",
"block-tags.json",
"cached-collision.nbt",
] {
hash_file(&mut hasher, root, &root.join(relative))?;
}
let mut fluids: Vec<PathBuf> = fs::read_dir(root.join("data/minecraft/tags/fluid"))?
.map(|entry| entry.map(|entry| entry.path()))
.collect::<io::Result<_>>()?;
fluids.sort();
for path in fluids {
hash_file(&mut hasher, root, &path)?;
}
hasher.update(sources_digest(root)?);
// The registry argument may be modified independently of facts.json.
hasher.update((registry.len() as u64).to_le_bytes());
let mut seen = std::collections::HashSet::new();
@@ -190,6 +175,55 @@ fn fingerprint(registry: &BlockRegistry, root: &Path) -> io::Result<[u8; 32]> {
Ok(hasher.finalize().into())
}
/// The source files the snapshot is resolved from, as their lengths and
/// modification times, and the hash of their contents.
type Sources = (Vec<(PathBuf, u64, Option<SystemTime>)>, [u8; 32]);
/// Source hashes already computed by this process: the client's tables and
/// the world generator's are loaded from the same folder, and hashing its
/// 70 MB again took a third of a second on a 4-thread laptop. A file whose
/// length or modification time changed is read again.
static SOURCES: Mutex<Vec<Sources>> = Mutex::new(Vec::new());
fn sources_digest(root: &Path) -> io::Result<[u8; 32]> {
let mut paths: Vec<PathBuf> = [
"facts.json",
"block-behaviours.json",
"gameplay-facts.json",
"block-tags.json",
"cached-collision.nbt",
]
.iter()
.map(|relative| root.join(relative))
.collect();
let mut fluids: Vec<PathBuf> = fs::read_dir(root.join("data/minecraft/tags/fluid"))?
.map(|entry| entry.map(|entry| entry.path()))
.collect::<io::Result<_>>()?;
fluids.sort();
paths.extend(fluids);
let stamps = paths
.iter()
.map(|path| {
let meta = fs::metadata(path)?;
Ok((path.clone(), meta.len(), meta.modified().ok()))
})
.collect::<io::Result<Vec<_>>>()?;
let known = SOURCES.lock().unwrap_or_else(|e| e.into_inner());
if let Some((_, digest)) = known.iter().find(|(s, _)| *s == stamps) {
return Ok(*digest);
}
drop(known);
let mut hasher = Sha256::new();
for path in &paths {
hash_file(&mut hasher, root, path)?;
}
let digest: [u8; 32] = hasher.finalize().into();
SOURCES
.lock()
.unwrap_or_else(|e| e.into_inner())
.push((stamps, digest));
Ok(digest)
}
fn hash_str(hasher: &mut Sha256, text: &str) {
hasher.update((text.len() as u64).to_le_bytes());
hasher.update(text.as_bytes());
@@ -806,6 +840,32 @@ mod tests {
);
}
/// A folder's sources are hashed once while they stay as they are; a
/// file rewritten at the same length is hashed again.
#[test]
fn sources_are_hashed_once_until_a_file_changes() {
let Some(root) = fixture() else {
return;
};
let entries = || {
SOURCES
.lock()
.unwrap()
.iter()
.filter(|(stamps, _)| stamps[0].0.starts_with(&root.0))
.count()
};
let first = sources_digest(&root.0).unwrap();
assert_eq!(sources_digest(&root.0).unwrap(), first);
assert_eq!(entries(), 1);
let tags = root.0.join("block-tags.json");
let mut bytes = fs::read(&tags).unwrap();
bytes[0] ^= 1;
fs::write(&tags, bytes).unwrap();
assert_ne!(sources_digest(&root.0).unwrap(), first);
assert_eq!(entries(), 2);
}
#[test]
fn cache_invalidates_sources_and_recovers_from_corruption() {
let Some(root) = fixture() else {
@@ -592,6 +592,37 @@ impl Behaviours {
{
return InteractionResult::Pass;
}
if self.data(state).chain.contains(&Class::CopperGolemStatue) {
return self.turn_statue(level, ticks, pos, state, item);
}
self.use_without_item(level, ticks, pos, face, hit, player)
}
/// `CopperGolemStatueBlock.useItemOn` (and its weathering subclass's): anything but an axe
/// (`#minecraft:axes`, every one named `*_axe`), even an empty hand, turns the statue to its
/// next pose; honeycomb waxes a statue that still weathers instead.
fn turn_statue<L: LevelAccess + ?Sized>(
&self,
level: &mut L,
ticks: &mut Ticks,
pos: BlockPos,
state: BlockStateId,
item: Option<&str>,
) -> InteractionResult {
let item = item.unwrap_or("minecraft:air");
let waxed = self.table.name(state).starts_with("minecraft:waxed_");
if item.ends_with("_axe") || (item == "minecraft:honeycomb" && !waxed) {
return InteractionResult::Pass;
}
let mut sim = self.sim(level, ticks);
sim.sound(
pos,
&"minecraft:entity.copper_golem_become_statue".into(),
1.0,
1.0,
);
sim.set_block_and_update(pos, self.table.cycle(state, self.props.copper_golem_pose));
sim.game_event(pos, "minecraft:block_change");
InteractionResult::Success
}
}
+50 -9
View File
@@ -1652,7 +1652,7 @@ trait SeededPipeline: Send + Sync {
) -> Vec<Arc<super::structure::start::StructureStart>>;
fn unsupported_features(&self) -> Vec<(String, String)>;
fn forget_structure_starts(&self);
fn ring_positions(&self, set: &str) -> Option<Vec<ChunkPos>>;
fn ring_positions(&self, worker: &mut WorkerState, set: &str) -> Option<Vec<ChunkPos>>;
fn spawn_position(&self) -> Result<[i32; 2], GeneratorError>;
fn locate(
&self,
@@ -1752,8 +1752,15 @@ where
structures.forget_starts();
}
}
fn ring_positions(&self, set: &str) -> Option<Vec<ChunkPos>> {
self.structures.as_ref()?.cached_rings(set)
fn ring_positions(&self, worker: &mut WorkerState, set: &str) -> Option<Vec<ChunkPos>> {
self.structures.as_ref()?.ring_positions(
&mut StructureQueries {
pipeline: self,
worker,
valid: BTreeSet::new(),
},
set,
)
}
fn spawn_position(&self) -> Result<[i32; 2], GeneratorError> {
if let Some(position) = self.spawn_position.get() {
@@ -2375,11 +2382,6 @@ impl OverworldGenerator {
pub fn unsupported_features(&self) -> Vec<(String, String)> {
self.pipeline.unsupported_features()
}
/// ConcentricRingsStructurePlacement chunks of a structure set (such as
/// `minecraft:strongholds`), available once structure starts were looked up.
pub fn ring_positions(&self, set: &str) -> Option<Vec<ChunkPos>> {
self.pipeline.ring_positions(set)
}
/// NoiseBasedChunkGenerator.getOrigin: the chunk a new world's spawn
/// search starts from (NoiseSpawnFinder over the `spawn_target` points).
pub fn origin(&self) -> Result<ChunkPos, GeneratorError> {
@@ -2487,6 +2489,11 @@ impl GeneratorWorker {
pub fn jigsaw_pieces(&mut self, query: &JigsawQuery<'_>) -> Option<JigsawPieces> {
self.pipeline.jigsaw_pieces(&mut self.state, query)
}
/// ConcentricRingsStructurePlacement chunks of a structure set (such as
/// `minecraft:strongholds`), searched for now if nothing needed them yet.
pub fn ring_positions(&mut self, set: &str) -> Option<Vec<ChunkPos>> {
self.pipeline.ring_positions(&mut self.state, set)
}
/// STRUCTURE_STARTS: the structure starts owned by a chunk (cached).
pub fn structure_starts(
&mut self,
@@ -2887,8 +2894,8 @@ mod tests {
return;
};
let generator = OverworldGenerator::new(data, 1234).expect("generator");
generator.worker().structure_starts(ChunkPos::new(0, 0));
let rings = generator
.worker()
.ring_positions("minecraft:strongholds")
.expect("ring positions");
assert_eq!(rings.len(), 128);
@@ -2902,6 +2909,40 @@ mod tests {
}
}
/// Chunks no ring search can end near are decided without the rings,
/// which stay unsearched, and get the starts they get with them.
#[test]
fn chunks_far_from_the_rings_do_not_search_them() {
let Some(data) = prepared_data() else {
return;
};
let generator = OverworldGenerator::new(data.clone(), 4321).expect("generator");
let mut worker = generator.worker();
let summary = |worker: &mut GeneratorWorker, c: ChunkPos| -> Vec<(String, i32, i32)> {
worker
.structure_starts(c)
.iter()
.map(|s| (s.name.clone(), s.chunk.x, s.chunk.z))
.collect()
};
let chunks: Vec<ChunkPos> = (-24..=24)
.step_by(3)
.flat_map(|x| (-24..=24).step_by(3).map(move |z| ChunkPos::new(x, z)))
.collect();
let before: Vec<_> = chunks.iter().map(|&c| summary(&mut worker, c)).collect();
assert!(before.iter().any(|s| !s.is_empty()), "no starts to compare");
let searched = || data.ring_cache.lock().unwrap()[0].1.get().is_some();
assert!(!searched());
let rings = worker
.ring_positions("minecraft:strongholds")
.expect("ring positions");
assert_eq!(rings.len(), 128);
assert!(searched());
worker.forget_structure_starts();
let after: Vec<_> = chunks.iter().map(|&c| summary(&mut worker, c)).collect();
assert_eq!(before, after);
}
/// Generators of one seed and dimension share their ring positions;
/// another seed or generator gets its own, and old entries go.
#[test]
@@ -37,6 +37,8 @@ pub(super) struct StructureState {
rings: Arc<OnceLock<Rings>>,
/// Their biome searches while they are computed.
ring_work: OnceLock<RingWork>,
/// `StructureRegistry::zone_reach`.
zone_reach: i32,
}
/// generateRingPositions' biome searches, shared out. Vanilla runs each as
@@ -209,7 +211,9 @@ impl StructureState {
{
bindings = bindings.with_block_properties(&blocks.properties)?;
}
let zone_reach = registry.zone_reach();
Ok(Some(Self {
zone_reach,
registry,
resources: resources.clone(),
bindings,
@@ -221,10 +225,22 @@ impl StructureState {
ring_work: OnceLock::new(),
}))
}
/// Concentric ring positions of a structure set, once the first start
/// lookup has computed them.
pub(super) fn cached_rings(&self, set: &str) -> Option<Vec<ChunkPos>> {
self.rings.get().and_then(|rings| rings.get(set).cloned())
/// Concentric ring positions of a structure set (vanilla's
/// getRingPositionsFor), computed now if no lookup needed them yet.
pub(super) fn ring_positions(
&self,
context: &mut impl StartContext,
set: &str,
) -> Option<Vec<ChunkPos>> {
self.rings(context).get(set).cloned()
}
fn ring_work(&self, context: &impl StartContext) -> &RingWork {
self.ring_work.get_or_init(|| {
RingWork::new(
self.registry
.ring_searches(&self.possible_sets, context.seed()),
)
})
}
/// The concentric ring positions, computing them with the threads that
/// need them first (see `RingWork`).
@@ -232,12 +248,7 @@ impl StructureState {
if let Some(rings) = self.rings.get() {
return rings;
}
let work = self.ring_work.get_or_init(|| {
RingWork::new(
self.registry
.ring_searches(&self.possible_sets, context.seed()),
)
});
let work = self.ring_work(context);
let registry = &self.registry;
work.help(|set| registry.ring_biomes(set), &mut |quarts| {
context.noise_biomes(quarts)
@@ -245,6 +256,24 @@ impl StructureState {
self.rings
.get_or_init(|| work.rings(|set| registry.sets[set].name.clone()))
}
/// The rings a chunk's starts are decided with. Before they are known,
/// a chunk no ring search can end near (with the exclusion zones' reach)
/// is decided without them: no ring chunk is near it, which is what the
/// rings would say. Strongholds lie 1,400 blocks out or more, so a new
/// world's first chunks don't wait for the 128 biome searches (seconds
/// on four threads); they run when a chunk near a ring needs them.
fn rings_for(&self, context: &mut impl StartContext, chunk: ChunkPos) -> &Rings {
static NONE: Rings = Rings::new();
if let Some(rings) = self.rings.get() {
return rings;
}
let near = self
.ring_work(context)
.searches
.iter()
.any(|(_, search)| search.may_land_near(chunk.x, chunk.z, self.zone_reach));
if near { self.rings(context) } else { &NONE }
}
/// Drop the cached starts, so that later chunks build fresh pieces (the
/// pieces keep per-start placement state such as a shipwreck's height).
pub(super) fn forget_starts(&self) {
@@ -263,7 +292,7 @@ impl StructureState {
}
// Ring searches enlist other workers and wait for them: never hold a
// chunk-work lock while helping, even when this chunk has no starts.
let rings = self.rings(context);
let rings = self.rings_for(context, chunk);
let work = self.start_work.at((chunk.x, chunk.z));
let _work = work.lock().unwrap();
if let Some(found) = self.starts.get((chunk.x, chunk.z)) {
@@ -470,6 +499,40 @@ mod tests {
assert!(cache.get((3, -4)).is_none());
}
/// A ring search ends where `may_land_near` allows: on its ring chunk
/// or in the square it samples, never further.
#[test]
fn ring_searches_end_where_they_may() {
let none = BTreeSet::new();
for seed in [0, 1234, -77, i64::MAX] {
for (b, search) in ring_searches(seed, 32, 3, 128).iter().enumerate() {
// Preferred biomes on one quart at a time, in turn at each
// corner of the square, else nowhere (the ring chunk).
let corner = (b % 5) as i32;
let biomes = |quarts: &[[i32; 3]]| -> Vec<BiomeId> {
let (first, last) = (quarts[0], quarts[quarts.len() - 1]);
let pick = match corner {
0 => first,
1 => [last[0], 0, first[2]],
2 => [first[0], 0, last[2]],
3 => last,
_ => [i32::MIN, 0, i32::MIN],
};
quarts
.iter()
.map(|q| BiomeId(u32::from(*q == pick)))
.collect()
};
let preferred: BTreeSet<BiomeId> = [BiomeId(1)].into();
for wanted in [&preferred, &none] {
let found = search.find(wanted, &mut { biomes });
assert!(search.may_land_near(found.x, found.z, 0));
assert!(!search.may_land_near(found.x + 17, found.z, 0));
}
}
}
}
/// Searches shared between threads give the positions of one thread
/// running them in order, set by set.
#[test]
@@ -511,6 +511,18 @@ impl StructureRegistry {
})
.collect()
}
/// How far from a chunk, in chunks, deciding its starts can look at
/// other sets' start chunks through exclusion zones: every set's zones
/// summed, a bound on any chain of them.
pub fn zone_reach(&self) -> i32 {
self.sets
.iter()
.map(|s| {
s.exclusion.as_ref().map_or(0, |e| e.1.max(0))
+ s.avoid.as_ref().map_or(0, |a| a.chunk_count.max(0))
})
.sum()
}
/// The preferred biomes of a concentric-ring set (empty for others).
pub fn ring_biomes(&self, set: usize) -> &BTreeSet<BiomeId> {
static NONE: BTreeSet<BiomeId> = BTreeSet::new();

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