Merge origin/main into feat/win-screen
- game.rs: main (#1271) dropped the Horizon-theme checks from menu_blur and the title scroll; kept without them, with this branch's WinScreen parts (the credits alone blur, the title doesn't scroll under the Win screen). Screen keeps main's Friends and this branch's Win. - control.rs: horizon-ctl options pages keep credits, horizon and shader-packs. - options_ui.rs: Page keeps Credits and main's Horizon. The Options grid is main's (Horizon Settings and Mods in vanilla's Telemetry and Credits slots; Horizon Extras now sits inside Horizon Settings) with Credits & Attribution after them, laid out by this branch's row count. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@@ -18,6 +18,10 @@ concurrency:
|
||||
# A new push to a pull request replaces its running checks; main's runs all finish (releases follow them).
|
||||
group: checks-${{ github.event.pull_request.number || github.sha }}
|
||||
cancel-in-progress: ${{ github.event_name == 'pull_request' }}
|
||||
env:
|
||||
# Test runs never reach the telemetry server: no live-count ping, no uploads (docs/telemetry.md).
|
||||
HORIZON_TELEMETRY_URL: "off"
|
||||
|
||||
jobs:
|
||||
verify:
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
@@ -49,6 +49,10 @@ concurrency:
|
||||
group: launcher-${{ github.ref == 'refs/heads/main' && 'release' || github.ref }}
|
||||
cancel-in-progress: false
|
||||
|
||||
env:
|
||||
# Test runs never reach the telemetry server: no live-count ping, no uploads (docs/telemetry.md).
|
||||
HORIZON_TELEMETRY_URL: "off"
|
||||
|
||||
jobs:
|
||||
decide:
|
||||
runs-on: ubuntu-latest
|
||||
@@ -188,9 +192,6 @@ jobs:
|
||||
retry "$launcher" install latest
|
||||
"$launcher" versions --installed
|
||||
"$launcher" links --json
|
||||
"$launcher" menu-style classic
|
||||
grep -qx 'menuStyle:classic' "$HORIZON_HOME/horizon.txt"
|
||||
"$launcher" menu-style horizon
|
||||
clients=("$HORIZON_LAUNCHER_HOME"/versions/v*/horizon-client*)
|
||||
client="${clients[0]}"
|
||||
echo "installed client: $client"
|
||||
|
||||
@@ -23,6 +23,10 @@ permissions:
|
||||
concurrency:
|
||||
group: nightly-audit
|
||||
cancel-in-progress: false
|
||||
env:
|
||||
# Test runs never reach the telemetry server: no live-count ping, no uploads (docs/telemetry.md).
|
||||
HORIZON_TELEMETRY_URL: "off"
|
||||
|
||||
jobs:
|
||||
audit:
|
||||
runs-on: [self-hosted, horizon-game]
|
||||
|
||||
@@ -15,6 +15,10 @@ on:
|
||||
required: true
|
||||
permissions:
|
||||
contents: read
|
||||
env:
|
||||
# Test runs never reach the telemetry server: no live-count ping, no uploads (docs/telemetry.md).
|
||||
HORIZON_TELEMETRY_URL: "off"
|
||||
|
||||
jobs:
|
||||
parity:
|
||||
runs-on: [self-hosted, horizon-game]
|
||||
|
||||
@@ -11,6 +11,10 @@ permissions:
|
||||
concurrency:
|
||||
group: run-parity-${{ github.event.pull_request.number }}
|
||||
cancel-in-progress: true
|
||||
env:
|
||||
# Test runs never reach the telemetry server: no live-count ping, no uploads (docs/telemetry.md).
|
||||
HORIZON_TELEMETRY_URL: "off"
|
||||
|
||||
jobs:
|
||||
parity:
|
||||
if: github.event.label.name == 'run-parity'
|
||||
|
||||
@@ -46,7 +46,7 @@ The [documentation](https://playhorizon.dev/docs/) covers each of these.
|
||||
- **The game:** singleplayer with vanilla's world generation, mobs, villagers, raids, redstone, every command, the HUD and the recipe book, on saves in vanilla's format. Worlds from 1.8 to 26.2 are upgraded as vanilla does. [Status table](#project-status).
|
||||
- **Horizon's own extras:** new menus (vanilla's are one setting away), graphics presets, distant terrain up to 1024 chunks, controller support, optional zoom, minimap and more, all off by default where they would change the vanilla look. See [Settings](https://playhorizon.dev/docs/settings).
|
||||
- **Resource packs, shader packs and data packs:** resource packs work, Java shader packs run their full-screen effects (experimental), and data packs load functions, predicates and item modifiers.
|
||||
- **Playing with others:** invite friends from the pause menu with a code, Open to LAN, and joining offline-mode servers. Horizon cannot sign in to a Microsoft account yet, so it cannot join servers that check accounts. See [Multiplayer](https://playhorizon.dev/docs/multiplayer).
|
||||
- **Playing with others:** invite friends from the pause menu's Friends button with a code, Open to LAN, and joining offline-mode servers. Horizon cannot sign in to a Microsoft account yet, so it cannot join servers that check accounts. See [Multiplayer](https://playhorizon.dev/docs/multiplayer).
|
||||
- **Mods:** Horizon has its own mod system (Rust compiled to WebAssembly). Java mod jars do not run. See [Mods and data packs](https://playhorizon.dev/docs/mods).
|
||||
|
||||
Screenshots, captured in the Rust client itself with vanilla assets and no mods or shaders:
|
||||
@@ -56,8 +56,8 @@ Screenshots, captured in the Rust client itself with vanilla assets and no mods
|
||||
<td colspan="2"><img src="docs/media/sunset.webp" alt="Sunset over a savanna river valley and a plains village"></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="50%"><img src="docs/media/menu-title.webp" alt="Horizon's title screen over a veiled snowy landscape"></td>
|
||||
<td width="50%"><img src="docs/media/settings.webp" alt="The Video settings in their Simple view: a preset, render distance, field of view, framerate, VSync and GUI scale, each with what it costs"></td>
|
||||
<td width="50%"><img src="docs/media/survival.webp" alt="Survival at dusk: a zombie walks up, with the hotbar, health, hunger and experience"></td>
|
||||
<td width="50%"><img src="docs/media/settings.webp" alt="Vanilla's Video Settings screen with Horizon's own buttons at the top: Horizon Graphics, Advanced Graphics and Shader Packs"></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="50%"><img src="docs/media/village.webp" alt="A plains village among savanna hills, with farms, villagers and an iron golem"></td>
|
||||
|
||||
@@ -36,3 +36,15 @@ SOFTWARE.
|
||||
developers, with one upstream fix applied
|
||||
([gfx-rs/wgpu#10124](https://github.com/gfx-rs/wgpu/pull/10124)). It is licensed under MIT or
|
||||
Apache-2.0; both licenses are in that folder (`LICENSE.MIT`, `LICENSE.APACHE`).
|
||||
|
||||
## Pixelify Sans
|
||||
|
||||
`crates/horizon-theme/fonts/PixelifySans-*.ttf` is [Pixelify Sans](https://github.com/eifetx/Pixelify-Sans)
|
||||
by The Pixelify Sans Project Authors, licensed under the SIL Open Font License 1.1
|
||||
(`crates/horizon-theme/fonts/OFL-PixelifySans.txt`).
|
||||
|
||||
## Pixelarticons
|
||||
|
||||
`crates/horizon-theme/icons/pixel/*.svg` are icons from
|
||||
[Pixelarticons](https://github.com/halfmage/pixelarticons) by Gerrit Halfmann, under the MIT
|
||||
license (`crates/horizon-theme/icons/pixel/LICENSE-pixelarticons.txt`).
|
||||
|
||||
@@ -11,6 +11,7 @@ fn bits(value: f32) -> String {
|
||||
fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
let args: Vec<_> = std::env::args().collect();
|
||||
let mut output = String::new();
|
||||
let mut parameters = weather::ParameterCache::default();
|
||||
for (case, line) in fs::read_to_string(&args[1])?.lines().enumerate() {
|
||||
let p: Vec<&str> = line.split_whitespace().collect();
|
||||
let int = |i: usize| p[i].parse::<i32>().unwrap();
|
||||
@@ -38,6 +39,13 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
bits(column.v_offset),
|
||||
column.light_coords
|
||||
)?;
|
||||
assert_eq!(
|
||||
parameters
|
||||
.get(x, z)
|
||||
.column(kind != 0, ticks, x, bottom, top, z, light, partial),
|
||||
column,
|
||||
"cached parameters differ from original random source at case {case}"
|
||||
);
|
||||
let max_alpha = if kind == 0 { 1.0 } else { 0.8 };
|
||||
for v in weather::column_quad(&column, camera, max_alpha, radius, intensity) {
|
||||
write!(
|
||||
|
||||
@@ -43,6 +43,7 @@ struct Out {
|
||||
@location(8) back_color: vec4<f32>,
|
||||
// entity.vsh's lightMapColor, multiplied in after the overlay.
|
||||
@location(9) light_color: vec4<f32>,
|
||||
@location(10) @interpolate(flat) weather_rect: vec4<f32>,
|
||||
}
|
||||
// Shipped light.glsl; normals are already transformed and RGBA8_SNORM packed.
|
||||
fn entity_light(normal: vec3<f32>, nether: bool) -> f32 {
|
||||
@@ -216,3 +217,135 @@ fn linear_fog(d: f32, start: f32, end: f32) -> f32 {
|
||||
@fragment fn fs_water_mask() -> @location(0) vec4<f32> {
|
||||
return vec4(0.0);
|
||||
}
|
||||
|
||||
// WEATHER_MATH_BEGIN
|
||||
// Unsigned 64-bit helpers (low word first). Snow adds a random double to a
|
||||
// float drift before casting to float. Retaining the 53-bit base avoids early
|
||||
// rounding, including ties, without requiring optional GPU float64 support.
|
||||
fn weather_shr_jam(v: vec2<u32>, n: u32) -> vec2<u32> {
|
||||
if n == 0u { return v; }
|
||||
if n < 32u {
|
||||
return vec2((v.x >> n) | (v.y << (32u - n)) | select(0u, 1u, (v.x << (32u - n)) != 0u), v.y >> n);
|
||||
}
|
||||
if n == 32u { return vec2(v.y | select(0u, 1u, v.x != 0u), 0u); }
|
||||
if n < 64u {
|
||||
return vec2((v.y >> (n - 32u)) | select(0u, 1u, v.x != 0u || (v.y << (64u - n)) != 0u), 0u);
|
||||
}
|
||||
return vec2(select(0u, 1u, any(v != vec2(0u))), 0u);
|
||||
}
|
||||
fn weather_add64(a: vec2<u32>, b: vec2<u32>) -> vec2<u32> {
|
||||
let lo = a.x + b.x;
|
||||
return vec2(lo, a.y + b.y + select(0u, 1u, lo < a.x));
|
||||
}
|
||||
fn weather_sub64(a: vec2<u32>, b: vec2<u32>) -> vec2<u32> {
|
||||
return vec2(a.x - b.x, a.y - b.y - select(0u, 1u, a.x < b.x));
|
||||
}
|
||||
fn weather_double_plus_float(base: vec2<u32>, delta: f32) -> f32 {
|
||||
// The random base is nonnegative and either zero or >= 2^-53.
|
||||
if all(base == vec2(0u)) { return select(delta, 0.0, delta == 0.0); }
|
||||
let db = bitcast<u32>(delta);
|
||||
let mag = db & 0x7fffffffu;
|
||||
let be = i32((base.y >> 20u) & 2047u) - 1023;
|
||||
var de = i32(mag >> 23u) - 127;
|
||||
var dm = (mag & 0x7fffffu) | 0x800000u;
|
||||
if mag < 0x800000u {
|
||||
dm = mag;
|
||||
if dm == 0u { de = -200; }
|
||||
else {
|
||||
let shift = countLeadingZeros(dm) - 8u;
|
||||
dm <<= shift;
|
||||
de = -126 - i32(shift);
|
||||
}
|
||||
}
|
||||
let e = max(be, de);
|
||||
// Leading significand bit at 61, with room for addition and guard bits.
|
||||
var a = vec2(base.x << 9u, ((base.y & 0xfffffu) | 0x100000u) << 9u | (base.x >> 23u));
|
||||
var b = vec2(0u, dm << 6u);
|
||||
a = weather_shr_jam(a, u32(e - be));
|
||||
b = weather_shr_jam(b, u32(e - de));
|
||||
var sign = 0u;
|
||||
var value: vec2<u32>;
|
||||
if (db >> 31u) == 0u { value = weather_add64(a, b); }
|
||||
else if a.y > b.y || (a.y == b.y && a.x >= b.x) { value = weather_sub64(a, b); }
|
||||
else { value = weather_sub64(b, a); sign = 0x80000000u; }
|
||||
if all(value == vec2(0u)) { return 0.0; }
|
||||
let leading = select(31u - countLeadingZeros(value.x), 63u - countLeadingZeros(value.y), value.y != 0u);
|
||||
var exponent = e + i32(leading) - 61;
|
||||
// Normalize the leading bit to 62. After jamming, bit 38 is the guard
|
||||
// bit and bits 0..37 distinguish a tie from a value above the midpoint.
|
||||
let shift = 62u - leading;
|
||||
if shift >= 32u { value = vec2(0u, value.x << (shift - 32u)); }
|
||||
else if shift != 0u { value = vec2(value.x << shift, (value.y << shift) | (value.x >> (32u - shift))); }
|
||||
// Vanilla first rounds the addition to double, then casts to float.
|
||||
// Round at bit 10 (53 retained bits) before the 24-bit rounding below;
|
||||
// otherwise a double-rounding midpoint can select the wrong float.
|
||||
let double_guard = (value.x & 512u) != 0u;
|
||||
let double_sticky = (value.x & 511u) != 0u;
|
||||
let double_odd = (value.x & 1024u) != 0u;
|
||||
value.x &= 0xfffffc00u;
|
||||
if double_guard && (double_sticky || double_odd) {
|
||||
value = weather_add64(value, vec2(1024u, 0u));
|
||||
}
|
||||
if (value.y & 0x80000000u) != 0u {
|
||||
value = weather_shr_jam(value, 1u);
|
||||
exponent += 1;
|
||||
}
|
||||
var mantissa = value.y >> 7u;
|
||||
let guard = (value.y & 64u) != 0u;
|
||||
let sticky = (value.y & 63u) != 0u || value.x != 0u;
|
||||
if guard && (sticky || (mantissa & 1u) != 0u) { mantissa += 1u; }
|
||||
if mantissa >= 0x1000000u { mantissa >>= 1u; exponent += 1; }
|
||||
return bitcast<f32>(sign | (u32(exponent + 127) << 23u) | (mantissa & 0x7fffffu));
|
||||
}
|
||||
fn weather_phase(animation: vec4<f32>, bases: vec4<u32>, snow: u32, time: vec4<f32>) -> vec2<f32> {
|
||||
if snow == 0u {
|
||||
let ticks = time.x + animation.y;
|
||||
let t = ticks + time.z;
|
||||
let step = -t / 32.0;
|
||||
let offset = step * animation.x;
|
||||
return vec2(0.0, offset % 32.0);
|
||||
}
|
||||
let t = time.x + time.z;
|
||||
let u_time = t * 0.01;
|
||||
let du = u_time * animation.z;
|
||||
let v_time = t * animation.w;
|
||||
let dv = v_time * 0.001;
|
||||
let u = weather_double_plus_float(bases.xy, du);
|
||||
let v = weather_double_plus_float(bases.zw, dv);
|
||||
let fall_time = time.y + time.z;
|
||||
let fall = -fall_time / 512.0;
|
||||
return vec2(u, fall + v);
|
||||
}
|
||||
// Atlas sampler is nearest with no mipmaps. Clamp the integer texel inside
|
||||
// the sprite even when a fractional coordinate rounds up at its far edge.
|
||||
fn weather_texel(uv: vec2<f32>, rect: vec4<f32>, dimensions: vec2<u32>) -> vec2<i32> {
|
||||
let size = vec2<f32>(dimensions);
|
||||
let origin = vec2<i32>(round(rect.xy * size));
|
||||
let extent = max(vec2<i32>(round(rect.zw * size)), vec2(1));
|
||||
let local = min(vec2<i32>(floor(fract(uv) * vec2<f32>(extent))), extent - vec2(1));
|
||||
return origin + local;
|
||||
}
|
||||
// WEATHER_MATH_END
|
||||
|
||||
struct WeatherTime { values: vec4<f32> }
|
||||
@group(1) @binding(1) var<uniform> weather_time: WeatherTime;
|
||||
@vertex fn vs_weather(@location(0) position: vec3<f32>, @location(1) uv: vec2<f32>,
|
||||
@location(2) rect: vec4<f32>, @location(3) animation: vec4<f32>,
|
||||
@location(4) bases: vec4<u32>, @location(5) color: vec4<f32>,
|
||||
@location(6) light: vec4<u32>, @location(7) snow: u32) -> Out {
|
||||
let phase = weather_phase(animation, bases, snow, weather_time.values);
|
||||
var out = entity_vertex(position, uv + phase, 0u, color, light, vec4(0.0));
|
||||
out.weather_rect = rect;
|
||||
return out;
|
||||
}
|
||||
@fragment fn fs_weather(in: Out) -> @location(0) vec4<f32> {
|
||||
// Repeat within this sprite, never across the atlas. The atlas uses nearest
|
||||
// filtering and no mipmaps, so fractional UVs have no seam derivatives.
|
||||
let texel = weather_texel(in.uv, in.weather_rect, textureDimensions(atlas));
|
||||
var color = textureLoad(atlas, texel, 0) * in.color;
|
||||
if color.a < 0.1 { discard; }
|
||||
color *= in.light_color;
|
||||
let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
|
||||
linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
|
||||
return vec4(mix(color.rgb, globals.fog_color.rgb, f * globals.fog_color.a), color.a);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,303 @@
|
||||
//! Play with Friends: Horizon's own sharing of the open world behind an
|
||||
//! invite code (`game/friends.rs`). The pause menu's Friends button, the icon
|
||||
//! vanilla's PauseScreen already has, opens it. It is drawn the way a mod adds
|
||||
//! a screen to vanilla: the menu background, a centred title and text,
|
||||
//! vanilla's buttons and Done in the footer.
|
||||
use crate::{
|
||||
hud::{HudAtlas, HudBatch, rgba},
|
||||
multiplayer::wrap,
|
||||
text::Text,
|
||||
ui,
|
||||
};
|
||||
|
||||
pub const TITLE: &str = "Play with Friends";
|
||||
/// What the screen shows (game/friends.rs fills it).
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct FriendsView {
|
||||
/// A singleplayer world (not a server): sharing is offered.
|
||||
pub shown: bool,
|
||||
pub sharing: bool,
|
||||
pub code: Option<String>,
|
||||
/// Who can join and what to do when friends on the internet can't (or,
|
||||
/// before the code, what the game is doing).
|
||||
pub status: String,
|
||||
/// Friends on the internet can reach the host.
|
||||
pub reachable: bool,
|
||||
/// Where the troubleshooting is, when they can't.
|
||||
pub help: Option<String>,
|
||||
/// The players in the world besides the host.
|
||||
pub guests: Vec<String>,
|
||||
pub notice: Option<String>,
|
||||
/// The code was just copied.
|
||||
pub copied: bool,
|
||||
}
|
||||
|
||||
/// A button's action.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Action {
|
||||
Share,
|
||||
Copy,
|
||||
Stop,
|
||||
/// Open the troubleshooting page.
|
||||
Help,
|
||||
Done,
|
||||
}
|
||||
|
||||
fn grey() -> u32 {
|
||||
rgba(160, 160, 160, 255)
|
||||
}
|
||||
const WHITE: u32 = u32::MAX;
|
||||
const HINT: &str = "Friends paste the code after the title screen's Friends button, in Direct Connection, or on the launcher's Play page.";
|
||||
|
||||
struct Button {
|
||||
x: f32,
|
||||
y: f32,
|
||||
w: f32,
|
||||
label: &'static str,
|
||||
action: Action,
|
||||
active: bool,
|
||||
}
|
||||
|
||||
/// The centred lines (text, colour, y) and the buttons.
|
||||
fn layout(
|
||||
atlas: &HudAtlas,
|
||||
(w, h): (f32, f32),
|
||||
view: &FriendsView,
|
||||
) -> (Vec<(String, u32, f32)>, Vec<Button>) {
|
||||
let width = (w - 40.0).min(310.0);
|
||||
let cx = (w / 2.0).floor();
|
||||
let mut lines = Vec::new();
|
||||
let mut y = 40.0;
|
||||
let add = |lines: &mut Vec<(String, u32, f32)>, text: &str, color: u32, y: &mut f32| {
|
||||
for line in wrap(text, width, atlas) {
|
||||
lines.push((line, color, *y));
|
||||
*y += 10.0;
|
||||
}
|
||||
};
|
||||
let mut buttons = Vec::new();
|
||||
if view.sharing {
|
||||
lines.push(("Invite Code".to_owned(), grey(), y));
|
||||
y += 12.0;
|
||||
match &view.code {
|
||||
Some(code) => {
|
||||
for line in code_lines(atlas, code, width) {
|
||||
lines.push((line, WHITE, y));
|
||||
y += 10.0;
|
||||
}
|
||||
}
|
||||
None => add(&mut lines, &view.status, WHITE, &mut y),
|
||||
}
|
||||
y += 6.0;
|
||||
buttons.push(Button {
|
||||
x: cx - 154.0,
|
||||
y,
|
||||
w: 150.0,
|
||||
label: if view.copied { "Copied" } else { "Copy Code" },
|
||||
action: Action::Copy,
|
||||
active: view.code.is_some(),
|
||||
});
|
||||
buttons.push(Button {
|
||||
x: cx + 4.0,
|
||||
y,
|
||||
w: 150.0,
|
||||
label: "Stop Sharing",
|
||||
action: Action::Stop,
|
||||
active: true,
|
||||
});
|
||||
y += 30.0;
|
||||
if view.code.is_some() {
|
||||
// Who can join: grey when friends anywhere can, white (it asks
|
||||
// for something) when only the LAN and VPNs can.
|
||||
let tint = if view.reachable { grey() } else { WHITE };
|
||||
add(&mut lines, &view.status, tint, &mut y);
|
||||
y += 4.0;
|
||||
}
|
||||
let here = if view.guests.is_empty() {
|
||||
"No friends here yet.".to_owned()
|
||||
} else {
|
||||
format!("Here now: {}", view.guests.join(", "))
|
||||
};
|
||||
add(&mut lines, &here, grey(), &mut y);
|
||||
if let Some(notice) = &view.notice {
|
||||
add(&mut lines, notice, WHITE, &mut y);
|
||||
}
|
||||
// Where friends paste the code, while it fits above the footer.
|
||||
if y + 10.0 * wrap(HINT, width, atlas).len() as f32 <= h - 33.0 {
|
||||
add(&mut lines, HINT, grey(), &mut y);
|
||||
}
|
||||
} else {
|
||||
add(
|
||||
&mut lines,
|
||||
"Share this world behind an invite code: it opens to LAN, and friends on the internet join with the code. No server of ours is involved.",
|
||||
WHITE,
|
||||
&mut y,
|
||||
);
|
||||
y += 4.0;
|
||||
add(&mut lines, HINT, grey(), &mut y);
|
||||
buttons.push(Button {
|
||||
x: cx - 100.0,
|
||||
y: y + 8.0,
|
||||
w: 200.0,
|
||||
label: "Start Sharing",
|
||||
action: Action::Share,
|
||||
active: view.shown,
|
||||
});
|
||||
}
|
||||
// HeaderAndFooterLayout's footer: Done, beside Troubleshooting when
|
||||
// friends on the internet can't reach the host.
|
||||
if view.sharing && view.help.is_some() {
|
||||
buttons.push(Button {
|
||||
x: cx - 154.0,
|
||||
y: h - 27.0,
|
||||
w: 150.0,
|
||||
label: "Troubleshooting...",
|
||||
action: Action::Help,
|
||||
active: true,
|
||||
});
|
||||
buttons.push(Button {
|
||||
x: cx + 4.0,
|
||||
y: h - 27.0,
|
||||
w: 150.0,
|
||||
label: "gui.done",
|
||||
action: Action::Done,
|
||||
active: true,
|
||||
});
|
||||
} else {
|
||||
buttons.push(Button {
|
||||
x: cx - 100.0,
|
||||
y: h - 27.0,
|
||||
w: 200.0,
|
||||
label: "gui.done",
|
||||
action: Action::Done,
|
||||
active: true,
|
||||
});
|
||||
}
|
||||
(lines, buttons)
|
||||
}
|
||||
/// The code's groups packed into lines of at most `width`.
|
||||
fn code_lines(atlas: &HudAtlas, code: &str, width: f32) -> Vec<String> {
|
||||
let mut lines: Vec<String> = Vec::new();
|
||||
for group in code.split('-') {
|
||||
match lines.last_mut() {
|
||||
Some(l) if HudBatch::text_width(atlas, &format!("{l}-{group}")) <= width => {
|
||||
l.push('-');
|
||||
l.push_str(group);
|
||||
}
|
||||
_ => lines.push(group.to_owned()),
|
||||
}
|
||||
}
|
||||
lines
|
||||
}
|
||||
fn label(key: &str) -> Text {
|
||||
if key.starts_with("gui.") {
|
||||
Text::translate(key, &[])
|
||||
} else {
|
||||
Text::literal(key)
|
||||
}
|
||||
}
|
||||
pub fn draw(
|
||||
batch: &mut HudBatch,
|
||||
atlas: &HudAtlas,
|
||||
cursor: (f32, f32),
|
||||
view: &FriendsView,
|
||||
in_world: bool,
|
||||
) {
|
||||
let (w, h) = (batch.width, batch.height);
|
||||
ui::menu_background(batch, atlas, 0.0, 0.0, w, h, in_world);
|
||||
let title = Text::literal(TITLE);
|
||||
let tw = atlas.font.width_text(&title);
|
||||
batch.text_styled(atlas, &title, ((w - tw) / 2.0).floor(), 15.0, WHITE, true);
|
||||
let (lines, buttons) = layout(atlas, (w, h), view);
|
||||
for (line, color, y) in lines {
|
||||
let lw = HudBatch::text_width(atlas, &line);
|
||||
batch.text(atlas, &line, ((w - lw) / 2.0).floor(), y, color, true);
|
||||
}
|
||||
for b in buttons {
|
||||
let hover = b.active && ui::hovered(cursor, b.x, b.y, b.w, 20.0);
|
||||
ui::button(
|
||||
batch,
|
||||
atlas,
|
||||
b.x,
|
||||
b.y,
|
||||
b.w,
|
||||
20.0,
|
||||
&label(b.label),
|
||||
b.active,
|
||||
hover,
|
||||
);
|
||||
}
|
||||
}
|
||||
/// The button under a click, if it is active.
|
||||
pub fn click(
|
||||
atlas: &HudAtlas,
|
||||
size: (f32, f32),
|
||||
cursor: (f32, f32),
|
||||
view: &FriendsView,
|
||||
) -> Option<Action> {
|
||||
layout(atlas, size, view)
|
||||
.1
|
||||
.into_iter()
|
||||
.find(|b| b.active && ui::hovered(cursor, b.x, b.y, b.w, 20.0))
|
||||
.map(|b| b.action)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn atlas() -> HudAtlas {
|
||||
HudAtlas::build(std::path::Path::new("/nonexistent/horizon-test-assets")).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn share_then_copy_and_stop() {
|
||||
let atlas = atlas();
|
||||
let size = (427.0, 240.0);
|
||||
let idle = FriendsView {
|
||||
shown: true,
|
||||
..FriendsView::default()
|
||||
};
|
||||
let (_, buttons) = layout(&atlas, size, &idle);
|
||||
let share = buttons.iter().find(|b| b.action == Action::Share).unwrap();
|
||||
assert_eq!(
|
||||
click(&atlas, size, (share.x + 1.0, share.y + 1.0), &idle),
|
||||
Some(Action::Share)
|
||||
);
|
||||
let sharing = FriendsView {
|
||||
shown: true,
|
||||
sharing: true,
|
||||
status: "Finding how friends can reach you…".into(),
|
||||
..FriendsView::default()
|
||||
};
|
||||
let (_, buttons) = layout(&atlas, size, &sharing);
|
||||
let copy = buttons.iter().find(|b| b.action == Action::Copy).unwrap();
|
||||
assert!(!copy.active, "nothing to copy before the code");
|
||||
let with_code = FriendsView {
|
||||
code: Some("0B33K-Q405Q-1Z5CV-X6NHY-R12N0-VK8T1-60N00-RA134-952PE-1HA08-910P0-K5M01-ST1NB-JDTB6-K4W1P-0".into()),
|
||||
status: "Friends on your network or VPN can join. For friends on the internet: turn on UPnP on your router, or forward TCP port 25580 to 10.0.0.2, or use a relay, or a VPN such as Tailscale or ZeroTier (the code already holds your VPN address).".into(),
|
||||
help: Some("https://example.invalid/help".into()),
|
||||
..sharing
|
||||
};
|
||||
let (lines, buttons) = layout(&atlas, size, &with_code);
|
||||
assert!(
|
||||
lines.iter().all(|(_, _, y)| y + 9.0 <= size.1 - 27.0),
|
||||
"the text stays above the footer"
|
||||
);
|
||||
for action in [Action::Copy, Action::Stop, Action::Help, Action::Done] {
|
||||
let b = buttons.iter().find(|b| b.action == action).unwrap();
|
||||
assert_eq!(
|
||||
click(&atlas, size, (b.x + 1.0, b.y + 1.0), &with_code),
|
||||
Some(action)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_server_offers_no_sharing() {
|
||||
let atlas = atlas();
|
||||
let view = FriendsView::default();
|
||||
let (_, buttons) = layout(&atlas, (427.0, 240.0), &view);
|
||||
let share = buttons.iter().find(|b| b.action == Action::Share).unwrap();
|
||||
assert!(!share.active);
|
||||
}
|
||||
}
|
||||
@@ -5,7 +5,6 @@ mod advancements_screen;
|
||||
mod agent;
|
||||
mod allays;
|
||||
mod armor_stands;
|
||||
mod backdrop;
|
||||
mod banners;
|
||||
mod beacon;
|
||||
mod beehives;
|
||||
@@ -76,6 +75,7 @@ mod lan_pvp;
|
||||
mod lan_screen;
|
||||
mod lan_stations;
|
||||
mod lan_trading;
|
||||
mod lan_vehicles;
|
||||
mod lan_waypoints;
|
||||
mod leads;
|
||||
mod level_particles;
|
||||
@@ -121,6 +121,7 @@ mod remote;
|
||||
mod remote_objects;
|
||||
mod remote_projectiles;
|
||||
mod remote_stations;
|
||||
mod remote_vehicles;
|
||||
mod render_control;
|
||||
mod render_tick;
|
||||
mod respawn_anchor;
|
||||
@@ -456,6 +457,9 @@ enum Screen {
|
||||
Advancements,
|
||||
/// WorldOptionsScreen (game/lan_screen.rs).
|
||||
WorldOptions,
|
||||
/// Play with Friends, from the pause menu's Friends button
|
||||
/// (`friends_screen`, game/friends.rs).
|
||||
Friends,
|
||||
/// CommandBlockEditScreen (game/command_blocks.rs).
|
||||
CommandBlock,
|
||||
/// WinScreen: the end poem and the credits (game/win.rs).
|
||||
@@ -1115,6 +1119,7 @@ struct Game<'a> {
|
||||
/// `FogRenderer`'s evolving state.
|
||||
fog: horizon_client::fog::FogState,
|
||||
screen_fx: horizon_client::screen_effects::ScreenEffects,
|
||||
weather_parameters: horizon_client::weather::ParameterCache,
|
||||
panorama_rotation: horizon_client::gfx::panorama::Rotation,
|
||||
world: World,
|
||||
streaming: Streaming,
|
||||
@@ -1317,14 +1322,12 @@ struct Game<'a> {
|
||||
settings: Settings,
|
||||
/// Where the options screen returns: true = title, false = pause menu.
|
||||
options_from_title: bool,
|
||||
/// The live title backdrop (game/backdrop.rs).
|
||||
backdrop: backdrop::Backdrop,
|
||||
/// When the pause menu opened (Horizon style's entrance).
|
||||
pause_since: Option<Instant>,
|
||||
dragging: bool,
|
||||
/// `ClientAvatarState`: walked distance and view bob.
|
||||
avatar: horizon_client::camera::AvatarBob,
|
||||
flash: u32,
|
||||
/// Bolts that struck here and sky flashes they made, in total (`status`).
|
||||
lightning_seen: [u32; 2],
|
||||
/// The head of the bed while sleeping; the visual timer also survives waking.
|
||||
sleeping: Option<[i32; 3]>,
|
||||
sleep_timer: u32,
|
||||
@@ -4460,6 +4463,7 @@ impl Game<'_> {
|
||||
| Screen::Stats
|
||||
| Screen::Advancements
|
||||
| Screen::WorldOptions
|
||||
| Screen::Friends
|
||||
| Screen::CommandBlock
|
||||
) || self.book.is_some()
|
||||
|| self.win_screen_pauses())
|
||||
@@ -4692,20 +4696,12 @@ impl Game<'_> {
|
||||
}
|
||||
}
|
||||
if let Some(title) = &self.title {
|
||||
if horizon_client::ui_theme::horizon() {
|
||||
let fade = self.backdrop_fade();
|
||||
let mut ui =
|
||||
horizon_client::ui_theme::Ui::new(&self.gui.atlas, &mut batch, self.cursor);
|
||||
title.draw_horizon(&mut ui, fade);
|
||||
ui.finish();
|
||||
} else {
|
||||
title.draw(
|
||||
&self.gui.atlas,
|
||||
&mut batch,
|
||||
self.cursor,
|
||||
self.settings.file.bool("hideSplashTexts"),
|
||||
);
|
||||
}
|
||||
title.draw(
|
||||
&self.gui.atlas,
|
||||
&mut batch,
|
||||
self.cursor,
|
||||
self.settings.file.bool("hideSplashTexts"),
|
||||
);
|
||||
return batch;
|
||||
}
|
||||
let atlas_ptr: *const HudAtlas = &self.gui.atlas;
|
||||
@@ -4722,9 +4718,7 @@ impl Game<'_> {
|
||||
// the sleep overlay, debug screen and open screens still draw.
|
||||
let spectator = self.spectator();
|
||||
let (wi, hi) = (w as i32, h as i32);
|
||||
// Horizon's pause menu sits over the blurred world alone.
|
||||
let horizon_pause = self.horizon_pause();
|
||||
let show_hud = !self.ui.hide_gui && !horizon_pause;
|
||||
let show_hud = !self.ui.hide_gui;
|
||||
if show_hud {
|
||||
self.draw_spyglass(&mut batch);
|
||||
// Hud.extractCrosshair / extractItemHotbar / extractPlayerHealth /
|
||||
@@ -4858,10 +4852,8 @@ impl Game<'_> {
|
||||
let tw = HudBatch::text_width(atlas, text);
|
||||
batch.text(atlas, text, (w - tw) / 2.0, h - 59.0, u32::MAX, true);
|
||||
}
|
||||
if !horizon_pause {
|
||||
self.draw_chat(&mut batch);
|
||||
self.draw_tab_list(&mut batch);
|
||||
}
|
||||
self.draw_chat(&mut batch);
|
||||
self.draw_tab_list(&mut batch);
|
||||
// Screen.extractBlurredBackground blurs the world and HUD, while the
|
||||
// screen's background, widgets, toasts and debug overlay stay sharp.
|
||||
batch.blur_at = batch.vertices.len() as u32;
|
||||
@@ -4885,6 +4877,7 @@ impl Game<'_> {
|
||||
Screen::Stats => self.draw_stats(&mut batch),
|
||||
Screen::Advancements => self.draw_advancements(&mut batch),
|
||||
Screen::WorldOptions => self.draw_world_options(&mut batch),
|
||||
Screen::Friends => self.draw_friends_screen(&mut batch),
|
||||
Screen::CommandBlock => self.draw_command_block(&mut batch),
|
||||
Screen::Inventory => {
|
||||
self.draw_inventory(&mut batch);
|
||||
@@ -8969,89 +8962,84 @@ impl Game<'_> {
|
||||
}
|
||||
}
|
||||
/// WeatherEffectRenderer: rain and snow columns within the weather radius.
|
||||
fn weather_geometry(&self, camera: glam::DVec3, alpha: f64, out: &mut Vec<Vertex>) {
|
||||
fn weather_geometry(
|
||||
&mut self,
|
||||
camera: glam::DVec3,
|
||||
alpha: f64,
|
||||
) -> Vec<horizon_client::weather::Vertex> {
|
||||
use horizon_client::weather;
|
||||
let (intensity, _) = self.world.weather.levels(alpha as f32);
|
||||
if intensity <= 0.0 {
|
||||
return;
|
||||
return Vec::new();
|
||||
}
|
||||
let atlas = &self.gui.atlas;
|
||||
let (Some(rain_tex), Some(snow_tex)) = (
|
||||
atlas.sprites.get("environment/rain").copied(),
|
||||
atlas.sprites.get("environment/snow").copied(),
|
||||
) else {
|
||||
return;
|
||||
return Vec::new();
|
||||
};
|
||||
let (cx, cy, cz) = (
|
||||
camera.x.floor() as i32,
|
||||
camera.y.floor() as i32,
|
||||
camera.z.floor() as i32,
|
||||
);
|
||||
let radius = self.settings.weather_radius;
|
||||
let ticks = self.world.game_time;
|
||||
let partial = alpha as f32;
|
||||
let eye = [camera.x, camera.y, camera.z];
|
||||
// Vanilla draws every rain column before the snow ones.
|
||||
let mut columns = (Vec::new(), Vec::new());
|
||||
for z in cz - radius..=cz + radius {
|
||||
for x in cx - radius..=cx + radius {
|
||||
// The 32x32 direction table supports at most a 15-block radius.
|
||||
let radius = self.settings.weather_radius.clamp(0, 15);
|
||||
let eye = camera.to_array();
|
||||
let mut rain = Vec::new();
|
||||
let mut snow_vertices = Vec::new();
|
||||
// Saturation keeps extreme camera coordinates from overflowing the loop.
|
||||
for z in cz.saturating_sub(radius)..=cz.saturating_add(radius) {
|
||||
for x in cx.saturating_sub(radius)..=cx.saturating_add(radius) {
|
||||
let top = self.rain_height(x, z);
|
||||
let y0 = (cy - radius).max(top);
|
||||
let y1 = (cy + radius).max(top);
|
||||
let y0 = cy.saturating_sub(radius).max(top);
|
||||
let y1 = cy.saturating_add(radius).max(top);
|
||||
if y1 == y0 {
|
||||
continue;
|
||||
}
|
||||
let Some(snow) = self.precipitation(x, cy, z) else {
|
||||
continue;
|
||||
};
|
||||
let mut random = weather::column_random(x, z);
|
||||
let parameters = self.weather_parameters.get(x, z);
|
||||
let light = self.world.light(x, top.max(cy), z);
|
||||
let coords = i32::from(light & 15) << 4 | i32::from(light >> 4) << 20;
|
||||
if snow {
|
||||
columns.1.push(weather::snow_column(
|
||||
&mut random,
|
||||
ticks,
|
||||
x,
|
||||
y0,
|
||||
y1,
|
||||
z,
|
||||
coords,
|
||||
partial,
|
||||
));
|
||||
// Only light brightening is needed here; UV phases stay zero.
|
||||
let lc = if snow {
|
||||
let (block, sky) = (coords >> 4 & 15, coords >> 20 & 15);
|
||||
((block * 3 + 15) / 4) << 4 | ((sky * 3 + 15) / 4) << 20
|
||||
} else {
|
||||
columns.0.push(weather::rain_column(
|
||||
&mut random,
|
||||
ticks,
|
||||
x,
|
||||
y0,
|
||||
y1,
|
||||
z,
|
||||
coords,
|
||||
partial,
|
||||
));
|
||||
coords
|
||||
};
|
||||
let column = weather::Column {
|
||||
x,
|
||||
z,
|
||||
bottom_y: y0,
|
||||
top_y: y1,
|
||||
u_offset: 0.0,
|
||||
v_offset: 0.0,
|
||||
light_coords: lc,
|
||||
};
|
||||
let r = if snow { snow_tex } else { rain_tex };
|
||||
let vertices = weather::vertices(
|
||||
&column,
|
||||
parameters,
|
||||
snow,
|
||||
eye,
|
||||
radius,
|
||||
intensity,
|
||||
[r.u0, r.v0, r.u1 - r.u0, r.v1 - r.v0],
|
||||
);
|
||||
if snow {
|
||||
snow_vertices.extend(vertices);
|
||||
} else {
|
||||
rain.extend(vertices);
|
||||
}
|
||||
}
|
||||
}
|
||||
let rain = columns.0.iter().map(|c| (c, 1.0, rain_tex));
|
||||
let snow = columns.1.iter().map(|c| (c, 0.8, snow_tex));
|
||||
for (column, max_alpha, r) in rain.chain(snow) {
|
||||
let quad = weather::column_quad(column, eye, max_alpha, radius, intensity);
|
||||
let color = quad[0].color;
|
||||
let lc = quad[0].light_coords;
|
||||
let light = ((lc >> 20 & 15) * 16) as u32 | (((lc >> 4 & 15) * 16) as u32) << 8;
|
||||
weather::tile(&quad, |pos, uvs| {
|
||||
for (p, [u, v]) in pos.into_iter().zip(uvs) {
|
||||
out.push(Vertex {
|
||||
normal: [0; 4],
|
||||
pos: p,
|
||||
uv: [r.u0 + (r.u1 - r.u0) * u, r.v0 + (r.v1 - r.v0) * v],
|
||||
layer: 0,
|
||||
color,
|
||||
light,
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
// Vanilla draws every rain column before the snow ones.
|
||||
rain.extend(snow_vertices);
|
||||
rain
|
||||
}
|
||||
/// Player.startSleepInBed: night or thunder, no monsters within 8 blocks;
|
||||
/// the bed becomes the respawn point either way.
|
||||
@@ -9613,12 +9601,7 @@ impl Game<'_> {
|
||||
// Camera.getCameraEntityPartialTicks: the view, the hand and the
|
||||
// player's own model stay smooth while the level is frozen.
|
||||
let camera_alpha = self.clock.camera_fraction();
|
||||
let live = self.backdrop_live();
|
||||
let view = if live {
|
||||
self.backdrop_view()
|
||||
} else {
|
||||
self.camera_view(camera_alpha as f32)
|
||||
};
|
||||
let view = self.camera_view(camera_alpha as f32);
|
||||
let (camera, underwater, view_yaw, view_pitch) = match view {
|
||||
Some((c, yaw, pitch)) => {
|
||||
let s =
|
||||
@@ -9766,9 +9749,7 @@ impl Game<'_> {
|
||||
// LevelLoadingScreen (Reason.OTHER) draws the title's panorama.
|
||||
let title = self.title.is_some()
|
||||
|| self.loading_reason() == Some(horizon_client::level_loading::Reason::Other);
|
||||
let (yaw, pitch) = if live {
|
||||
(view_yaw, view_pitch)
|
||||
} else if title {
|
||||
let (yaw, pitch) = if title {
|
||||
// PanoramaRenderer: the title cube spins at 0.1 degrees per tick, pitched 10 degrees.
|
||||
(
|
||||
self.panorama_rotation.update(
|
||||
@@ -9780,9 +9761,7 @@ impl Game<'_> {
|
||||
} else {
|
||||
(view_yaw, view_pitch)
|
||||
};
|
||||
let fov_degrees = if live {
|
||||
72.0
|
||||
} else if title {
|
||||
let fov_degrees = if title {
|
||||
85.0
|
||||
} else {
|
||||
self.fov_degrees(camera_alpha as f32, camera.to_array())
|
||||
@@ -9833,7 +9812,7 @@ impl Game<'_> {
|
||||
}
|
||||
.to_owned()
|
||||
};
|
||||
let (celestial, stars) = if title && !live {
|
||||
let (celestial, stars) = if title {
|
||||
(Vec::new(), None)
|
||||
} else if self.dim == Dim::Overworld
|
||||
&& self.potions.effects.get("darkness").is_none()
|
||||
@@ -9859,11 +9838,11 @@ impl Game<'_> {
|
||||
if !title {
|
||||
self.end_geometry(camera, &mut entities);
|
||||
}
|
||||
if (!title || live) && self.dim == Dim::Overworld && self.settings.horizon.weather {
|
||||
horizon_client::spans::time("weather", || {
|
||||
self.weather_geometry(camera, alpha, &mut entities)
|
||||
});
|
||||
}
|
||||
let weather = if !title && self.dim == Dim::Overworld && self.settings.horizon.weather {
|
||||
horizon_client::spans::time("weather", || self.weather_geometry(camera, alpha))
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
let border = (!title)
|
||||
.then(|| self.border_draw(camera.to_array(), alpha as f32))
|
||||
.flatten();
|
||||
@@ -9874,6 +9853,8 @@ impl Game<'_> {
|
||||
self.gather_dynamic_lights(camera, alpha);
|
||||
}
|
||||
let frame = Frame {
|
||||
weather: &weather,
|
||||
weather_time: horizon_client::weather::Time::new(self.world.game_time, alpha as f32),
|
||||
shader: self.shader_inputs(camera, alpha as f32),
|
||||
nether_lighting: self.dim == Dim::Nether,
|
||||
camera,
|
||||
@@ -9886,7 +9867,7 @@ impl Game<'_> {
|
||||
detail_distance: (self.streaming.radius * 16) as f32,
|
||||
depth_far,
|
||||
underwater,
|
||||
title: title && !live,
|
||||
title,
|
||||
skybox: self.dim == Dim::Overworld && self.settings.horizon.sky,
|
||||
end_sky: self.dim == Dim::End && self.settings.horizon.sky,
|
||||
end_sky_sprite: self
|
||||
@@ -9920,7 +9901,7 @@ impl Game<'_> {
|
||||
debug_lines_on_top: &debug_lines_on_top,
|
||||
debug_crosshair: &debug_crosshair,
|
||||
hud: &hud,
|
||||
clouds: ((!title || live)
|
||||
clouds: (!title
|
||||
&& self.dim == Dim::Overworld
|
||||
&& horizon_client::clouds::visible(&clouds_mode, sky.cloud_color[3]))
|
||||
.then(|| self.gui.atlas.sprites.get("horizon/white"))
|
||||
@@ -9975,13 +9956,6 @@ impl Game<'_> {
|
||||
darkness: self.darkness_lighting(alpha as f32),
|
||||
night_vision: self.night_vision_intensity(),
|
||||
block_flicker: self.fog.block_light_flicker,
|
||||
post: if live {
|
||||
Some(horizon_client::post::PostGrade::FROST)
|
||||
} else if self.horizon_pause() {
|
||||
Some(horizon_client::post::PostGrade::PAUSE)
|
||||
} else {
|
||||
None
|
||||
},
|
||||
menu_blur: self.menu_blur(),
|
||||
};
|
||||
let result = match self.renderer.as_mut() {
|
||||
@@ -10053,16 +10027,15 @@ impl Game<'_> {
|
||||
/// HUD, when `menuBackgroundBlurriness` is at least 1.
|
||||
fn menu_blur(&self) -> Option<f32> {
|
||||
let loading = self.loading_reason() == Some(horizon_client::level_loading::Reason::Other);
|
||||
let blurred = !horizon_client::ui_theme::horizon()
|
||||
&& (loading
|
||||
|| self.title.as_ref().is_some_and(|t| {
|
||||
matches!(self.screen, Screen::Options | Screen::Win)
|
||||
|| !matches!(t.mode, horizon_client::title::Mode::Main)
|
||||
})
|
||||
|| (self.title.is_none()
|
||||
&& self.player.is_some()
|
||||
&& (self.screen.blurs_background(self.pause_menu)
|
||||
|| (self.screen == Screen::Win && self.win_screen_pauses()))));
|
||||
let blurred = loading
|
||||
|| self.title.as_ref().is_some_and(|t| {
|
||||
matches!(self.screen, Screen::Options | Screen::Win)
|
||||
|| !matches!(t.mode, horizon_client::title::Mode::Main)
|
||||
})
|
||||
|| (self.title.is_none()
|
||||
&& self.player.is_some()
|
||||
&& (self.screen.blurs_background(self.pause_menu)
|
||||
|| (self.screen == Screen::Win && self.win_screen_pauses())));
|
||||
let radius = self.settings.menu_blur as f32;
|
||||
(blurred && radius >= 1.0).then_some(radius)
|
||||
}
|
||||
@@ -10141,7 +10114,7 @@ impl Game<'_> {
|
||||
}
|
||||
Screen::GameModeSwitcher => self.close_gamemode_switcher(false),
|
||||
Screen::Dead => {}
|
||||
Screen::Stats => self.screen = Screen::Paused,
|
||||
Screen::Stats | Screen::Friends => self.screen = Screen::Paused,
|
||||
Screen::Advancements => self.close_advancements(),
|
||||
Screen::WorldOptions => self.world_options_escape(),
|
||||
Screen::CommandBlock => self.close_command_block(),
|
||||
@@ -10616,15 +10589,6 @@ impl ApplicationHandler for Game<'_> {
|
||||
) {
|
||||
self.last_input = Instant::now();
|
||||
}
|
||||
if let WindowEvent::MouseInput {
|
||||
state,
|
||||
button: MouseButton::Left,
|
||||
..
|
||||
} = &event
|
||||
{
|
||||
// The press state of Horizon-style buttons.
|
||||
horizon_client::ui_theme::set_pressed(*state == ElementState::Pressed);
|
||||
}
|
||||
if (self.pending_entry.is_some() || self.world_loader.is_some())
|
||||
&& matches!(&event, WindowEvent::KeyboardInput { event, .. }
|
||||
if event.state == ElementState::Pressed
|
||||
@@ -10724,9 +10688,7 @@ impl ApplicationHandler for Game<'_> {
|
||||
if matches!(self.screen, Screen::Inventory | Screen::Creative) {
|
||||
self.inventory_drag_move();
|
||||
}
|
||||
if let Some(title) = &mut self.title
|
||||
&& !horizon_client::ui_theme::horizon()
|
||||
{
|
||||
if let Some(title) = &mut self.title {
|
||||
title.drag(self.cursor, (b.width, b.height));
|
||||
title.drag_field(&self.gui.atlas, self.cursor.0);
|
||||
}
|
||||
@@ -10753,7 +10715,6 @@ impl ApplicationHandler for Game<'_> {
|
||||
};
|
||||
let d = scaled(raw_y) as f32;
|
||||
if let Some(title) = &mut self.title
|
||||
&& !horizon_client::ui_theme::horizon()
|
||||
&& self.screen != Screen::Win
|
||||
{
|
||||
let size = self
|
||||
@@ -10844,21 +10805,13 @@ impl ApplicationHandler for Game<'_> {
|
||||
.as_ref()
|
||||
.map(|r| [r.config.width, r.config.height])
|
||||
.unwrap_or([1, 1]);
|
||||
let mut b = HudBatch::new(size);
|
||||
let b = HudBatch::new(size);
|
||||
let atlas = &self.gui.atlas;
|
||||
let shift = self.has_shift_down();
|
||||
let (action, sound) = self.title.as_mut().map_or((Action::None, false), |t| {
|
||||
if horizon_client::ui_theme::horizon() {
|
||||
(
|
||||
t.click_horizon(atlas, &mut b, self.cursor.0, self.cursor.1),
|
||||
false,
|
||||
)
|
||||
} else {
|
||||
let clicked =
|
||||
t.click(self.cursor.0, self.cursor.1, (b.width, b.height));
|
||||
t.press_field(atlas, self.cursor, (b.width, b.height), shift);
|
||||
clicked
|
||||
}
|
||||
let clicked = t.click(self.cursor.0, self.cursor.1, (b.width, b.height));
|
||||
t.press_field(atlas, self.cursor, (b.width, b.height), shift);
|
||||
clicked
|
||||
});
|
||||
self.save_title_options();
|
||||
if sound {
|
||||
@@ -10994,6 +10947,9 @@ impl ApplicationHandler for Game<'_> {
|
||||
Screen::WorldOptions if pressed && button == MouseButton::Left => {
|
||||
self.world_options_click()
|
||||
}
|
||||
Screen::Friends if pressed && button == MouseButton::Left => {
|
||||
self.friends_screen_click()
|
||||
}
|
||||
Screen::CommandBlock if pressed && button == MouseButton::Left => {
|
||||
self.command_block_click()
|
||||
}
|
||||
@@ -11096,9 +11052,7 @@ impl ApplicationHandler for Game<'_> {
|
||||
}
|
||||
}
|
||||
WindowEvent::KeyboardInput { event, .. } if self.title.is_some() => {
|
||||
if event.state == ElementState::Pressed
|
||||
&& self.title.as_ref().is_some_and(|t| !t.skip_opening())
|
||||
{
|
||||
if event.state == ElementState::Pressed {
|
||||
if let Some(shortcut) = self.edit_shortcut(&event) {
|
||||
self.title_shortcut(shortcut);
|
||||
return Ok(());
|
||||
@@ -11191,11 +11145,6 @@ impl ApplicationHandler for Game<'_> {
|
||||
+ (turn(KeyCode::ArrowDown) - turn(KeyCode::ArrowUp)) * 90.0 * secs)
|
||||
.clamp(-90.0, 90.0);
|
||||
}
|
||||
self.update_backdrop()?;
|
||||
horizon_client::ui_theme::set_backdrop(self.backdrop_fade());
|
||||
if self.screen != Screen::Paused {
|
||||
self.pause_since = None;
|
||||
}
|
||||
if self.title.is_none() {
|
||||
horizon_client::spans::time("update_world", || self.update_world());
|
||||
horizon_client::spans::time("spawn_player", || self.spawn_player())?;
|
||||
@@ -11217,8 +11166,6 @@ impl ApplicationHandler for Game<'_> {
|
||||
}
|
||||
self.tick_ambience();
|
||||
self.tick_fov();
|
||||
} else if self.title.is_some() {
|
||||
self.tick_backdrop();
|
||||
}
|
||||
self.tick_win_screen()?;
|
||||
self.tick_music();
|
||||
@@ -11490,6 +11437,7 @@ impl<'a> Game<'a> {
|
||||
gui,
|
||||
fog: Default::default(),
|
||||
screen_fx: Default::default(),
|
||||
weather_parameters: Default::default(),
|
||||
panorama_rotation: Default::default(),
|
||||
world,
|
||||
streaming,
|
||||
@@ -11629,11 +11577,10 @@ impl<'a> Game<'a> {
|
||||
hand_strength: Default::default(),
|
||||
settings,
|
||||
options_from_title: false,
|
||||
backdrop: Default::default(),
|
||||
pause_since: None,
|
||||
dragging: false,
|
||||
avatar: Default::default(),
|
||||
flash: 0,
|
||||
lightning_seen: [0; 2],
|
||||
sleeping: None,
|
||||
sleep_timer: 0,
|
||||
dim: Dim::Overworld,
|
||||
@@ -12003,13 +11950,11 @@ impl Progress {
|
||||
/// Harness and dedicated runs keep the fully-synchronous startup so their
|
||||
/// output stays byte-identical; only an ordinary launch shows the window first.
|
||||
fn synchronous_startup(options: &Options) -> bool {
|
||||
let classic = std::env::var("HORIZON_MENU_STYLE").ok().as_deref() == Some("classic");
|
||||
options.frames.is_some()
|
||||
|| options.world_frames.is_some()
|
||||
|| options.benchmark.is_some()
|
||||
|| options.control.is_some()
|
||||
|| options.dedicated.is_some()
|
||||
|| classic
|
||||
|| std::env::var_os("HORIZON_DISPENSE_FIXTURE").is_some()
|
||||
|| std::env::var_os("HORIZON_SCULK_FIXTURE").is_some()
|
||||
|| std::env::var_os("HORIZON_COMMAND_SCRIPT").is_some()
|
||||
@@ -12030,7 +11975,7 @@ fn load_resources(
|
||||
let requested_root = root.clone();
|
||||
let threads = settings.horizon.worker_threads();
|
||||
// Stage A: the menu bundle (atlas and panorama). With a loading screen it is
|
||||
// published at once so the title backdrop can appear while the world bundle
|
||||
// published at once so the title screen can appear while the world bundle
|
||||
// loads; the synchronous launch instead carries it in `Loaded`.
|
||||
let mut loaded_gui = None;
|
||||
let mut ui_ready = false;
|
||||
@@ -12403,6 +12348,8 @@ fn loading_renderer(
|
||||
/// A title-shaped frame: black clear and panorama, only the HUD is drawn.
|
||||
fn loading_frame(hud: &HudBatch) -> Frame<'_> {
|
||||
Frame {
|
||||
weather: &[],
|
||||
weather_time: horizon_client::weather::Time::new(0, 0.0),
|
||||
camera: glam::DVec3::new(0.5, 100.0, 0.5),
|
||||
yaw: 0.0,
|
||||
pitch: 10.0,
|
||||
@@ -12449,7 +12396,6 @@ fn loading_frame(hud: &HudBatch) -> Frame<'_> {
|
||||
darkness: (0.0, 0.0),
|
||||
night_vision: 0.0,
|
||||
block_flicker: 0.0,
|
||||
post: None,
|
||||
menu_blur: None,
|
||||
shader: Default::default(),
|
||||
}
|
||||
@@ -12476,18 +12422,8 @@ fn start_game<'a>(
|
||||
let handoff = prepared.is_some();
|
||||
let mut settings = match settings {
|
||||
Some(settings) => settings,
|
||||
None => {
|
||||
horizon_client::ui_theme::load_preferences(&std::env::current_dir()?);
|
||||
Settings::load(&std::env::current_dir()?.join("options.txt"))
|
||||
}
|
||||
None => Settings::load(&std::env::current_dir()?.join("options.txt")),
|
||||
};
|
||||
// Scripted and frame-limited runs (the parity harnesses) see vanilla's
|
||||
// screens unless HORIZON_MENU_STYLE asks otherwise.
|
||||
if (options.frames.is_some() || options.control.is_some())
|
||||
&& std::env::var_os("HORIZON_MENU_STYLE").is_none()
|
||||
{
|
||||
horizon_client::ui_theme::set_style(horizon_client::ui_theme::MenuStyle::Classic);
|
||||
}
|
||||
if let Some(d) = options.distance_override {
|
||||
settings.render_distance = d;
|
||||
}
|
||||
@@ -12593,12 +12529,6 @@ fn start_game<'a>(
|
||||
&game.options.resources,
|
||||
);
|
||||
title.last_server = game.settings.file.string("lastServer");
|
||||
// The launcher's opening, once per session and only in Horizon's style.
|
||||
if horizon_client::ui_theme::horizon() && game.options.frames.is_none() {
|
||||
title
|
||||
.opening
|
||||
.set(Some(horizon_client::front::Opening::new()));
|
||||
}
|
||||
game.title = Some(title);
|
||||
}
|
||||
}
|
||||
@@ -12956,7 +12886,6 @@ fn run_loading(
|
||||
pack_error: Option<String>,
|
||||
started: Instant,
|
||||
) -> Result<()> {
|
||||
horizon_client::ui_theme::load_preferences(&std::env::current_dir()?);
|
||||
let progress = Progress::new();
|
||||
let (receiver, loader) =
|
||||
startup_menu::spawn_loader(&options, &settings, &vanilla_root, started, &progress)?;
|
||||
|
||||
@@ -403,6 +403,7 @@ impl Game<'_> {
|
||||
Screen::Stats => "stats",
|
||||
Screen::Advancements => "advancements",
|
||||
Screen::WorldOptions => "world-options",
|
||||
Screen::Friends => "friends",
|
||||
Screen::CommandBlock => "command-block",
|
||||
Screen::Win => "win",
|
||||
}
|
||||
|
||||
@@ -1,303 +0,0 @@
|
||||
//! The live title backdrop (Menu style: Horizon): a frozen landscape that
|
||||
//! Horizon generates and renders itself behind the title screens, seen
|
||||
//! through a slow orbiting camera, falling snow, an overcast sky and the cold
|
||||
//! blur and grade of `gfx::PostGrade`. Nothing is bundled: the chunks come
|
||||
//! from the vanilla generator for a fixed seed and are cached in
|
||||
//! `saves/.horizon-title/backdrop` (no level.dat, so no world list entry).
|
||||
//! The ice-spikes spot is found once with `/locate biome`'s search and kept
|
||||
//! in `spot.txt` there. The generator is built and the spot found on a
|
||||
//! worker, so the title keeps drawing its panorama until both are ready.
|
||||
use super::Game;
|
||||
use horizon_client::{
|
||||
Result,
|
||||
save::{Persistent, SaveDir},
|
||||
streaming::Streaming,
|
||||
vanillagen::VanillaTerrain,
|
||||
world::{Weather, World},
|
||||
};
|
||||
use horizon_core::biome::{BiomeZoom, obfuscate_seed};
|
||||
use std::{
|
||||
sync::{Arc, Mutex},
|
||||
time::Instant,
|
||||
};
|
||||
|
||||
/// The world the backdrop is cut from (HORIZON_BACKDROP_SEED overrides it).
|
||||
const SEED: i64 = 2_026_031_337;
|
||||
/// The biome the camera looks for.
|
||||
const BIOME: &str = "minecraft:ice_spikes";
|
||||
/// Late morning: the snow reads clearly; the grade (`PostGrade::FROST`) makes it cold.
|
||||
const DAY_TIME: i64 = 4_000;
|
||||
|
||||
/// The worker's result: the generator for [`SEED`], or why it failed.
|
||||
type Built = std::result::Result<Arc<VanillaTerrain>, String>;
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct Backdrop {
|
||||
pub active: bool,
|
||||
/// The generator, once the worker has built it; taken when it is installed.
|
||||
terrain: Arc<Mutex<Option<Built>>>,
|
||||
/// The generator streams the backdrop's chunks.
|
||||
installed: bool,
|
||||
/// The search for the spot, then the spot (block x, z).
|
||||
spot: Arc<Mutex<Option<Option<(i32, i32)>>>>,
|
||||
centred: bool,
|
||||
/// Camera position once the ground under it has loaded.
|
||||
pub camera: Option<glam::DVec3>,
|
||||
pub ready: Option<Instant>,
|
||||
pub started: Option<Instant>,
|
||||
}
|
||||
fn seed() -> i64 {
|
||||
std::env::var("HORIZON_BACKDROP_SEED")
|
||||
.ok()
|
||||
.and_then(|s| s.parse().ok())
|
||||
.unwrap_or(SEED)
|
||||
}
|
||||
impl Game<'_> {
|
||||
/// How visible the live backdrop is (0 until its first chunks are drawn).
|
||||
pub(super) fn backdrop_fade(&self) -> f32 {
|
||||
let Some(at) = self.backdrop.ready else {
|
||||
return 0.0;
|
||||
};
|
||||
let x = (at.elapsed().as_secs_f32() / 1.6).clamp(0.0, 1.0);
|
||||
x * x * (3.0 - 2.0 * x)
|
||||
}
|
||||
/// Whether the frame should draw the backdrop world instead of the panorama.
|
||||
pub(super) fn backdrop_live(&self) -> bool {
|
||||
self.title.is_some() && self.backdrop.active && self.backdrop.camera.is_some()
|
||||
}
|
||||
/// The orbiting camera: position, yaw and pitch.
|
||||
pub(super) fn backdrop_view(&self) -> Option<(glam::DVec3, f32, f32)> {
|
||||
let c = self.backdrop.camera?;
|
||||
let t = self
|
||||
.backdrop
|
||||
.started
|
||||
.map_or(0.0, |s| s.elapsed().as_secs_f32());
|
||||
// A full turn in about six minutes.
|
||||
let yaw = (200.0 + t * 1.0) % 360.0;
|
||||
let pitch = 6.0 + (t * 0.05).sin() * 2.0;
|
||||
Some((c, yaw, pitch))
|
||||
}
|
||||
/// Called every frame while the title is up.
|
||||
pub(super) fn update_backdrop(&mut self) -> Result<()> {
|
||||
let wanted = self.pending_entry.is_none()
|
||||
&& self.title.is_some()
|
||||
&& horizon_client::ui_theme::horizon()
|
||||
&& self.world_renderer_ready
|
||||
&& self.renderer.is_some()
|
||||
&& self.options.frames.is_none();
|
||||
if !wanted {
|
||||
if self.backdrop.active && self.title.is_some() {
|
||||
self.stop_backdrop();
|
||||
}
|
||||
if self.title.is_none() && self.backdrop.active {
|
||||
// open_world / connect_server replaced the world and streaming.
|
||||
self.backdrop = Backdrop::default();
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
if !self.backdrop.active {
|
||||
self.start_backdrop()?;
|
||||
}
|
||||
if !self.backdrop.installed {
|
||||
let built = self
|
||||
.backdrop
|
||||
.terrain
|
||||
.lock()
|
||||
.unwrap_or_else(|e| e.into_inner())
|
||||
.take();
|
||||
match built {
|
||||
// Still building: the panorama stays up.
|
||||
None => return Ok(()),
|
||||
Some(Ok(terrain)) => self.install_backdrop(terrain)?,
|
||||
Some(Err(e)) => {
|
||||
// The panorama stays up for good.
|
||||
log::warn!("Horizon: title backdrop: {e}");
|
||||
self.backdrop.installed = true;
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
}
|
||||
let found = *self.backdrop.spot.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let Some(Some((x, z))) = found else {
|
||||
return Ok(());
|
||||
};
|
||||
if !self.backdrop.centred {
|
||||
self.backdrop.centred = true;
|
||||
self.streaming.center = (x >> 4, z >> 4);
|
||||
self.streaming.paused = false;
|
||||
}
|
||||
self.update_world();
|
||||
if self.backdrop.camera.is_none()
|
||||
&& (-2..=2)
|
||||
.all(|dz| (-2..=2).all(|dx| self.streaming.is_lit((x >> 4) + dx, (z >> 4) + dz)))
|
||||
{
|
||||
// Above the tallest block nearby, so no spike pokes through the lens.
|
||||
let mut top = 64;
|
||||
for dz in (-12..=12).step_by(3) {
|
||||
for dx in (-12..=12).step_by(3) {
|
||||
if let Some(y) = self.surface_y(x + dx, z + dz) {
|
||||
top = top.max(y);
|
||||
}
|
||||
}
|
||||
}
|
||||
let ground = self.surface_y(x, z).unwrap_or(top);
|
||||
let y = (ground + 22).max(top + 4);
|
||||
self.backdrop.camera = Some(glam::DVec3::new(
|
||||
f64::from(x) + 0.5,
|
||||
f64::from(y),
|
||||
f64::from(z) + 0.5,
|
||||
));
|
||||
}
|
||||
if self.backdrop.camera.is_some()
|
||||
&& self.backdrop.ready.is_none()
|
||||
&& self
|
||||
.renderer
|
||||
.as_ref()
|
||||
.is_some_and(|r| r.section_count() > 40)
|
||||
{
|
||||
self.backdrop.ready = Some(Instant::now());
|
||||
log::info!(
|
||||
"Horizon: title backdrop ready; world rest ready: {}",
|
||||
self.res.rest.get().is_some()
|
||||
);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
/// The world tick of the backdrop: time passes for clouds and snow only.
|
||||
pub(super) fn tick_backdrop(&mut self) {
|
||||
if self.backdrop.active {
|
||||
self.world.game_time += 1;
|
||||
// The snow's fall follows the client tick counter.
|
||||
self.ticks += 1;
|
||||
}
|
||||
}
|
||||
fn surface_y(&self, x: i32, z: i32) -> Option<i32> {
|
||||
let air = self.res.facts().air;
|
||||
(-60..320).rev().find(|&y| self.world.block(x, y, z) != air)
|
||||
}
|
||||
/// Start building the generator and finding the spot on a worker
|
||||
/// (`VanillaTerrain::new` takes seconds on a cold cache).
|
||||
fn start_backdrop(&mut self) -> Result<()> {
|
||||
log::info!(
|
||||
"Horizon: starting title backdrop after {} ms",
|
||||
self.started.elapsed().as_millis()
|
||||
);
|
||||
let seed = seed();
|
||||
let dir = self.backdrop_root()?.join(format!("{seed}"));
|
||||
std::fs::create_dir_all(&dir)?;
|
||||
// The streaming is replaced once the generator is built.
|
||||
self.streaming.paused = true;
|
||||
let mut world = World::new(self.res.facts().air, seed);
|
||||
world.day_time = DAY_TIME;
|
||||
world.game_time = 6000;
|
||||
// Light snow: the weather renders as snow in frozen biomes.
|
||||
world.weather = Weather {
|
||||
clear_time: 0,
|
||||
rain_time: i32::MAX / 2,
|
||||
thunder_time: i32::MAX / 2,
|
||||
raining: true,
|
||||
thundering: false,
|
||||
rain_level: (0.35, 0.35),
|
||||
thunder_level: (0.0, 0.0),
|
||||
};
|
||||
self.world = world;
|
||||
self.dim = super::Dim::Overworld;
|
||||
if let Some(r) = self.renderer.as_mut() {
|
||||
r.clear_sections();
|
||||
}
|
||||
self.backdrop = Backdrop {
|
||||
active: true,
|
||||
started: Some(Instant::now()),
|
||||
..Default::default()
|
||||
};
|
||||
let (terrain, spot) = (self.backdrop.terrain.clone(), self.backdrop.spot.clone());
|
||||
let worldgen = self.options.resources.join("worldgen");
|
||||
let registry = self.pack.assets.registry;
|
||||
let biomes = self.res.biomes().clone();
|
||||
let cache = dir.join("spot.txt");
|
||||
std::thread::Builder::new()
|
||||
.name("horizon-backdrop".into())
|
||||
.spawn(move || {
|
||||
let built = Instant::now();
|
||||
let inner = match VanillaTerrain::new(&worldgen, registry, &biomes, seed) {
|
||||
Ok(t) => Arc::new(t),
|
||||
Err(e) => {
|
||||
*terrain.lock().unwrap_or_else(|e| e.into_inner()) =
|
||||
Some(Err(e.to_string()));
|
||||
return;
|
||||
}
|
||||
};
|
||||
log::info!(
|
||||
"Horizon: title backdrop generator built in {} ms",
|
||||
built.elapsed().as_millis()
|
||||
);
|
||||
*terrain.lock().unwrap_or_else(|e| e.into_inner()) = Some(Ok(inner.clone()));
|
||||
// Find (or recall) the spot.
|
||||
let known = std::fs::read_to_string(&cache).ok().and_then(|t| {
|
||||
let mut it = t.split_whitespace().map(|v| v.parse::<i32>().ok());
|
||||
Some((it.next()??, it.next()??))
|
||||
});
|
||||
let found = known.or_else(|| {
|
||||
let allowed = |name: &str| name == BIOME;
|
||||
let search = horizon_world::worldgen::generator::BiomeSearch {
|
||||
allowed: &allowed,
|
||||
origin: [0, 64, 0],
|
||||
radius: 6400,
|
||||
horizontal: 32,
|
||||
vertical: 64,
|
||||
min_y: -64,
|
||||
max_y: 320,
|
||||
};
|
||||
let found = inner.find_closest_biome(&search);
|
||||
log::info!("Horizon: title backdrop: {BIOME} at {found:?}");
|
||||
let (_, p) = found?;
|
||||
let _ = std::fs::write(&cache, format!("{} {}\n", p[0], p[2]));
|
||||
Some((p[0], p[2]))
|
||||
});
|
||||
*spot.lock().unwrap_or_else(|e| e.into_inner()) =
|
||||
Some(Some(found.unwrap_or((0, 0))));
|
||||
})?;
|
||||
Ok(())
|
||||
}
|
||||
fn backdrop_root(&self) -> Result<std::path::PathBuf> {
|
||||
Ok(std::env::current_dir()?
|
||||
.join("saves")
|
||||
.join(".horizon-title")
|
||||
.join("backdrop"))
|
||||
}
|
||||
/// The built generator streams the backdrop's chunks.
|
||||
fn install_backdrop(&mut self, inner: Arc<VanillaTerrain>) -> Result<()> {
|
||||
let seed = seed();
|
||||
let save = Arc::new(SaveDir::new(self.backdrop_root()?.join(format!("{seed}"))));
|
||||
let (res, pack) = (&*self.res, &self.pack);
|
||||
let mut streaming = Streaming::new(
|
||||
Arc::new(Persistent {
|
||||
inner,
|
||||
save: save.clone(),
|
||||
registry: pack.assets.clone(),
|
||||
biomes: res.biomes().clone(),
|
||||
}),
|
||||
pack.context.clone(),
|
||||
res.threads().min(6),
|
||||
);
|
||||
streaming.radius = self.settings.render_distance.clamp(4, 10);
|
||||
streaming.biome_blend = self.settings.biome_blend;
|
||||
streaming.smooth_lighting = self.settings.smooth_lighting;
|
||||
streaming.cutout_leaves = self.settings.cutout_leaves;
|
||||
streaming.cull_leaves = self.settings.horizon.cull_leaves;
|
||||
streaming.biome_zoom = BiomeZoom::new(obfuscate_seed(seed));
|
||||
streaming.paused = true;
|
||||
self.streaming = streaming;
|
||||
self.save = save;
|
||||
self.backdrop.installed = true;
|
||||
Ok(())
|
||||
}
|
||||
fn stop_backdrop(&mut self) {
|
||||
self.streaming.paused = true;
|
||||
self.world = World::new(self.res.facts().air, 0);
|
||||
if let Some(r) = self.renderer.as_mut() {
|
||||
r.clear_sections();
|
||||
}
|
||||
self.backdrop = Backdrop::default();
|
||||
}
|
||||
}
|
||||
@@ -57,7 +57,7 @@ pub(super) const CHEST_SLOTS: usize = 27;
|
||||
const WIDTH: f64 = 1.375;
|
||||
const HEIGHT: f64 = 0.5625;
|
||||
/// Player.DEFAULT_VEHICLE_ATTACHMENT minus the boat's passenger attachment.
|
||||
const SEAT: f64 = 0.1875 - 0.6;
|
||||
pub(super) const SEAT: f64 = 0.1875 - 0.6;
|
||||
impl Boat {
|
||||
pub fn new(id: u32, wood: Arc<str>, position: Vec3, yaw: f32) -> Self {
|
||||
Self {
|
||||
@@ -295,7 +295,7 @@ impl Game<'_> {
|
||||
}
|
||||
}
|
||||
/// `AbstractBoat.tick` for one boat (`controlled` when the player rides it).
|
||||
fn tick_boat(&mut self, mut b: Boat, controlled: bool) -> Boat {
|
||||
pub(super) fn tick_boat(&mut self, mut b: Boat, controlled: bool) -> Boat {
|
||||
b.previous = b.position;
|
||||
b.previous_yaw = b.yaw;
|
||||
b.old_status = b.status;
|
||||
@@ -448,9 +448,12 @@ impl Game<'_> {
|
||||
pub(super) fn tick_boats(&mut self) {
|
||||
// ServerLevel.tick: only entities in entity-ticking chunks tick.
|
||||
let ticking = self.entity_ticking_area();
|
||||
// A server player's boat is driven by its client (lan_vehicles.rs).
|
||||
let driven = self.guest_vehicles();
|
||||
for i in 0..self.boats.len() {
|
||||
let p = self.boats[i].position;
|
||||
if Some(self.boats[i].id) == self.riding
|
||||
|| driven.contains(&self.boats[i].id)
|
||||
|| !ticking(p.x.floor() as i32, p.z.floor() as i32)
|
||||
{
|
||||
continue;
|
||||
@@ -659,7 +662,11 @@ impl Game<'_> {
|
||||
self.right = false;
|
||||
return true;
|
||||
}
|
||||
if sneaking || self.boats[i].out_of_control >= 60.0 || self.riding.is_some() {
|
||||
if sneaking
|
||||
|| self.boats[i].out_of_control >= 60.0
|
||||
|| self.riding.is_some()
|
||||
|| self.ridden_by_guest(self.boats[i].id)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
self.riding = Some(self.boats[i].id);
|
||||
|
||||
@@ -566,6 +566,8 @@ impl Game<'_> {
|
||||
"graphics-advanced" => Page::GraphicsAdvanced,
|
||||
"extras" => Page::Extras,
|
||||
"credits" => Page::Credits,
|
||||
"horizon" => Page::Horizon,
|
||||
"shader-packs" => Page::ShaderPacks,
|
||||
other => return Err(format!("unknown options page {other}").into()),
|
||||
};
|
||||
if self.screen == Screen::Playing && self.title.is_none() {
|
||||
@@ -760,6 +762,7 @@ impl Game<'_> {
|
||||
Screen::Stats => "stats",
|
||||
Screen::Advancements => "advancements",
|
||||
Screen::WorldOptions => "world-options",
|
||||
Screen::Friends => "friends",
|
||||
Screen::CommandBlock => "command-block",
|
||||
Screen::Win => "win",
|
||||
}
|
||||
@@ -951,6 +954,8 @@ impl Game<'_> {
|
||||
status["heard"] = json!(self.audio.heard);
|
||||
// Boats, minecarts, armor stands, item frames and paintings.
|
||||
status["objects"] = json!(self.objects_status());
|
||||
status["lightning"] = json!({"bolts": self.bolts.len(), "struck": self.lightning_seen[0],
|
||||
"flashes": self.lightning_seen[1], "flash": self.flash});
|
||||
// Primed TNT, falling blocks, projectiles, tridents and end crystals.
|
||||
status["projectiles"] = json!(self.projectiles_status());
|
||||
status
|
||||
|
||||
@@ -330,6 +330,10 @@ impl Game<'_> {
|
||||
"held": m.extra.main_hand.as_deref(),
|
||||
"mount": m.extra.mount,
|
||||
"rider": m.extra.rider,
|
||||
// A player's input this tick, and whether it steers.
|
||||
"ridden": m.rider.map(|r| r.steer),
|
||||
"controlled": horizon_client::mobs::equine::controlled(m),
|
||||
"saddled": m.extra.saddled,
|
||||
"enchants": horizon_client::mobs::gear::gear(m).map(|g| g.slots.iter().map(|s| s.iter().map(|(e, l)| format!("{e}:{l}")).collect::<Vec<_>>()).collect::<Vec<_>>()),
|
||||
"ints": m.extra.ints,
|
||||
"pois": [m.extra.home, m.extra.bed, m.extra.meeting],
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
//! Play with friends, host side: "Invite friends" opens the world to LAN if
|
||||
//! Play with friends, host side: "Start Sharing" on the Play with Friends
|
||||
//! screen (`friends_screen`, the pause menu's Friends button) opens the world to LAN if
|
||||
//! it isn't (with Open to LAN's defaults) and shares that port behind an
|
||||
//! invite code (horizon-friends). The code holds this computer's addresses
|
||||
//! and the key, so friends join with no server of ours; a relay the player
|
||||
@@ -6,7 +7,12 @@
|
||||
//! LAN one, unchanged: tunnelled guests are LAN guests that connect from the
|
||||
//! loopback address.
|
||||
use super::{Game, lan::LanSettings};
|
||||
use horizon_client::{Result, front::FriendsView, text::Text};
|
||||
use horizon_client::{
|
||||
Result,
|
||||
friends_screen::{self, Action, FriendsView},
|
||||
hud::HudBatch,
|
||||
text::Text,
|
||||
};
|
||||
use horizon_friends::{Host, HostConfig, HostEvent, PathMode, host::DEFAULT_PORT, reach, stun};
|
||||
use horizon_protocol::{GAME_VERSION, PROTOCOL_VERSION};
|
||||
use std::time::{Duration, Instant};
|
||||
@@ -52,10 +58,12 @@ impl Game<'_> {
|
||||
if self.friends.is_some() {
|
||||
return Ok(());
|
||||
}
|
||||
if self.remote.is_some() || self.title.is_some() {
|
||||
// Single player on its server thread shares that server, as Open to
|
||||
// LAN publishes it; another server can't be shared.
|
||||
if self.title.is_some() || (self.remote.is_some() && self.integrated.is_none()) {
|
||||
return Err("open a singleplayer world first".into());
|
||||
}
|
||||
let opened_lan = self.lan.is_none();
|
||||
let opened_lan = self.lan_port().is_none();
|
||||
if opened_lan {
|
||||
// ShareToLanScreen's defaults, as the world options screen offers them.
|
||||
self.lan_open(LanSettings {
|
||||
@@ -153,7 +161,7 @@ impl Game<'_> {
|
||||
}
|
||||
if announce {
|
||||
self.system_message(Text::literal(
|
||||
"Your invite code is ready in the pause menu: copy it and send it to your friends.",
|
||||
"Your invite code is ready: Game Menu, Play with Friends. Copy it and send it to your friends.",
|
||||
));
|
||||
}
|
||||
}
|
||||
@@ -169,16 +177,55 @@ impl Game<'_> {
|
||||
}
|
||||
}
|
||||
|
||||
/// What the pause menu shows.
|
||||
/// Play with Friends. The world is paused under it in singleplayer, so
|
||||
/// new codes and sessions are read while it is drawn.
|
||||
pub(super) fn draw_friends_screen(&mut self, batch: &mut HudBatch) {
|
||||
self.tick_friends();
|
||||
let view = self.friends_view();
|
||||
friends_screen::draw(batch, &self.gui.atlas, self.cursor, &view, true);
|
||||
}
|
||||
pub(super) fn friends_screen_click(&mut self) {
|
||||
let view = self.friends_view();
|
||||
let Some(action) =
|
||||
friends_screen::click(&self.gui.atlas, self.gui_size(), self.cursor, &view)
|
||||
else {
|
||||
return;
|
||||
};
|
||||
self.audio.play_button_click();
|
||||
match action {
|
||||
Action::Share => {
|
||||
if let Err(e) = self.friends_start() {
|
||||
self.system_message(Text::literal(format!("Couldn't share the world: {e}")));
|
||||
}
|
||||
}
|
||||
Action::Copy => self.friends_copy(),
|
||||
Action::Stop => self.friends_stop(),
|
||||
// The system browser, as the Shader Packs page opens its folder.
|
||||
Action::Help => {
|
||||
if let Some(url) = &view.help {
|
||||
super::packs::open_folder(std::path::Path::new(url));
|
||||
}
|
||||
}
|
||||
Action::Done => self.screen = super::Screen::Paused,
|
||||
}
|
||||
}
|
||||
|
||||
/// What Play with Friends shows.
|
||||
pub(super) fn friends_view(&self) -> FriendsView {
|
||||
let guests = self
|
||||
.lan
|
||||
.as_ref()
|
||||
.map(|h| h.hub.guests.iter().map(|g| g.name.clone()).collect())
|
||||
.unwrap_or_default();
|
||||
let guests = match &self.lan {
|
||||
Some(h) => h.hub.guests.iter().map(|g| g.name.clone()).collect(),
|
||||
// On the server thread: the other players the server lists.
|
||||
None if self.integrated.is_some() => {
|
||||
let me = self.options.player_name();
|
||||
let mut names = self.remote_online_names().unwrap_or_default();
|
||||
names.retain(|n| *n != me);
|
||||
names
|
||||
}
|
||||
None => Vec::new(),
|
||||
};
|
||||
let Some(s) = &self.friends else {
|
||||
return FriendsView {
|
||||
shown: self.remote.is_none(),
|
||||
shown: self.remote.is_none() || self.integrated.is_some(),
|
||||
..FriendsView::default()
|
||||
};
|
||||
};
|
||||
|
||||
@@ -800,6 +800,16 @@ impl Game<'_> {
|
||||
self.send_admin_feedback(&mut host, None);
|
||||
}
|
||||
let state = self.lan_host_state(&host);
|
||||
// An animal whose rider left the game (or the level) stops taking
|
||||
// its input.
|
||||
for m in &mut self.mobs {
|
||||
if m.rider.is_some()
|
||||
&& self.riding != Some(m.id)
|
||||
&& !host.hub.guests.iter().any(|g| g.vehicle == Some(m.id))
|
||||
{
|
||||
m.rider = None;
|
||||
}
|
||||
}
|
||||
// A dedicated server runs the hub without a host player.
|
||||
if state.is_some() || host.hub.config.dedicated {
|
||||
let has_guests = !host.hub.guests.is_empty();
|
||||
@@ -807,7 +817,13 @@ impl Game<'_> {
|
||||
if has_guests {
|
||||
let host_entity = state.as_ref().map(|s| s.entity_id);
|
||||
self.lan_assign_ids();
|
||||
self.lan_riding(host_entity, &mut host.hub.riding);
|
||||
let guests: Vec<(u32, i32)> = host
|
||||
.hub
|
||||
.guests
|
||||
.iter()
|
||||
.filter_map(|g| Some((g.vehicle?, g.entity_id)))
|
||||
.collect();
|
||||
self.lan_riding(host_entity, &guests, &mut host.hub.riding);
|
||||
self.lan_entities(host_entity, &mut host.hub, &mut states);
|
||||
} else {
|
||||
states.clear();
|
||||
|
||||
@@ -49,6 +49,8 @@ pub(super) struct GuestPlay {
|
||||
/// Swings the guest's actions started this tick, for the players around
|
||||
/// (`LivingEntity.swing` sends ClientboundSwingAnimationPacket).
|
||||
swings: u32,
|
||||
/// The guest's riding jump charge (`LocalPlayer.jumpRidingTicks`).
|
||||
mount: super::mounts::MountState,
|
||||
/// The trading screen the guest has open.
|
||||
pub(super) merchant: Option<super::lan_trading::GuestMerchant>,
|
||||
/// The inventory menu and the crafting table the guest crafts in.
|
||||
@@ -289,10 +291,12 @@ impl Game<'_> {
|
||||
let attack_ticks = std::mem::replace(&mut self.attack_ticks, play.attack_ticks);
|
||||
let attack_item = std::mem::replace(&mut self.attack_item, play.attack_item.take());
|
||||
let swing = std::mem::replace(&mut self.swing, play.swing);
|
||||
std::mem::swap(&mut self.mount, &mut play.mount);
|
||||
let (left, right) = (self.left, self.right);
|
||||
self.left = play.digging.is_some();
|
||||
self.right = play.using.is_some() || self.using.is_some();
|
||||
let riding = self.riding.take();
|
||||
// The guest's vehicle (Entity.vehicle) for its turn.
|
||||
let riding = std::mem::replace(&mut self.riding, g.vehicle);
|
||||
let host_station = self.station.take();
|
||||
// The guest's bed, sleep counter and respawn point; the host's
|
||||
// respawn point, anchor and action bar stay theirs.
|
||||
@@ -467,7 +471,7 @@ impl Game<'_> {
|
||||
(self.respawn_config, self.level.spawn) = respawn;
|
||||
// ServerPlayer.displayClientMessage(_, true): the guest's action bar.
|
||||
let guest_message = std::mem::replace(&mut self.message, message);
|
||||
self.riding = riding;
|
||||
let guest_vehicle = std::mem::replace(&mut self.riding, riding);
|
||||
self.left = left;
|
||||
self.right = right;
|
||||
play.mining = std::mem::replace(&mut self.mining, mining);
|
||||
@@ -477,6 +481,7 @@ impl Game<'_> {
|
||||
play.attack_ticks = std::mem::replace(&mut self.attack_ticks, attack_ticks);
|
||||
play.attack_item = std::mem::replace(&mut self.attack_item, attack_item);
|
||||
play.swing = std::mem::replace(&mut self.swing, swing);
|
||||
std::mem::swap(&mut self.mount, &mut play.mount);
|
||||
self.container = container;
|
||||
self.screen = screen;
|
||||
self.sign_edit = host_sign;
|
||||
@@ -491,6 +496,11 @@ impl Game<'_> {
|
||||
self.mount_menu = host_mount_menu;
|
||||
self.keys = host_keys;
|
||||
let g = &mut host.hub.guests[i];
|
||||
let left_vehicle = g.vehicle.filter(|_| guest_vehicle.is_none());
|
||||
if guest_vehicle.is_none() {
|
||||
g.vehicle_good = None;
|
||||
}
|
||||
g.vehicle = guest_vehicle;
|
||||
let fell_asleep = bed.is_some() && g.bed.is_none();
|
||||
(g.bed, g.sleep_timer, g.spawn) = (bed, guest_sleep_timer, guest_spawn);
|
||||
g.sleeping = g.bed.is_some();
|
||||
@@ -549,7 +559,24 @@ impl Game<'_> {
|
||||
let teleported = std::mem::take(&mut m.teleported);
|
||||
let moved: f64 = (0..3).map(|k| (at[k] - g.position[k]).powi(2)).sum();
|
||||
g.motion = Some(Box::new(m));
|
||||
if moved > 0.0001 || turned || teleported {
|
||||
// Entity.teleportTo takes a rider out of its vehicle.
|
||||
let left_vehicle = match g.vehicle.filter(|_| teleported) {
|
||||
Some(v) => {
|
||||
(g.vehicle, g.vehicle_good) = (None, None);
|
||||
Some(v)
|
||||
}
|
||||
None => left_vehicle,
|
||||
};
|
||||
// ServerPlayer.dismountTo: the client hears it is out of the
|
||||
// vehicle before the teleport beside it. A rider sits where its
|
||||
// vehicle puts it (lan_vehicles.rs), with no teleport.
|
||||
if let Some(vehicle) = left_vehicle {
|
||||
g.send(&C::SetPassengers(play::SetPassengers {
|
||||
vehicle: vehicle as i32,
|
||||
passengers: Vec::new(),
|
||||
}));
|
||||
}
|
||||
if g.vehicle.is_none() && (moved > 0.0001 || turned || teleported) {
|
||||
host.hub.teleport(i, Some(at));
|
||||
}
|
||||
}
|
||||
@@ -900,16 +927,22 @@ impl Game<'_> {
|
||||
}
|
||||
S::Attack(p) => self.guest_attack(host, conn, p.id),
|
||||
S::Interact(p) => {
|
||||
if let Some((position, eye)) = self.look_at_entity(host, gi, p.id) {
|
||||
let _ = (position, eye);
|
||||
let before = host.hub.guests[gi].vehicle;
|
||||
if self
|
||||
.look_at_entity(host, gi, p.id, Some(p.location))
|
||||
.is_some()
|
||||
{
|
||||
let swung = self.as_guest(host, conn, |g| {
|
||||
let swings = g.swings_started;
|
||||
let _ = g.use_item();
|
||||
g.swings_started != swings
|
||||
});
|
||||
self.lan_swing_back(host, conn, swung);
|
||||
self.guest_boarded(host, conn, before);
|
||||
}
|
||||
}
|
||||
S::MoveVehicle(p) => self.guest_move_vehicle(host, conn, &p),
|
||||
S::PaddleBoat(p) => self.guest_paddle_boat(host, conn, [p.left, p.right]),
|
||||
S::SetCreativeModeSlot(p) => {
|
||||
let g = &mut host.hub.guests[gi];
|
||||
if !g.creative() || !(0..46).contains(&p.slot) {
|
||||
@@ -1147,19 +1180,39 @@ impl Game<'_> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Aim the swapped-in player at an entity; returns its centre and the eye.
|
||||
/// Aim the swapped-in player at an entity; returns where it aims and the
|
||||
/// eye. A boat, minecart, armor stand, item frame or painting is aimed at
|
||||
/// the point the client hit (the interact packet's location) when that
|
||||
/// is on it, else at its centre.
|
||||
fn look_at_entity(
|
||||
&mut self,
|
||||
host: &mut LanHost,
|
||||
gi: usize,
|
||||
id: i32,
|
||||
location: Option<[f64; 3]>,
|
||||
) -> Option<([f64; 3], [f64; 3])> {
|
||||
let object = || {
|
||||
let (lo, hi, origin) = self.object_target(id)?;
|
||||
let middle = [0, 1, 2].map(|k| (lo[k] + hi[k]) / 2.0);
|
||||
let Some(l) = location else {
|
||||
return Some(middle);
|
||||
};
|
||||
let point = [0, 1, 2].map(|k| origin[k] + l[k]);
|
||||
// A little inside the box, so the ray from the eye meets it.
|
||||
let inside = [0, 1, 2].map(|k| {
|
||||
let margin = ((hi[k] - lo[k]) / 2.0).min(0.01);
|
||||
point[k].clamp(lo[k] + margin, hi[k] - margin)
|
||||
});
|
||||
let on = (0..3).all(|k| (point[k] - inside[k]).abs() < 0.1);
|
||||
Some(if on { inside } else { middle })
|
||||
};
|
||||
let centre = match self.mobs.iter().find(|m| m.id as i32 == id) {
|
||||
Some(m) => [
|
||||
m.position.x,
|
||||
m.position.y + m.kind.height * 0.5,
|
||||
m.position.z,
|
||||
],
|
||||
None if self.object_target(id).is_some() => object()?,
|
||||
// A dragon part or an end crystal (game/dragon.rs).
|
||||
None => {
|
||||
let b = self.tracked_special_box(id)?;
|
||||
@@ -1210,7 +1263,7 @@ impl Game<'_> {
|
||||
return;
|
||||
}
|
||||
let (old_yaw, old_pitch) = (host.hub.guests[gi].yaw, host.hub.guests[gi].pitch);
|
||||
if self.look_at_entity(host, gi, id).is_none() {
|
||||
if self.look_at_entity(host, gi, id, None).is_none() {
|
||||
return;
|
||||
}
|
||||
self.as_guest(host, conn, |g| {
|
||||
@@ -1676,6 +1729,7 @@ impl Game<'_> {
|
||||
/// regeneration and the food tick (ServerPlayer.doTick). Their hurt
|
||||
/// sounds are heard at the guest.
|
||||
fn guest_server_tick(&mut self, host: &mut LanHost, conn: u32) {
|
||||
self.guest_vehicle_tick(host, conn);
|
||||
let Some(g) = host.hub.guest_mut(conn) else {
|
||||
return;
|
||||
};
|
||||
|
||||
@@ -89,8 +89,17 @@ fn stand_poses(raw: Option<&Tag>) -> Vec<(u8, i32, Value)> {
|
||||
impl Game<'_> {
|
||||
/// Who rides what (`Entity.getPassengers`): mobs on mobs, and the
|
||||
/// host in its boat or minecart.
|
||||
pub(super) fn lan_riding(&self, host_entity: Option<i32>, riding: &mut Riding) {
|
||||
pub(super) fn lan_riding(
|
||||
&self,
|
||||
host_entity: Option<i32>,
|
||||
guests: &[(u32, i32)],
|
||||
riding: &mut Riding,
|
||||
) {
|
||||
riding.clear();
|
||||
// The server's players in their boats and minecarts.
|
||||
for &(vehicle, guest) in guests {
|
||||
riding.add(vehicle as i32, guest);
|
||||
}
|
||||
for m in self.mobs.iter().filter(|m| !m.removed) {
|
||||
if let Some(vehicle) = m.extra.mount {
|
||||
riding.add(vehicle as i32, m.id as i32);
|
||||
@@ -264,6 +273,7 @@ impl Game<'_> {
|
||||
self.tridents.iter_mut().for_each(|t| give(&mut t.id));
|
||||
self.rockets.iter_mut().for_each(|r| give(&mut r.id));
|
||||
self.crystals.iter_mut().for_each(|c| give(&mut c.id));
|
||||
self.bolts.iter_mut().for_each(|b| give(&mut b.id));
|
||||
}
|
||||
|
||||
/// Primed TNT, falling blocks, projectiles, tridents, firework rockets and
|
||||
@@ -275,6 +285,10 @@ impl Game<'_> {
|
||||
None => 0,
|
||||
};
|
||||
let at = |p: horizon_core::geometry::Vec3| [p.x, p.y, p.z];
|
||||
// LightningBolt: each client draws and flashes its own.
|
||||
for b in self.bolts.iter().filter(|b| b.id != 0) {
|
||||
out.push(state(b.id, "minecraft:lightning_bolt", b.at, 0.0, false));
|
||||
}
|
||||
for t in self.tnts.iter().filter(|t| t.id != 0) {
|
||||
let mut e = state(t.id, "minecraft:tnt", at(t.position), 0.0, t.on_ground);
|
||||
e.velocity = at(t.velocity);
|
||||
|
||||
@@ -0,0 +1,308 @@
|
||||
//! Boats and minecarts for a server's players: LAN guests, players on a
|
||||
//! dedicated server, and single player's window on its server thread.
|
||||
//!
|
||||
//! A player aims at a vehicle, item frame, armor stand or painting as at a
|
||||
//! mob (`ServerGamePacketListenerImpl.handleInteract`), and the game's own
|
||||
//! code for it runs as that player (`AbstractBoat.interact` seats it,
|
||||
//! `VehicleEntity.hurtServer` breaks the vehicle). A boat is driven by its
|
||||
//! rider's client (`handleMoveVehicle`, `handlePaddleBoat`); a minecart moves
|
||||
//! here with the rider's input (`ServerPlayer.getLastClientMoveIntent`).
|
||||
//! Sneaking gets out (`Player.rideTick`: `wantsToStopRiding`), and the client
|
||||
//! is teleported where the player lands (`ServerPlayer.dismountTo`).
|
||||
use super::{Game, Keys, boats::SEAT, lan::LanHost};
|
||||
use horizon_client::collisions::SceneCollisions;
|
||||
use horizon_core::geometry::{Aabb, Vec3};
|
||||
use horizon_protocol::{
|
||||
packets::play::{self, Clientbound as C},
|
||||
text::translatable,
|
||||
};
|
||||
|
||||
/// `PlayerInput` flags, as the server player's client last sent them.
|
||||
pub(super) fn input_keys(flags: u8) -> Keys {
|
||||
Keys {
|
||||
forward: flags & 1 != 0,
|
||||
backward: flags & 2 != 0,
|
||||
left: flags & 4 != 0,
|
||||
right: flags & 8 != 0,
|
||||
jump: flags & 16 != 0,
|
||||
shift: flags & 32 != 0,
|
||||
sprint: flags & 64 != 0,
|
||||
..Keys::default()
|
||||
}
|
||||
}
|
||||
|
||||
fn corners(b: Aabb) -> ([f64; 3], [f64; 3]) {
|
||||
let (lo, hi) = (b.min_position(), b.max_position());
|
||||
([lo.x, lo.y, lo.z], [hi.x, hi.y, hi.z])
|
||||
}
|
||||
|
||||
impl Game<'_> {
|
||||
/// The box of a boat, minecart, armor stand, item frame or painting, and
|
||||
/// the point an interact packet's location is measured from (the
|
||||
/// client's `remote_object_hit` uses the same points).
|
||||
pub(super) fn object_target(&self, id: i32) -> Option<([f64; 3], [f64; 3], [f64; 3])> {
|
||||
let id = u32::try_from(id).ok()?;
|
||||
let at = |v: Vec3| [v.x, v.y, v.z];
|
||||
let centre = |p: [i32; 3]| p.map(|v| f64::from(v) + 0.5);
|
||||
if let Some(b) = self.boats.iter().find(|b| b.id == id) {
|
||||
let (lo, hi) = corners(b.bounds());
|
||||
return Some((lo, hi, at(b.position)));
|
||||
}
|
||||
if let Some(c) = self.carts.iter().find(|c| c.id == id) {
|
||||
let (lo, hi) = corners(c.bounds());
|
||||
return Some((lo, hi, at(c.position)));
|
||||
}
|
||||
if let Some(a) = self.armor_stands.iter().find(|a| a.id == id) {
|
||||
let (lo, hi) = corners(a.bounds());
|
||||
return Some((lo, hi, at(a.position)));
|
||||
}
|
||||
if let Some(f) = self.item_frames.iter().find(|f| f.id == id) {
|
||||
let (lo, hi) = f.bounds();
|
||||
return Some((lo, hi, centre(f.pos)));
|
||||
}
|
||||
let p = self.paintings.iter().find(|p| p.id == id)?;
|
||||
let (lo, hi) = p.bounds();
|
||||
Some((lo, hi, centre(p.pos)))
|
||||
}
|
||||
|
||||
/// The vehicles the server's players ride: they move with their riders,
|
||||
/// not in `tick_boats` and `tick_carts`.
|
||||
pub(super) fn guest_vehicles(&self) -> Vec<u32> {
|
||||
self.lan.as_ref().map_or_else(Vec::new, |h| {
|
||||
h.hub.guests.iter().filter_map(|g| g.vehicle).collect()
|
||||
})
|
||||
}
|
||||
|
||||
/// Whether a server player other than the one acting rides `vehicle`
|
||||
/// (`Entity.canAddPassenger`: a boat or minecart seats one player here).
|
||||
pub(super) fn ridden_by_guest(&self, vehicle: u32) -> bool {
|
||||
self.lan.as_ref().is_some_and(|h| {
|
||||
h.hub
|
||||
.guests
|
||||
.iter()
|
||||
.any(|g| Some(g.conn) != self.lan_acting && g.vehicle == Some(vehicle))
|
||||
})
|
||||
}
|
||||
|
||||
/// `Player.rideTick` for a server player, before its moves this tick:
|
||||
/// it stays in its seat, steers its minecart, or gets out.
|
||||
pub(super) fn guest_vehicle_tick(&mut self, host: &mut LanHost, conn: u32) {
|
||||
let Some(gi) = host.hub.guests.iter().position(|g| g.conn == conn) else {
|
||||
return;
|
||||
};
|
||||
let g = &host.hub.guests[gi];
|
||||
let Some(vehicle) = g.vehicle else {
|
||||
return;
|
||||
};
|
||||
let (keys, dead) = (input_keys(g.input), g.dead || g.health <= 0.0);
|
||||
let boat = self.boats.iter().position(|b| b.id == vehicle);
|
||||
let cart = self.carts.iter().any(|c| c.id == vehicle);
|
||||
let mount = self.mobs.iter().any(|m| m.id == vehicle);
|
||||
// The vehicle is gone (broken, in another level) or the rider died:
|
||||
// its client drops it with the entity or the death screen.
|
||||
if dead || (boat.is_none() && !cart && !mount) {
|
||||
let g = &mut host.hub.guests[gi];
|
||||
(g.vehicle, g.vehicle_good) = (None, None);
|
||||
return;
|
||||
}
|
||||
if let Some(i) = boat {
|
||||
// AbstractBoat.tick on the server for a boat its rider drives:
|
||||
// only the hurt animation and the damage wear off here.
|
||||
let b = &mut self.boats[i];
|
||||
b.hurt_time = (b.hurt_time - 1).max(0);
|
||||
b.damage = (b.damage - 1.0).max(0.0);
|
||||
}
|
||||
// Getting out goes through leave_guest, which tells the client and
|
||||
// teleports it (ServerPlayer.dismountTo).
|
||||
let seat = self.as_guest(host, conn, |game| {
|
||||
if let Some(i) = game.boats.iter().position(|b| Some(b.id) == game.riding) {
|
||||
if keys.shift {
|
||||
game.dismount(i);
|
||||
return None;
|
||||
}
|
||||
let p = game.boats[i].position;
|
||||
return Some([p.x, p.y + SEAT, p.z]);
|
||||
}
|
||||
// The minecart moves with the rider's input, and lets it out when
|
||||
// it sneaks or the cart breaks. An animal takes the rider's input
|
||||
// for its own tick (`travelRidden`), or lets it off.
|
||||
if !game.tick_cart_riding(keys) && game.tick_mount_riding(keys) {
|
||||
game.riding?;
|
||||
game.position_rider();
|
||||
}
|
||||
game.riding?;
|
||||
let p = game.player.as_ref()?.position;
|
||||
Some([p.x, p.y, p.z])
|
||||
});
|
||||
if let Some(Some(at)) = seat {
|
||||
let g = &mut host.hub.guests[gi];
|
||||
g.previous_position = g.position;
|
||||
g.position = at;
|
||||
}
|
||||
}
|
||||
|
||||
/// After an interaction: a player that got into a vehicle sits in it,
|
||||
/// and its last good vehicle position is where the vehicle is.
|
||||
pub(super) fn guest_boarded(&mut self, host: &mut LanHost, conn: u32, before: Option<u32>) {
|
||||
let Some(gi) = host.hub.guests.iter().position(|g| g.conn == conn) else {
|
||||
return;
|
||||
};
|
||||
let Some(vehicle) = host.hub.guests[gi].vehicle else {
|
||||
return;
|
||||
};
|
||||
if before == Some(vehicle) {
|
||||
return;
|
||||
}
|
||||
// The host in the window rides it already.
|
||||
if self.riding == Some(vehicle) {
|
||||
host.hub.guests[gi].vehicle = before;
|
||||
return;
|
||||
}
|
||||
let at = self
|
||||
.boats
|
||||
.iter()
|
||||
.find(|b| b.id == vehicle)
|
||||
.map(|b| b.position)
|
||||
.or_else(|| {
|
||||
self.carts
|
||||
.iter()
|
||||
.find(|c| c.id == vehicle)
|
||||
.map(|c| c.position)
|
||||
});
|
||||
if let Some(p) = at {
|
||||
let g = &mut host.hub.guests[gi];
|
||||
g.vehicle_good = Some([p.x, p.y, p.z]);
|
||||
g.previous_position = g.position;
|
||||
g.position = [p.x, p.y + SEAT, p.z];
|
||||
g.on_ground = false;
|
||||
return;
|
||||
}
|
||||
// An animal: the rider sits where `positionRider` puts it.
|
||||
let seat = self.as_guest(host, conn, |game| {
|
||||
game.position_rider();
|
||||
game.player
|
||||
.as_ref()
|
||||
.map(|p| [p.position.x, p.position.y, p.position.z])
|
||||
});
|
||||
if let Some(Some(at)) = seat {
|
||||
let g = &mut host.hub.guests[gi];
|
||||
g.previous_position = g.position;
|
||||
g.position = at;
|
||||
g.on_ground = false;
|
||||
}
|
||||
}
|
||||
|
||||
/// `ServerGamePacketListenerImpl.handleMoveVehicle`: the boat its rider
|
||||
/// drives goes where the client says, unless it moved too quickly or
|
||||
/// wrongly; then it stays, and the client is told where it is.
|
||||
pub(super) fn guest_move_vehicle(
|
||||
&mut self,
|
||||
host: &mut LanHost,
|
||||
conn: u32,
|
||||
p: &play::MoveVehicleRequest,
|
||||
) {
|
||||
let Some(gi) = host.hub.guests.iter().position(|g| g.conn == conn) else {
|
||||
return;
|
||||
};
|
||||
let [x, y, z] = p.position;
|
||||
if !(x.is_finite() && y.is_finite() && z.is_finite())
|
||||
|| !p.yaw.is_finite()
|
||||
|| !p.pitch.is_finite()
|
||||
{
|
||||
host.hub.kick(
|
||||
conn,
|
||||
translatable("multiplayer.disconnect.invalid_vehicle_movement", &[]),
|
||||
);
|
||||
return;
|
||||
}
|
||||
let g = &host.hub.guests[gi];
|
||||
if g.awaiting_teleport.is_some() || !g.loaded {
|
||||
return;
|
||||
}
|
||||
let owner = host.hub.singleplayer_owner == Some(g.uuid);
|
||||
let (vehicle, good) = (g.vehicle, g.vehicle_good);
|
||||
let back = |host: &mut LanHost, position: Vec3, yaw: f32| {
|
||||
let packet = play::MoveVehicle {
|
||||
position: [position.x, position.y, position.z],
|
||||
yaw,
|
||||
pitch: 0.0,
|
||||
};
|
||||
host.hub.send_to(conn, &C::MoveVehicle(packet));
|
||||
};
|
||||
// Only a boat is driven by its rider (getControllingPassenger); a
|
||||
// minecart that is elsewhere on the client is put back.
|
||||
let Some(i) = vehicle.and_then(|v| self.boats.iter().position(|b| b.id == v)) else {
|
||||
if let Some(c) = vehicle.and_then(|v| self.carts.iter().find(|c| c.id == v))
|
||||
&& c.position.distance_squared(Vec3::new(x, y, z)) > 1.0
|
||||
{
|
||||
back(host, c.position, c.yaw);
|
||||
}
|
||||
return;
|
||||
};
|
||||
let b = &self.boats[i];
|
||||
let old = b.position;
|
||||
let good = good.map_or(old, |g| Vec3::new(g[0], g[1], g[2]));
|
||||
let target = Vec3::new(
|
||||
x.clamp(-3.0E7, 3.0E7),
|
||||
y.clamp(-2.0E7, 2.0E7),
|
||||
z.clamp(-3.0E7, 3.0E7),
|
||||
);
|
||||
// Moved too quickly: more than 10 blocks past its own motion.
|
||||
let moved = target.distance_squared(old) - b.velocity.length_squared();
|
||||
if moved > 100.0 && !owner {
|
||||
log::warn!("boat {} moved too quickly! {moved}", b.id);
|
||||
back(host, old, b.yaw);
|
||||
return;
|
||||
}
|
||||
// vehicle.move(PLAYER, target - lastGood) with the boat's collisions:
|
||||
// where it can't follow the client (a quarter block off, the height
|
||||
// aside), it moved wrongly.
|
||||
let bounds = b.bounds();
|
||||
let mut scene = SceneCollisions {
|
||||
world: &self.world,
|
||||
binding: self.collision,
|
||||
subject: None,
|
||||
};
|
||||
let wanted = target.subtract(good);
|
||||
let resolved = scene
|
||||
.resolve(bounds, wanted, 0.0, b.on_ground)
|
||||
.unwrap_or(wanted);
|
||||
let reached = old.add_vector(resolved);
|
||||
let wrongly = (target.x - reached.x).powi(2) + (target.z - reached.z).powi(2) > 0.0625;
|
||||
let free_before = scene.unobstructed(bounds).unwrap_or(true);
|
||||
// isEntityCollidingWithAnythingNew: a box that was free is not there.
|
||||
let moved_box = bounds.move_by(target.subtract(old));
|
||||
let free_after = scene
|
||||
.unobstructed(moved_box.deflate(Vec3::new(1.0E-5, 1.0E-5, 1.0E-5)))
|
||||
.unwrap_or(true);
|
||||
if free_before && (wrongly || !free_after) {
|
||||
log::warn!("boat {} moved wrongly", b.id);
|
||||
back(host, old, b.yaw);
|
||||
return;
|
||||
}
|
||||
let b = &mut self.boats[i];
|
||||
b.previous = old;
|
||||
b.velocity = target.subtract(old);
|
||||
b.position = target;
|
||||
b.previous_yaw = b.yaw;
|
||||
b.yaw = p.yaw;
|
||||
b.on_ground = p.on_ground;
|
||||
let g = &mut host.hub.guests[gi];
|
||||
g.vehicle_good = Some([target.x, target.y, target.z]);
|
||||
g.previous_position = g.position;
|
||||
g.position = [target.x, target.y + SEAT, target.z];
|
||||
}
|
||||
|
||||
/// `handlePaddleBoat`: the paddles of the boat the player drives.
|
||||
pub(super) fn guest_paddle_boat(&mut self, host: &LanHost, conn: u32, paddles: [bool; 2]) {
|
||||
let vehicle = host
|
||||
.hub
|
||||
.guests
|
||||
.iter()
|
||||
.find(|g| g.conn == conn)
|
||||
.and_then(|g| g.vehicle);
|
||||
if let Some(b) = self.boats.iter_mut().find(|b| Some(b.id) == vehicle) {
|
||||
b.paddling = paddles;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -9,7 +9,9 @@ use horizon_client::mobs::{Damage, DamageKind, MobEvent, SpawnSetup, Species};
|
||||
use horizon_core::{position::BlockPos, random::RandomSource};
|
||||
|
||||
pub(super) struct Bolt {
|
||||
at: [f64; 3],
|
||||
/// The entity id a server's players know it by (0 until it has one).
|
||||
pub id: u32,
|
||||
pub at: [f64; 3],
|
||||
life: i32,
|
||||
flashes: i32,
|
||||
seed: i64,
|
||||
@@ -131,7 +133,9 @@ impl Game<'_> {
|
||||
let r = &mut self.world.random;
|
||||
let seed = r.next_long();
|
||||
let flashes = r.next_int_bound(3).unwrap_or(0) + 1;
|
||||
self.lightning_seen[0] += 1;
|
||||
self.bolts.push(Bolt {
|
||||
id: 0,
|
||||
at,
|
||||
life: 2,
|
||||
flashes,
|
||||
@@ -140,6 +144,24 @@ impl Game<'_> {
|
||||
converted: Vec::new(),
|
||||
});
|
||||
}
|
||||
/// `ClientLevel.addEntity` for a server's lightning bolt: on a client it
|
||||
/// only flashes, sounds and draws (`LightningBolt.tick` off the server).
|
||||
pub(super) fn spawn_remote_bolt(&mut self, id: u32, at: [f64; 3]) {
|
||||
self.bolts.retain(|b| b.id != id);
|
||||
let r = &mut self.world.random;
|
||||
let seed = r.next_long();
|
||||
let flashes = r.next_int_bound(3).unwrap_or(0) + 1;
|
||||
self.lightning_seen[0] += 1;
|
||||
self.bolts.push(Bolt {
|
||||
id,
|
||||
at,
|
||||
life: 2,
|
||||
flashes,
|
||||
seed,
|
||||
visual_only: true,
|
||||
converted: Vec::new(),
|
||||
});
|
||||
}
|
||||
/// `spawnFire`: fire at the strike point and `extra` random neighbours.
|
||||
fn bolt_fire(&mut self, at: [f64; 3], extra: i32) {
|
||||
if self.ui.difficulty < 2 {
|
||||
@@ -216,6 +238,9 @@ impl Game<'_> {
|
||||
}
|
||||
}
|
||||
if b.life >= 0 {
|
||||
if self.flash == 0 {
|
||||
self.lightning_seen[1] += 1;
|
||||
}
|
||||
self.flash = 2;
|
||||
if !b.visual_only {
|
||||
self.thunder_hit(b);
|
||||
|
||||
@@ -775,10 +775,13 @@ impl Game<'_> {
|
||||
self.push_carts();
|
||||
// ServerLevel.tick: only entities in entity-ticking chunks tick.
|
||||
let ticking = self.entity_ticking_area();
|
||||
// A server player's minecart moves with its rider (lan_vehicles.rs).
|
||||
let ridden = self.guest_vehicles();
|
||||
let mut i = 0;
|
||||
while i < self.carts.len() {
|
||||
let p = self.carts[i].position;
|
||||
if Some(self.carts[i].id) == self.riding
|
||||
|| ridden.contains(&self.carts[i].id)
|
||||
|| !ticking(p.x.floor() as i32, p.z.floor() as i32)
|
||||
{
|
||||
i += 1;
|
||||
@@ -986,7 +989,7 @@ impl Game<'_> {
|
||||
let held = self.held().cloned();
|
||||
match self.carts[i].kind {
|
||||
CartKind::Rideable => {
|
||||
if sneaking || self.riding.is_some() {
|
||||
if sneaking || self.riding.is_some() || self.ridden_by_guest(self.carts[i].id) {
|
||||
return false;
|
||||
}
|
||||
self.riding = Some(self.carts[i].id);
|
||||
|
||||
@@ -107,6 +107,10 @@ impl Game<'_> {
|
||||
let held = self.inventory[self.selected].clone();
|
||||
let m = &self.mobs[index];
|
||||
let species = m.species();
|
||||
// A server player rides it already (`isVehicle`: no seat, no feeding).
|
||||
if self.ridden_by_guest(m.id) {
|
||||
return false;
|
||||
}
|
||||
if matches!(species, Species::Pig | Species::Strider) {
|
||||
return self.interact_steerable(index, item);
|
||||
}
|
||||
@@ -246,24 +250,9 @@ impl Game<'_> {
|
||||
self.consume_held();
|
||||
true
|
||||
}
|
||||
/// The rider's input for this tick; returns false when not on a mount.
|
||||
pub(super) fn tick_mount_riding(&mut self, keys: Keys) -> bool {
|
||||
let Some(i) = self.mount_index() else {
|
||||
return false;
|
||||
};
|
||||
if keys.shift || !self.mobs[i].alive() {
|
||||
self.dismount_mount();
|
||||
return true;
|
||||
}
|
||||
let strafe = f32::from(u8::from(keys.left)) - f32::from(u8::from(keys.right));
|
||||
let forward = f32::from(u8::from(keys.forward)) - f32::from(u8::from(keys.backward));
|
||||
// LocalPlayer.aiStep: the riding jump charges while space is held.
|
||||
let held = self.held().map(|s| s.item.clone());
|
||||
let steer = match self.mobs[i].species() {
|
||||
Species::Pig => held.as_deref() == Some("minecraft:carrot_on_a_stick"),
|
||||
Species::Strider => held.as_deref() == Some("minecraft:warped_fungus_on_a_stick"),
|
||||
_ => false,
|
||||
};
|
||||
/// `LocalPlayer.aiStep`'s riding jump: the bar charges while jump is
|
||||
/// held; on release, the jump's strength (0 when there is none).
|
||||
pub(super) fn charge_mount_jump(&mut self, i: usize, keys: Keys) -> f32 {
|
||||
// PlayerRideableJumping: horses, camels and nautili (the dash).
|
||||
let saddled = self.mobs[i].extra.saddled
|
||||
&& (equine::is_equine(self.mobs[i].species())
|
||||
@@ -299,6 +288,27 @@ impl Game<'_> {
|
||||
}
|
||||
st.was_jumping = keys.jump;
|
||||
}
|
||||
jump
|
||||
}
|
||||
/// The rider's input for this tick; returns false when not on a mount.
|
||||
pub(super) fn tick_mount_riding(&mut self, keys: Keys) -> bool {
|
||||
let Some(i) = self.mount_index() else {
|
||||
return false;
|
||||
};
|
||||
if keys.shift || !self.mobs[i].alive() {
|
||||
self.dismount_mount();
|
||||
return true;
|
||||
}
|
||||
let strafe = f32::from(u8::from(keys.left)) - f32::from(u8::from(keys.right));
|
||||
let forward = f32::from(u8::from(keys.forward)) - f32::from(u8::from(keys.backward));
|
||||
// LocalPlayer.aiStep: the riding jump charges while space is held.
|
||||
let held = self.held().map(|s| s.item.clone());
|
||||
let steer = match self.mobs[i].species() {
|
||||
Species::Pig => held.as_deref() == Some("minecraft:carrot_on_a_stick"),
|
||||
Species::Strider => held.as_deref() == Some("minecraft:warped_fungus_on_a_stick"),
|
||||
_ => false,
|
||||
};
|
||||
let jump = self.charge_mount_jump(i, keys);
|
||||
let m = &mut self.mobs[i];
|
||||
if jump > 0.0 {
|
||||
// onPlayerJump: rear while jumping (horses).
|
||||
@@ -324,7 +334,7 @@ impl Game<'_> {
|
||||
pitch: self.pitch,
|
||||
jump: if jump > 0.0 { jump } else { pending },
|
||||
steer,
|
||||
sprint: self.keys.contains(&winit::keyboard::KeyCode::ControlLeft),
|
||||
sprint: keys.sprint || self.keys.contains(&winit::keyboard::KeyCode::ControlLeft),
|
||||
jumping: keys.jump,
|
||||
});
|
||||
true
|
||||
|
||||
@@ -113,7 +113,7 @@ impl Game<'_> {
|
||||
}
|
||||
|
||||
/// Where focus can land: buttons drawn last frame, every registered
|
||||
/// target (sliders, fields, rows, Horizon-style widgets), and the slots
|
||||
/// target (sliders, fields, rows, keyboard keys), and the slots
|
||||
/// and tabs of inventories (GUI pixels), on screen.
|
||||
fn pad_targets(&self) -> Vec<Target> {
|
||||
let mut targets = self.pad_all_targets();
|
||||
@@ -137,7 +137,7 @@ impl Game<'_> {
|
||||
})
|
||||
.collect();
|
||||
for t in widgets::last_targets() {
|
||||
// A Horizon button is both a labelled button and a target.
|
||||
// A button can be both a labelled button and a target.
|
||||
if let Some(same) = targets.iter_mut().find(|o| o.rect == t.rect) {
|
||||
same.kind = t.kind;
|
||||
} else {
|
||||
@@ -1026,45 +1026,13 @@ impl Game<'_> {
|
||||
}
|
||||
}
|
||||
|
||||
/// The focus highlight. Classic screens look as vanilla's keyboard focus
|
||||
/// does: buttons, sliders and slots already draw their highlighted
|
||||
/// sprite under the (hidden) pointer, and list rows and fields get
|
||||
/// vanilla's white one-pixel outline (`AbstractSelectionList`'s focused
|
||||
/// selection, `EditBox`'s highlighted border). Horizon-style screens get
|
||||
/// the design system's focus colour: a two-dp accent ring.
|
||||
/// The focus highlight, as vanilla's keyboard focus looks: buttons,
|
||||
/// sliders and slots already draw their highlighted sprite under the
|
||||
/// (hidden) pointer, and list rows and fields get vanilla's white
|
||||
/// one-pixel outline (`AbstractSelectionList`'s focused selection,
|
||||
/// `EditBox`'s highlighted border).
|
||||
fn draw_pad_focus(&self, batch: &mut HudBatch, focus: Target) {
|
||||
let [x, y, w, h] = focus.rect;
|
||||
// The options' sub-pages keep the classic layout under either style.
|
||||
let horizon = horizon_client::ui_theme::horizon()
|
||||
&& if self.screen == Screen::Options {
|
||||
self.ui.options.page() == Page::Main
|
||||
} else {
|
||||
self.title.is_some() || self.screen == Screen::Paused
|
||||
};
|
||||
if horizon {
|
||||
use horizon_client::ui_theme::{self as theme, Ui, color};
|
||||
let mut ui = Ui::new(&self.gui.atlas, batch, self.cursor);
|
||||
let k = ui.batch.scale / ui.density;
|
||||
let (x, y, w, h) = (x * k, y * k, w * k, h * k);
|
||||
let radius = match focus.kind {
|
||||
Kind::Button | Kind::Tab(_) | Kind::Slider { .. } => (h + 6.0) / 2.0,
|
||||
Kind::Field => theme::RADIUS + 3.0,
|
||||
_ => theme::RADIUS_PLATE + 3.0,
|
||||
};
|
||||
for inset in [0.0, 1.0] {
|
||||
let o = 3.0 - inset;
|
||||
ui.border(
|
||||
x - o,
|
||||
y - o,
|
||||
w + 2.0 * o,
|
||||
h + 2.0 * o,
|
||||
radius - inset,
|
||||
color::ACCENT,
|
||||
);
|
||||
}
|
||||
ui.finish();
|
||||
return;
|
||||
}
|
||||
if matches!(focus.kind, Kind::Row | Kind::Field) {
|
||||
let atlas = &self.gui.atlas;
|
||||
let white = rgba(255, 255, 255, 255);
|
||||
|
||||
@@ -93,7 +93,7 @@ pub(super) struct Remote {
|
||||
pub(super) registries: Arc<Dynamic>,
|
||||
joined: bool,
|
||||
status: String,
|
||||
entity_id: i32,
|
||||
pub(super) entity_id: i32,
|
||||
dimension: DimensionType,
|
||||
biome_map: Vec<u16>,
|
||||
biome_bits: u8,
|
||||
@@ -1367,6 +1367,10 @@ impl Game<'_> {
|
||||
self.turn_remote_projectile(id, rotation);
|
||||
}
|
||||
fn remove_entity(&mut self, id: i32) {
|
||||
// The vehicle the player rode is gone (Entity.removeVehicle).
|
||||
if self.riding == Some(id as u32) {
|
||||
self.riding = None;
|
||||
}
|
||||
self.mobs.retain(|m| m.id != id as u32);
|
||||
self.orbs.retain(|o| o.id != id as u32);
|
||||
self.dropped.retain(|d| d.id != id as u32);
|
||||
@@ -1753,6 +1757,8 @@ impl Game<'_> {
|
||||
];
|
||||
self.move_entity(p.id, position, Some((p.yaw, p.pitch)), p.on_ground);
|
||||
}
|
||||
C::SetPassengers(p) => self.remote_set_passengers(p.vehicle, &p.passengers),
|
||||
C::MoveVehicle(p) => self.remote_move_vehicle(p.position, p.yaw),
|
||||
// ClientPacketListener.handleRotateMob: lerpHeadTo(yHeadRot, 3).
|
||||
C::RotateHead(p) => {
|
||||
if let Some(r) = self.remote.as_mut() {
|
||||
@@ -2936,9 +2942,9 @@ impl Game<'_> {
|
||||
self.capture_loaded_world();
|
||||
}
|
||||
let stick = self.pad_move();
|
||||
let Some(player) = self.player.as_mut() else {
|
||||
if self.player.is_none() {
|
||||
return Ok(());
|
||||
};
|
||||
}
|
||||
let playing = self.screen == Screen::Playing;
|
||||
let held = |k| playing && self.keys.contains(&k);
|
||||
let keys = Keys {
|
||||
@@ -2959,7 +2965,14 @@ impl Game<'_> {
|
||||
| u8::from(keys.jump) << 4
|
||||
| u8::from(keys.shift) << 5
|
||||
| u8::from(keys.sprint) << 6;
|
||||
self.previous_position = player.position;
|
||||
// A passenger moves with its vehicle (Entity.rideTick), not by itself.
|
||||
let riding = self.screen != Screen::Dead && self.remote_ride(keys);
|
||||
let Some(player) = self.player.as_mut() else {
|
||||
return Ok(());
|
||||
};
|
||||
if !riding {
|
||||
self.previous_position = player.position;
|
||||
}
|
||||
let before = (
|
||||
player.ground.on_ground,
|
||||
[player.velocity.x, player.velocity.y, player.velocity.z],
|
||||
@@ -2976,7 +2989,7 @@ impl Game<'_> {
|
||||
f64::from(head[2]) + 0.5,
|
||||
);
|
||||
player.velocity = Vec3::ZERO;
|
||||
} else if !dead {
|
||||
} else if !dead && !riding {
|
||||
player.velocity = player.velocity.add_vector(pushed);
|
||||
MotionWorld {
|
||||
entities: &ghast_collisions,
|
||||
@@ -3262,6 +3275,9 @@ impl Game<'_> {
|
||||
};
|
||||
self.tick_remote_objects(&mut step);
|
||||
self.tick_remote_projectiles(&mut step);
|
||||
// LightningBolt.tick on a client, and the sky flash fading.
|
||||
self.flash = self.flash.saturating_sub(1);
|
||||
self.tick_bolts();
|
||||
}
|
||||
lerps.retain(|_, l| l.steps > 0);
|
||||
if let Some(r) = self.remote.as_mut() {
|
||||
@@ -3323,6 +3339,8 @@ impl Game<'_> {
|
||||
p.sprinting,
|
||||
);
|
||||
let (yaw, pitch, selected) = (self.yaw, self.pitch, self.selected);
|
||||
let riding = self.riding.is_some();
|
||||
let vehicle = self.remote_vehicle_packets();
|
||||
let Some(r) = self.remote.as_mut() else {
|
||||
return;
|
||||
};
|
||||
@@ -3345,9 +3363,18 @@ impl Game<'_> {
|
||||
data: 0,
|
||||
}));
|
||||
}
|
||||
if let Some(packet) = r
|
||||
.position_sender
|
||||
.update(pos, (yaw, pitch), on_ground, collision)
|
||||
if riding {
|
||||
// LocalPlayer.tick: a passenger sends its look, then the vehicle
|
||||
// it controls.
|
||||
out.push(S::MovePlayerRot(play::MovePlayerRot {
|
||||
yaw,
|
||||
pitch,
|
||||
flags: u8::from(on_ground) | u8::from(collision) << 1,
|
||||
}));
|
||||
out.extend(vehicle);
|
||||
} else if let Some(packet) =
|
||||
r.position_sender
|
||||
.update(pos, (yaw, pitch), on_ground, collision)
|
||||
{
|
||||
out.push(packet);
|
||||
}
|
||||
@@ -3578,6 +3605,21 @@ impl Game<'_> {
|
||||
|
||||
fn remote_use_entity(&mut self) -> bool {
|
||||
let sneaking = self.keys.contains(&KeyCode::ShiftLeft);
|
||||
// A boat, minecart, item frame, armor stand or painting nearer than
|
||||
// any mob: the server uses it (AbstractBoat.interact boards it).
|
||||
if let Some(hit) = self.remote_object_hit()
|
||||
&& self.mob_hit().is_none_or(|(_, d)| hit.distance < d)
|
||||
&& self.before_block(hit.distance)
|
||||
{
|
||||
self.send(S::Interact(play::Interact {
|
||||
id: hit.id,
|
||||
hand: 0,
|
||||
location: hit.location,
|
||||
secondary: sneaking,
|
||||
}));
|
||||
self.swing_arm();
|
||||
return true;
|
||||
}
|
||||
if let Some((i, distance)) = self.mob_hit()
|
||||
&& self.before_block(distance)
|
||||
{
|
||||
@@ -3957,6 +3999,14 @@ impl Game<'_> {
|
||||
id: self.creatures.projectiles[i].id as i32,
|
||||
}));
|
||||
self.reset_attack_strength();
|
||||
} else if let Some(hit) = self.remote_object_hit()
|
||||
&& self.mob_hit().is_none_or(|(_, d)| hit.distance < d)
|
||||
&& self.before_block(hit.distance)
|
||||
{
|
||||
// VehicleEntity.hurtServer, ItemFrame and ArmorStand hurtServer,
|
||||
// a painting broken: the server decides.
|
||||
self.send(S::Attack(play::Attack { id: hit.id }));
|
||||
self.reset_attack_strength();
|
||||
} else if let Some((i, distance)) = self.mob_hit()
|
||||
&& self.before_block(distance)
|
||||
{
|
||||
|
||||
@@ -52,6 +52,8 @@ impl Game<'_> {
|
||||
invisible: false,
|
||||
check_interval: 0,
|
||||
});
|
||||
} else if kind == "minecraft:lightning_bolt" {
|
||||
self.spawn_remote_bolt(id, position);
|
||||
} else if kind == "minecraft:painting" {
|
||||
// The variant comes with the entity data; until then the
|
||||
// registry's first one (VariantUtils.getAny).
|
||||
@@ -188,7 +190,12 @@ impl Game<'_> {
|
||||
/// A move's rotation and ground state for an object.
|
||||
pub(super) fn turn_remote_object(&mut self, id: i32, yaw: Option<f32>, on_ground: bool) {
|
||||
let id = id as u32;
|
||||
// The boat the player drives turns here (isLocalInstanceAuthoritative).
|
||||
let driven = self.riding;
|
||||
if let Some(b) = self.boats.iter_mut().find(|b| b.id == id) {
|
||||
if Some(id) == driven {
|
||||
return;
|
||||
}
|
||||
if let Some(yaw) = yaw {
|
||||
b.yaw = yaw;
|
||||
}
|
||||
@@ -213,7 +220,12 @@ impl Game<'_> {
|
||||
c.previous_yaw = c.yaw;
|
||||
c.position = step(c.id, c.position);
|
||||
}
|
||||
// The boat the player drives moves here, not where the server says.
|
||||
let driven = self.riding;
|
||||
for b in &mut self.boats {
|
||||
if Some(b.id) == driven {
|
||||
continue;
|
||||
}
|
||||
b.previous = b.position;
|
||||
b.previous_yaw = b.yaw;
|
||||
b.position = step(b.id, b.position);
|
||||
@@ -274,5 +286,6 @@ impl Game<'_> {
|
||||
self.armor_stands.retain(|a| a.id != id);
|
||||
self.item_frames.retain(|f| f.id != id);
|
||||
self.paintings.retain(|p| p.id != id);
|
||||
self.bolts.retain(|b| b.id != id);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,189 @@
|
||||
//! Boats, minecarts, item frames, armor stands and paintings for a server's
|
||||
//! client: single player on its server thread, a LAN guest, a player on a
|
||||
//! dedicated server.
|
||||
//!
|
||||
//! The client aims at them like at mobs (`Minecraft.hitResult`, then
|
||||
//! `ServerboundInteractPacket`), and rides the vehicle the server seats it in
|
||||
//! (`ClientPacketListener.handleSetEntityPassengersPacket`). A boat is
|
||||
//! controlled by its rider's client: it ticks here and its moves go to the
|
||||
//! server (`LocalPlayer.tick`: `ServerboundMoveVehiclePacket`,
|
||||
//! `AbstractBoat.tick`: `ServerboundPaddleBoatPacket`). A minecart moves on
|
||||
//! the server with the rider's input, and the rider sits in it.
|
||||
use super::{Game, Keys, view_vector};
|
||||
use horizon_core::geometry::Vec3;
|
||||
use horizon_protocol::packets::play::{self, Serverbound as S};
|
||||
|
||||
/// An object under the crosshair: its entity id, how far along the view it
|
||||
/// was hit, and where (`EntityHitResult.getLocation` minus the entity's
|
||||
/// position, the interact packet's location).
|
||||
pub(super) struct ObjectHit {
|
||||
pub id: i32,
|
||||
pub distance: f64,
|
||||
pub location: [f64; 3],
|
||||
}
|
||||
|
||||
impl Game<'_> {
|
||||
/// The nearest boat, minecart, item frame, armor stand or painting the
|
||||
/// view hits within reach.
|
||||
pub(super) fn remote_object_hit(&self) -> Option<ObjectHit> {
|
||||
let eye = self.eye_position()?;
|
||||
let dir = view_vector(self.yaw, self.pitch);
|
||||
let at = |d: f64| {
|
||||
[
|
||||
eye[0] + dir[0] * d,
|
||||
eye[1] + dir[1] * d,
|
||||
eye[2] + dir[2] * d,
|
||||
]
|
||||
};
|
||||
let block_centre = |p: [i32; 3]| {
|
||||
[
|
||||
f64::from(p[0]) + 0.5,
|
||||
f64::from(p[1]) + 0.5,
|
||||
f64::from(p[2]) + 0.5,
|
||||
]
|
||||
};
|
||||
let mut hits: Vec<(i32, f64, [f64; 3])> = Vec::new();
|
||||
if let Some((i, d)) = self.painting_hit() {
|
||||
let p = &self.paintings[i];
|
||||
hits.push((p.id as i32, d, block_centre(p.pos)));
|
||||
}
|
||||
if let Some((i, d)) = self.frame_hit() {
|
||||
let f = &self.item_frames[i];
|
||||
hits.push((f.id as i32, d, block_centre(f.pos)));
|
||||
}
|
||||
if let Some((i, d, _)) = self.armor_stand_hit() {
|
||||
let a = &self.armor_stands[i];
|
||||
let p = a.position;
|
||||
hits.push((a.id as i32, d, [p.x, p.y, p.z]));
|
||||
}
|
||||
if let Some((i, d)) = self.boat_hit() {
|
||||
let p = self.boats[i].position;
|
||||
hits.push((self.boats[i].id as i32, d, [p.x, p.y, p.z]));
|
||||
}
|
||||
if let Some((i, d)) = self.cart_hit() {
|
||||
let p = self.carts[i].position;
|
||||
hits.push((self.carts[i].id as i32, d, [p.x, p.y, p.z]));
|
||||
}
|
||||
let (id, distance, origin) = hits.into_iter().min_by(|a, b| a.1.total_cmp(&b.1))?;
|
||||
let point = at(distance);
|
||||
Some(ObjectHit {
|
||||
id,
|
||||
distance,
|
||||
location: [
|
||||
point[0] - origin[0],
|
||||
point[1] - origin[1],
|
||||
point[2] - origin[2],
|
||||
],
|
||||
})
|
||||
}
|
||||
|
||||
/// `ClientPacketListener.handleSetEntityPassengersPacket`: who rides
|
||||
/// `vehicle` now. The local player gets in or out; mobs and other
|
||||
/// players sit where the server keeps them.
|
||||
pub(super) fn remote_set_passengers(&mut self, vehicle: i32, passengers: &[i32]) {
|
||||
let Some(me) = self.remote.as_ref().map(|r| r.entity_id) else {
|
||||
return;
|
||||
};
|
||||
let vehicle_id = vehicle as u32;
|
||||
for m in &mut self.mobs {
|
||||
if m.extra.mount == Some(vehicle_id) && !passengers.contains(&(m.id as i32)) {
|
||||
m.extra.mount = None;
|
||||
} else if passengers.contains(&(m.id as i32)) {
|
||||
m.extra.mount = Some(vehicle_id);
|
||||
}
|
||||
}
|
||||
if passengers.contains(&me) {
|
||||
if self.riding != Some(vehicle_id) {
|
||||
self.riding = Some(vehicle_id);
|
||||
if let Some(p) = self.player.as_mut() {
|
||||
p.velocity = Vec3::ZERO;
|
||||
p.fall_distance = 0.0;
|
||||
}
|
||||
}
|
||||
} else if self.riding == Some(vehicle_id) {
|
||||
// The server takes the player out, then teleports it.
|
||||
self.riding = None;
|
||||
}
|
||||
}
|
||||
|
||||
/// The local player's tick in its vehicle, in place of its own movement:
|
||||
/// false when it rides nothing.
|
||||
pub(super) fn remote_ride(&mut self, keys: Keys) -> bool {
|
||||
let Some(id) = self.riding else {
|
||||
return false;
|
||||
};
|
||||
if let Some(i) = self.mobs.iter().position(|m| m.id == id) {
|
||||
// An animal moves on the server with the rider's input
|
||||
// (PlayerInput); here the jump bar charges for the HUD and the
|
||||
// rider sits where `positionRider` puts it.
|
||||
self.charge_mount_jump(i, keys);
|
||||
self.position_rider();
|
||||
return true;
|
||||
}
|
||||
let seat = if let Some(i) = self.boats.iter().position(|b| b.id == id) {
|
||||
// AbstractBoat.tick on the controlling client: steer and move.
|
||||
let mut b = self.boats[i].clone();
|
||||
b.input = [keys.left, keys.right, keys.forward, keys.backward];
|
||||
let b = self.tick_boat(b, true);
|
||||
// positionRider: the seat turns with the boat; clampRotation.
|
||||
self.yaw += b.delta_rotation;
|
||||
let delta = (self.yaw - b.yaw + 180.0).rem_euclid(360.0) - 180.0;
|
||||
self.yaw += delta.clamp(-105.0, 105.0) - delta;
|
||||
let seat = b.position;
|
||||
self.boats[i] = b;
|
||||
Some(seat)
|
||||
} else {
|
||||
// A minecart: the server moves it, the rider sits in it.
|
||||
self.carts.iter().find(|c| c.id == id).map(|c| c.position)
|
||||
};
|
||||
if let Some(p) = self.player.as_mut() {
|
||||
self.previous_position = p.position;
|
||||
if let Some(v) = seat {
|
||||
p.position = Vec3::new(v.x, v.y + super::boats::SEAT, v.z);
|
||||
}
|
||||
p.velocity = Vec3::ZERO;
|
||||
p.fall_distance = 0.0;
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
/// `LocalPlayer.tick` for a passenger: the boat it controls goes to the
|
||||
/// server every tick with its paddles (the rider's own position does not).
|
||||
pub(super) fn remote_vehicle_packets(&self) -> Vec<S> {
|
||||
let Some(b) = self
|
||||
.riding
|
||||
.and_then(|id| self.boats.iter().find(|b| b.id == id))
|
||||
else {
|
||||
return Vec::new();
|
||||
};
|
||||
vec![
|
||||
S::MoveVehicle(play::MoveVehicleRequest {
|
||||
position: [b.position.x, b.position.y, b.position.z],
|
||||
yaw: b.yaw,
|
||||
pitch: 0.0,
|
||||
on_ground: b.on_ground,
|
||||
}),
|
||||
S::PaddleBoat(play::PaddleBoat {
|
||||
left: b.paddling[0],
|
||||
right: b.paddling[1],
|
||||
}),
|
||||
]
|
||||
}
|
||||
|
||||
/// `ClientPacketListener.handleMoveVehicle`: the server put the boat the
|
||||
/// player drives back.
|
||||
pub(super) fn remote_move_vehicle(&mut self, position: [f64; 3], yaw: f32) {
|
||||
let Some(b) = self
|
||||
.riding
|
||||
.and_then(|id| self.boats.iter_mut().find(|b| b.id == id))
|
||||
else {
|
||||
return;
|
||||
};
|
||||
let at = Vec3::new(position[0], position[1], position[2]);
|
||||
b.previous = at;
|
||||
b.position = at;
|
||||
b.yaw = yaw;
|
||||
b.previous_yaw = yaw;
|
||||
b.velocity = Vec3::ZERO;
|
||||
}
|
||||
}
|
||||
@@ -13,7 +13,11 @@ impl Screen {
|
||||
pub(super) fn blurs_background(self, pause_menu: bool) -> bool {
|
||||
match self {
|
||||
Self::Paused => pause_menu,
|
||||
Self::Options | Self::Stats | Self::Advancements | Self::WorldOptions => true,
|
||||
Self::Options
|
||||
| Self::Stats
|
||||
| Self::Advancements
|
||||
| Self::WorldOptions
|
||||
| Self::Friends => true,
|
||||
Self::Playing
|
||||
| Self::GameModeSwitcher
|
||||
| Self::Chat
|
||||
@@ -64,6 +68,9 @@ fn pause_buttons(w: f32, h: f32, remote: bool) -> Vec<(f32, f32, f32, &'static s
|
||||
}
|
||||
|
||||
/// The icon row: report bugs, feedback, friends, player reporting.
|
||||
/// `FRIENDS_ICON` (vanilla's `CommonButtons.friends`) opens Horizon's
|
||||
/// Play with Friends; the others stay inactive.
|
||||
const FRIENDS_ICON: usize = 2;
|
||||
fn pause_icons(w: f32, h: f32) -> [(f32, f32, &'static str); 4] {
|
||||
let x0 = ((w - 212.0) * 0.5).floor() + 60.0;
|
||||
let y = ((h - 166.0) * 0.25).floor() + 98.0;
|
||||
@@ -90,41 +97,8 @@ impl Game<'_> {
|
||||
pub(super) fn external_server(&self) -> bool {
|
||||
self.remote.is_some() && self.integrated.is_none()
|
||||
}
|
||||
/// Whether the pause menu is drawn in Horizon's style (over a blurred world).
|
||||
pub(super) fn horizon_pause(&self) -> bool {
|
||||
self.screen == Screen::Paused
|
||||
&& self.pause_menu
|
||||
&& self.title.is_none()
|
||||
&& horizon_client::ui_theme::horizon()
|
||||
}
|
||||
fn pause_labels(&self) -> (String, &'static str) {
|
||||
if let Some(server) = &self.integrated {
|
||||
return (server.world_name.clone(), "Save and quit");
|
||||
}
|
||||
if self.external_server() {
|
||||
("Multiplayer".to_owned(), "Disconnect")
|
||||
} else {
|
||||
(self.level.name.clone(), "Save and quit")
|
||||
}
|
||||
}
|
||||
pub(super) fn draw_pause_menu(&mut self, batch: &mut HudBatch) {
|
||||
if horizon_client::ui_theme::horizon() {
|
||||
let opened = *self.pause_since.get_or_insert_with(std::time::Instant::now);
|
||||
let (world, quit) = self.pause_labels();
|
||||
self.tick_friends();
|
||||
let friends = self.friends_view();
|
||||
let mut ui = horizon_client::ui_theme::Ui::new(&self.gui.atlas, batch, self.cursor);
|
||||
horizon_client::front::pause::draw(
|
||||
&mut ui,
|
||||
&world,
|
||||
quit,
|
||||
opened,
|
||||
&friends,
|
||||
self.external_server(),
|
||||
);
|
||||
ui.finish();
|
||||
return;
|
||||
}
|
||||
let friends = self.friends_view().shown;
|
||||
let atlas = &self.gui.atlas;
|
||||
let (w, h) = (batch.width, batch.height);
|
||||
ui::menu_background(batch, atlas, 0.0, 0.0, w, h, true);
|
||||
@@ -152,12 +126,41 @@ impl Game<'_> {
|
||||
hover,
|
||||
);
|
||||
}
|
||||
for (x, y, sprite) in pause_icons(w, h) {
|
||||
ui::button(batch, atlas, x, y, 20.0, 20.0, &Text::empty(), false, false);
|
||||
let mut tooltip = None;
|
||||
for (i, (x, y, sprite)) in pause_icons(w, h).into_iter().enumerate() {
|
||||
let active = i == FRIENDS_ICON && friends;
|
||||
let hover = ui::hovered(self.cursor, x, y, 20.0, 20.0);
|
||||
// The icon has no label: name it for controller focus and the
|
||||
// control socket's widget tree.
|
||||
if i == FRIENDS_ICON {
|
||||
horizon_client::widgets::record(
|
||||
horizon_client::friends_screen::TITLE,
|
||||
[x, y, 20.0, 20.0],
|
||||
active,
|
||||
);
|
||||
}
|
||||
ui::button(
|
||||
batch,
|
||||
atlas,
|
||||
x,
|
||||
y,
|
||||
20.0,
|
||||
20.0,
|
||||
&Text::empty(),
|
||||
active,
|
||||
active && hover,
|
||||
);
|
||||
// SpriteIconButton.CenteredIcon: the 15x15 sprite at
|
||||
// x + width / 2 - 15 / 2 in integer pixels, untinted even
|
||||
// when the button is inactive.
|
||||
batch.sprite_scaled(atlas, sprite, x + 3.0, y + 3.0, 15.0, 15.0, u32::MAX);
|
||||
if i == FRIENDS_ICON && hover {
|
||||
tooltip = Some(Text::literal(horizon_client::friends_screen::TITLE));
|
||||
}
|
||||
}
|
||||
// SpriteIconButton.withTootip: the label as a tooltip.
|
||||
if let Some(tip) = tooltip {
|
||||
ui::tooltip(batch, atlas, &[tip], self.cursor);
|
||||
}
|
||||
}
|
||||
pub(super) fn pause_click(&mut self) -> Result<()> {
|
||||
@@ -169,29 +172,16 @@ impl Game<'_> {
|
||||
let b = HudBatch::new(size);
|
||||
(b.width, b.height)
|
||||
};
|
||||
let hit = if horizon_client::ui_theme::horizon() {
|
||||
let size = self
|
||||
.renderer
|
||||
.as_ref()
|
||||
.map_or([1, 1], |r| [r.config.width, r.config.height]);
|
||||
let mut b = HudBatch::new(size);
|
||||
let (world, quit) = self.pause_labels();
|
||||
horizon_client::front::pause::click(
|
||||
&self.gui.atlas,
|
||||
&mut b,
|
||||
self.cursor.0,
|
||||
self.cursor.1,
|
||||
&world,
|
||||
quit,
|
||||
&self.friends_view(),
|
||||
self.external_server(),
|
||||
)
|
||||
} else {
|
||||
pause_buttons(w, h, self.external_server())
|
||||
.into_iter()
|
||||
.find(|b| b.5 && ui::hovered(self.cursor, b.0, b.1, b.2, 20.0))
|
||||
.map(|b| b.4)
|
||||
};
|
||||
let friends = pause_icons(w, h)[FRIENDS_ICON];
|
||||
let hit = pause_buttons(w, h, self.external_server())
|
||||
.into_iter()
|
||||
.find(|b| b.5 && ui::hovered(self.cursor, b.0, b.1, b.2, 20.0))
|
||||
.map(|b| b.4)
|
||||
.or_else(|| {
|
||||
(self.friends_view().shown
|
||||
&& ui::hovered(self.cursor, friends.0, friends.1, 20.0, 20.0))
|
||||
.then_some(10)
|
||||
});
|
||||
match hit {
|
||||
Some(0) => {
|
||||
self.screen = Screen::Playing;
|
||||
@@ -201,17 +191,11 @@ impl Game<'_> {
|
||||
Some(3) => self.open_stats(),
|
||||
Some(4) => self.open_advancements(true),
|
||||
Some(9) => self.open_world_options(),
|
||||
Some(10) => {
|
||||
if let Err(e) = self.friends_start() {
|
||||
self.system_message(Text::literal(format!("Couldn't share the world: {e}")));
|
||||
}
|
||||
}
|
||||
Some(11) => self.friends_copy(),
|
||||
Some(12) => self.friends_stop(),
|
||||
Some(10) => self.screen = Screen::Friends,
|
||||
Some(2) => self.close_world()?,
|
||||
_ => {}
|
||||
}
|
||||
if hit.is_some() && !horizon_client::ui_theme::horizon() {
|
||||
if hit.is_some() {
|
||||
self.audio.play_button_click();
|
||||
}
|
||||
Ok(())
|
||||
|
||||
@@ -75,11 +75,6 @@ impl StartupMenu {
|
||||
&self.root,
|
||||
);
|
||||
title.last_server = settings.file.string("lastServer");
|
||||
if horizon_client::ui_theme::horizon() {
|
||||
title
|
||||
.opening
|
||||
.set(Some(horizon_client::front::Opening::new()));
|
||||
}
|
||||
self.title = Some(title);
|
||||
}
|
||||
}
|
||||
@@ -154,9 +149,6 @@ impl StartupMenu {
|
||||
fn title_key(&mut self, event: &KeyEvent) {
|
||||
let shortcut = self.shortcut(event);
|
||||
let Some(title) = &mut self.title else { return };
|
||||
if title.skip_opening() {
|
||||
return;
|
||||
}
|
||||
if let Some(shortcut) = shortcut {
|
||||
if title.has_caret_field() {
|
||||
title.field_shortcut(shortcut, &mut self.clipboard);
|
||||
@@ -439,14 +431,6 @@ impl Loading {
|
||||
event_loop: &ActiveEventLoop,
|
||||
event: WindowEvent,
|
||||
) -> Result<()> {
|
||||
if let WindowEvent::MouseInput {
|
||||
state,
|
||||
button: MouseButton::Left,
|
||||
..
|
||||
} = &event
|
||||
{
|
||||
horizon_client::ui_theme::set_pressed(*state == ElementState::Pressed);
|
||||
}
|
||||
if let WindowEvent::KeyboardInput { event, .. } = &event
|
||||
&& let PhysicalKey::Code(key) = event.physical_key
|
||||
{
|
||||
@@ -472,7 +456,6 @@ impl Loading {
|
||||
WindowEvent::Focused(false) => {
|
||||
self.menu.modifiers = ModifiersState::empty();
|
||||
self.menu.physical_keys.clear();
|
||||
horizon_client::ui_theme::set_pressed(false);
|
||||
self.menu.dragging = false;
|
||||
if let Some(title) = &mut self.menu.title {
|
||||
title.release();
|
||||
@@ -539,41 +522,23 @@ impl Loading {
|
||||
button: MouseButton::Left,
|
||||
..
|
||||
} => {
|
||||
let mut batch = HudBatch::new(self.menu_size());
|
||||
let batch = HudBatch::new(self.menu_size());
|
||||
if let (Some(title), Some(gui)) = (&mut self.menu.title, &self.gui) {
|
||||
if state == ElementState::Released {
|
||||
title.release();
|
||||
title.release_field();
|
||||
} else {
|
||||
let action = if horizon_client::ui_theme::horizon() {
|
||||
let action = title.click_horizon(
|
||||
&gui.atlas,
|
||||
&mut batch,
|
||||
self.menu.cursor.0,
|
||||
self.menu.cursor.1,
|
||||
);
|
||||
// Horizon's deeper world-management pages use classic fields.
|
||||
title.press_field(
|
||||
&gui.atlas,
|
||||
self.menu.cursor,
|
||||
(batch.width, batch.height),
|
||||
self.menu.modifiers.shift_key(),
|
||||
);
|
||||
action
|
||||
} else {
|
||||
let (action, _) = title.click(
|
||||
self.menu.cursor.0,
|
||||
self.menu.cursor.1,
|
||||
(batch.width, batch.height),
|
||||
);
|
||||
title.press_field(
|
||||
&gui.atlas,
|
||||
self.menu.cursor,
|
||||
(batch.width, batch.height),
|
||||
self.menu.modifiers.shift_key(),
|
||||
);
|
||||
action
|
||||
};
|
||||
let (action, _) = title.click(
|
||||
self.menu.cursor.0,
|
||||
self.menu.cursor.1,
|
||||
(batch.width, batch.height),
|
||||
);
|
||||
title.press_field(
|
||||
&gui.atlas,
|
||||
self.menu.cursor,
|
||||
(batch.width, batch.height),
|
||||
self.menu.modifiers.shift_key(),
|
||||
);
|
||||
self.menu_action(event_loop, action);
|
||||
}
|
||||
}
|
||||
@@ -657,18 +622,12 @@ impl Loading {
|
||||
} else if let Some(title) = &mut self.menu.title {
|
||||
title.poll_backup();
|
||||
let _ = title.update_toast(self.settings.notification_display_time);
|
||||
if horizon_client::ui_theme::horizon() {
|
||||
let mut ui = horizon_client::ui_theme::Ui::new(&gui.atlas, batch, self.menu.cursor);
|
||||
title.draw_horizon(&mut ui, 0.0);
|
||||
ui.finish();
|
||||
} else {
|
||||
title.draw(
|
||||
&gui.atlas,
|
||||
batch,
|
||||
self.menu.cursor,
|
||||
self.settings.file.bool("hideSplashTexts"),
|
||||
);
|
||||
}
|
||||
title.draw(
|
||||
&gui.atlas,
|
||||
batch,
|
||||
self.menu.cursor,
|
||||
self.settings.file.bool("hideSplashTexts"),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -770,7 +729,6 @@ mod tests {
|
||||
// Navigate and enter a world name without a registry, biomes, pack
|
||||
// tables or a Game. Replacing fallback artwork preserves this state.
|
||||
let title = loading.menu.title.as_mut().unwrap();
|
||||
title.opening.set(None);
|
||||
title.mode = horizon_client::title::Mode::Create {
|
||||
name: String::new(),
|
||||
seed: "42".into(),
|
||||
|
||||
@@ -33,6 +33,7 @@ fn entity_shader() -> String {
|
||||
}
|
||||
|
||||
mod entity_batch;
|
||||
mod weather;
|
||||
use entity_batch::EntityBatch;
|
||||
pub use entity_batch::WATER_MASK_OVERLAY;
|
||||
|
||||
@@ -193,6 +194,8 @@ pub struct Frame<'a> {
|
||||
pub nether_lighting: bool,
|
||||
/// Camera-relative entity geometry textured from the shared atlas.
|
||||
pub entities: &'a [Vertex],
|
||||
pub weather: &'a [crate::weather::Vertex],
|
||||
pub weather_time: crate::weather::Time,
|
||||
/// Horizon Extras' dynamic lights, nearest first (`dynamic_light::select`); empty when off.
|
||||
pub dynamic_lights: &'a [[f32; 4]],
|
||||
/// Cloud mesh inputs; geometry and GPU storage are retained by the renderer.
|
||||
@@ -236,8 +239,6 @@ pub struct Frame<'a> {
|
||||
pub night_vision: f32,
|
||||
/// Torch flicker added to the block light factor of 1.4.
|
||||
pub block_flicker: f32,
|
||||
/// Blur and grade the frame under a Horizon-style menu (`post`).
|
||||
pub post: Option<crate::post::PostGrade>,
|
||||
/// `Screen.extractBlurredBackground`: blur the frame by this radius
|
||||
/// (`menuBackgroundBlurriness`) before the screen is drawn over it.
|
||||
pub menu_blur: Option<f32>,
|
||||
@@ -330,6 +331,7 @@ pub struct Renderer {
|
||||
crosshair_group: wgpu::BindGroup,
|
||||
crosshair_globals: wgpu::Buffer,
|
||||
entity_pipeline: wgpu::RenderPipeline,
|
||||
weather: weather::Weather,
|
||||
crumbling_pipeline: wgpu::RenderPipeline,
|
||||
/// `RenderPipelines.WATER_MASK`: depth writes only, no colour.
|
||||
water_mask_pipeline: wgpu::RenderPipeline,
|
||||
@@ -446,8 +448,6 @@ pub struct Renderer {
|
||||
/// The selected shader pack's stages (Horizon setting; none by default).
|
||||
pack: Option<Pack>,
|
||||
pub hud: HudRenderer,
|
||||
/// The menus' backdrop blur, made on first use.
|
||||
post: Option<crate::post::Post>,
|
||||
/// Vanilla's menu background blur, made on first use.
|
||||
menu_blur: Option<crate::menu_blur::MenuBlur>,
|
||||
pub info: wgpu::AdapterInfo,
|
||||
@@ -1454,6 +1454,12 @@ impl Renderer {
|
||||
),
|
||||
],
|
||||
});
|
||||
let weather = weather::Weather::new(
|
||||
&device,
|
||||
config.format.remove_srgb_suffix(),
|
||||
&entity_bindings,
|
||||
&entity_shader,
|
||||
);
|
||||
let atlas_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
|
||||
label: Some("Atlas"),
|
||||
..Default::default()
|
||||
@@ -2129,6 +2135,7 @@ impl Renderer {
|
||||
crosshair_group,
|
||||
crosshair_globals,
|
||||
entity_pipeline,
|
||||
weather,
|
||||
crumbling_pipeline,
|
||||
water_mask_pipeline,
|
||||
cloud_pipeline,
|
||||
@@ -2212,7 +2219,6 @@ impl Renderer {
|
||||
world_post,
|
||||
pack: None,
|
||||
hud,
|
||||
post: None,
|
||||
menu_blur: None,
|
||||
info,
|
||||
suspended: size.width == 0 || size.height == 0,
|
||||
@@ -3260,6 +3266,13 @@ impl Renderer {
|
||||
bytemuck::cast_slice(&all),
|
||||
);
|
||||
}
|
||||
self.weather.prepare(
|
||||
&self.device,
|
||||
&mut encoder,
|
||||
&mut self.uploads,
|
||||
frame.weather,
|
||||
frame.weather_time,
|
||||
);
|
||||
let outline_edges = frame.outline.len().min(MAX_OUTLINE_EDGES as usize);
|
||||
if outline_edges > 0 {
|
||||
let lines = outline_vertices(&frame.outline[..outline_edges], camera);
|
||||
@@ -3277,6 +3290,7 @@ impl Renderer {
|
||||
frame.hand,
|
||||
frame.see_through,
|
||||
);
|
||||
let weather_quads = frame.weather.len() as u32 / 4;
|
||||
let world_quads =
|
||||
entity_quads + crumbling_quads + translucent_crumbling_quads + water_mask_quads;
|
||||
let cloud_quads = if let Some(input) = &frame.clouds {
|
||||
@@ -3365,7 +3379,8 @@ impl Renderer {
|
||||
0
|
||||
} else {
|
||||
lightning::QUADS
|
||||
});
|
||||
})
|
||||
.max(weather_quads);
|
||||
if max_quads > self.index_quads {
|
||||
self.index_quads = max_quads.next_power_of_two();
|
||||
self.indices = Self::quad_indices(&self.device, self.index_quads);
|
||||
@@ -3653,6 +3668,8 @@ 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);
|
||||
pass.set_bind_group(0, &self.group, &[]);
|
||||
if crumbling_quads > 0 {
|
||||
pass.set_pipeline(&self.crumbling_pipeline);
|
||||
pass.set_bind_group(0, &self.entity_group, &[]);
|
||||
@@ -3925,23 +3942,6 @@ impl Renderer {
|
||||
radius,
|
||||
);
|
||||
}
|
||||
if let Some(grade) = &frame.post
|
||||
&& self.config.usage.contains(wgpu::TextureUsages::COPY_SRC)
|
||||
{
|
||||
let format = self.config.format;
|
||||
let device = &self.device;
|
||||
self.post
|
||||
.get_or_insert_with(|| crate::post::Post::new(device, format))
|
||||
.apply(
|
||||
&self.device,
|
||||
&self.queue,
|
||||
&mut encoder,
|
||||
&target_texture,
|
||||
&view_target,
|
||||
[self.config.width, self.config.height],
|
||||
grade,
|
||||
);
|
||||
}
|
||||
self.hud.draw_range(
|
||||
&mut encoder,
|
||||
&view_target,
|
||||
|
||||
@@ -0,0 +1,330 @@
|
||||
//! Weather's unsplit quads, using the entity atlas/lightmap resources.
|
||||
use crate::weather::{Time, Vertex};
|
||||
|
||||
pub(super) struct Weather {
|
||||
pipeline: wgpu::RenderPipeline,
|
||||
group: wgpu::BindGroup,
|
||||
uniform: wgpu::Buffer,
|
||||
vertices: wgpu::Buffer,
|
||||
capacity: usize,
|
||||
count: u32,
|
||||
}
|
||||
impl Weather {
|
||||
pub fn new(
|
||||
device: &wgpu::Device,
|
||||
format: wgpu::TextureFormat,
|
||||
entities: &wgpu::BindGroupLayout,
|
||||
shader: &wgpu::ShaderModule,
|
||||
) -> Self {
|
||||
let bindings = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||||
label: Some("Weather time"),
|
||||
entries: &[wgpu::BindGroupLayoutEntry {
|
||||
binding: 1,
|
||||
visibility: wgpu::ShaderStages::VERTEX,
|
||||
ty: wgpu::BindingType::Buffer {
|
||||
ty: wgpu::BufferBindingType::Uniform,
|
||||
has_dynamic_offset: false,
|
||||
min_binding_size: None,
|
||||
},
|
||||
count: None,
|
||||
}],
|
||||
});
|
||||
let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
||||
label: Some("Weather layout"),
|
||||
bind_group_layouts: &[Some(entities), Some(&bindings)],
|
||||
..Default::default()
|
||||
});
|
||||
let attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Float32x4,
|
||||
3=>Float32x4,4=>Uint32x4,5=>Unorm8x4,6=>Uint8x4,7=>Uint32];
|
||||
let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
|
||||
label: Some("Weather"),
|
||||
layout: Some(&layout),
|
||||
vertex: wgpu::VertexState {
|
||||
module: shader,
|
||||
entry_point: Some("vs_weather"),
|
||||
compilation_options: Default::default(),
|
||||
buffers: &[Some(wgpu::VertexBufferLayout {
|
||||
array_stride: std::mem::size_of::<Vertex>() as u64,
|
||||
step_mode: wgpu::VertexStepMode::Vertex,
|
||||
attributes: &attributes,
|
||||
})],
|
||||
},
|
||||
primitive: wgpu::PrimitiveState {
|
||||
topology: wgpu::PrimitiveTopology::TriangleList,
|
||||
..Default::default()
|
||||
},
|
||||
depth_stencil: Some(wgpu::DepthStencilState {
|
||||
format: wgpu::TextureFormat::Depth32Float,
|
||||
depth_write_enabled: Some(true),
|
||||
depth_compare: Some(wgpu::CompareFunction::GreaterEqual),
|
||||
stencil: Default::default(),
|
||||
bias: Default::default(),
|
||||
}),
|
||||
multisample: Default::default(),
|
||||
fragment: Some(wgpu::FragmentState {
|
||||
module: shader,
|
||||
entry_point: Some("fs_weather"),
|
||||
compilation_options: Default::default(),
|
||||
targets: &[Some(wgpu::ColorTargetState {
|
||||
format,
|
||||
blend: Some(wgpu::BlendState::ALPHA_BLENDING),
|
||||
write_mask: wgpu::ColorWrites::ALL,
|
||||
})],
|
||||
}),
|
||||
multiview_mask: None,
|
||||
cache: None,
|
||||
});
|
||||
let uniform = device.create_buffer(&wgpu::BufferDescriptor {
|
||||
label: Some("Weather time"),
|
||||
size: 16,
|
||||
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
|
||||
mapped_at_creation: false,
|
||||
});
|
||||
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
|
||||
label: Some("Weather time"),
|
||||
layout: &bindings,
|
||||
entries: &[wgpu::BindGroupEntry {
|
||||
binding: 1,
|
||||
resource: uniform.as_entire_binding(),
|
||||
}],
|
||||
});
|
||||
Self {
|
||||
pipeline,
|
||||
group,
|
||||
uniform,
|
||||
vertices: Self::buffer(device, 4),
|
||||
capacity: 4,
|
||||
count: 0,
|
||||
}
|
||||
}
|
||||
fn buffer(device: &wgpu::Device, capacity: usize) -> wgpu::Buffer {
|
||||
device.create_buffer(&wgpu::BufferDescriptor {
|
||||
label: Some("Weather vertices"),
|
||||
size: (capacity * std::mem::size_of::<Vertex>()) as u64,
|
||||
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
|
||||
mapped_at_creation: false,
|
||||
})
|
||||
}
|
||||
pub fn prepare(
|
||||
&mut self,
|
||||
device: &wgpu::Device,
|
||||
encoder: &mut wgpu::CommandEncoder,
|
||||
uploads: &mut super::upload::Uploads,
|
||||
vertices: &[Vertex],
|
||||
time: Time,
|
||||
) {
|
||||
self.count = vertices.len() as u32;
|
||||
if vertices.is_empty() {
|
||||
return;
|
||||
}
|
||||
if vertices.len() > self.capacity {
|
||||
self.capacity = vertices.len().next_power_of_two();
|
||||
self.vertices = Self::buffer(device, self.capacity);
|
||||
}
|
||||
uploads.buffer(encoder, &self.vertices, 0, bytemuck::cast_slice(vertices));
|
||||
uploads.buffer(encoder, &self.uniform, 0, bytemuck::bytes_of(&time));
|
||||
}
|
||||
pub fn draw(&self, pass: &mut wgpu::RenderPass<'_>, entities: &wgpu::BindGroup) {
|
||||
if self.count == 0 {
|
||||
return;
|
||||
}
|
||||
pass.set_pipeline(&self.pipeline);
|
||||
pass.set_bind_group(0, entities, &[]);
|
||||
pass.set_bind_group(1, &self.group, &[]);
|
||||
pass.set_vertex_buffer(0, self.vertices.slice(..));
|
||||
// The renderer binds the shared triangle-list quad indices.
|
||||
pass.draw_indexed(0..self.count / 4 * 6, 0, 0..1);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::weather::{Parameters, Time};
|
||||
use wgpu::util::DeviceExt;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
|
||||
struct Case {
|
||||
animation: [f32; 4],
|
||||
bases: [u32; 4],
|
||||
time: [f32; 4],
|
||||
uv: [f32; 2],
|
||||
snow: u32,
|
||||
_pad: u32,
|
||||
}
|
||||
|
||||
/// Execute the production WGSL math, rather than a Rust translation of it.
|
||||
/// Requires a GPU; run explicitly on renderer changes, not on headless CI.
|
||||
#[test]
|
||||
#[ignore = "requires a Vulkan/Metal/DX12 adapter"]
|
||||
fn weather_shader_uvs_match_legacy_bits() {
|
||||
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
|
||||
let adapter =
|
||||
pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions::default()))
|
||||
.unwrap();
|
||||
eprintln!("weather parity adapter: {:?}", adapter.get_info());
|
||||
let (device, queue) =
|
||||
pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default())).unwrap();
|
||||
let mut cases = Vec::new();
|
||||
let mut expected = Vec::new();
|
||||
for i in 0..4096i32 {
|
||||
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 [-1, 0, 511, 512, 131_071, 131_072, i64::MAX] {
|
||||
let partial = [0.0, 0.5, 0.999, f32::from_bits(0x3f7fffff)][i as usize % 4];
|
||||
for snow in [false, true] {
|
||||
let column = p.column(snow, ticks, x, -64, 320, z, 0, partial);
|
||||
let uv = [1.0, if i & 1 == 0 { -16.0 } else { 80.0 }];
|
||||
cases.push(Case {
|
||||
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,
|
||||
],
|
||||
time: Time::new(ticks, partial).values,
|
||||
uv,
|
||||
snow: u32::from(snow),
|
||||
_pad: 0,
|
||||
});
|
||||
expected.push([
|
||||
(uv[0] + column.u_offset).to_bits(),
|
||||
(uv[1] + column.v_offset).to_bits(),
|
||||
]);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Force halfway rounding, cancellation, zero, tiny bases and either
|
||||
// sign of drift. Gaussian seeds alone rarely land on exact midpoints.
|
||||
for base in [
|
||||
0.0,
|
||||
2.0f64.powi(-53),
|
||||
0.5,
|
||||
0.5 + 2.0f64.powi(-25),
|
||||
0.5 + 2.0f64.powi(-25) + 2.0f64.powi(-53),
|
||||
0.5 + 2.0f64.powi(-14) + 2.0f64.powi(-53),
|
||||
1.0 - 2.0f64.powi(-53),
|
||||
] {
|
||||
for delta in [0.0f32, -0.0, -0.5, 0.5, 1024.0, -1024.0, 2.0f32.powi(-40)] {
|
||||
// time=100, u scale=.01 -> delta exactly, v is unused.
|
||||
let bits = base.to_bits();
|
||||
cases.push(Case {
|
||||
animation: [3.0, 0.0, delta, 0.0],
|
||||
bases: [bits as u32, (bits >> 32) as u32, 0, 0],
|
||||
time: [100.0, 0.0, 0.0, 0.0],
|
||||
uv: [0.0, 0.0],
|
||||
snow: 1,
|
||||
_pad: 0,
|
||||
});
|
||||
expected.push([((base + f64::from(delta)) as f32).to_bits(), 0]);
|
||||
}
|
||||
}
|
||||
let expected: Vec<[u32; 4]> = expected
|
||||
.into_iter()
|
||||
.map(|bits| {
|
||||
let uv = bits.map(f32::from_bits);
|
||||
let texel = [
|
||||
256 + ((uv[0] - uv[0].floor()) * 16.0).floor() as u32,
|
||||
512 + ((uv[1] - uv[1].floor()) * 32.0).floor() as u32,
|
||||
];
|
||||
[bits[0], bits[1], texel[0], texel[1]]
|
||||
})
|
||||
.collect();
|
||||
let math = include_str!("../entity.wgsl")
|
||||
.split("// WEATHER_MATH_BEGIN")
|
||||
.nth(1)
|
||||
.unwrap()
|
||||
.split("// WEATHER_MATH_END")
|
||||
.next()
|
||||
.unwrap();
|
||||
let source = format!(
|
||||
"{math}\n{}",
|
||||
r#"
|
||||
struct Case { animation: vec4<f32>, bases: vec4<u32>, time: vec4<f32>, uv: vec2<f32>, snow: u32, pad: u32 }
|
||||
@group(0) @binding(0) var<storage, read> cases: array<Case>;
|
||||
@group(0) @binding(1) var<storage, read_write> results: array<vec4<u32>>;
|
||||
@compute @workgroup_size(64) fn main(@builtin(global_invocation_id) id: vec3<u32>) {
|
||||
if id.x >= arrayLength(&cases) { return; }
|
||||
let c = cases[id.x];
|
||||
let uv = c.uv + weather_phase(c.animation, c.bases, c.snow, c.time);
|
||||
let texel = weather_texel(uv, vec4(0.25, 0.5, 0.015625, 0.03125), vec2(1024u));
|
||||
results[id.x] = vec4(bitcast<vec2<u32>>(uv), vec2<u32>(texel));
|
||||
}"#
|
||||
);
|
||||
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
|
||||
label: Some("Weather parity"),
|
||||
source: wgpu::ShaderSource::Wgsl(source.into()),
|
||||
});
|
||||
let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
|
||||
label: Some("Weather parity"),
|
||||
layout: None,
|
||||
module: &shader,
|
||||
entry_point: Some("main"),
|
||||
compilation_options: Default::default(),
|
||||
cache: None,
|
||||
});
|
||||
let input = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
||||
label: None,
|
||||
contents: bytemuck::cast_slice(&cases),
|
||||
usage: wgpu::BufferUsages::STORAGE,
|
||||
});
|
||||
let size = (expected.len() * 16) as u64;
|
||||
let output = device.create_buffer(&wgpu::BufferDescriptor {
|
||||
label: None,
|
||||
size,
|
||||
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
|
||||
mapped_at_creation: false,
|
||||
});
|
||||
let readback = device.create_buffer(&wgpu::BufferDescriptor {
|
||||
label: None,
|
||||
size,
|
||||
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
|
||||
mapped_at_creation: false,
|
||||
});
|
||||
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
|
||||
label: None,
|
||||
layout: &pipeline.get_bind_group_layout(0),
|
||||
entries: &[
|
||||
wgpu::BindGroupEntry {
|
||||
binding: 0,
|
||||
resource: input.as_entire_binding(),
|
||||
},
|
||||
wgpu::BindGroupEntry {
|
||||
binding: 1,
|
||||
resource: output.as_entire_binding(),
|
||||
},
|
||||
],
|
||||
});
|
||||
let mut encoder = device.create_command_encoder(&Default::default());
|
||||
{
|
||||
let mut pass = encoder.begin_compute_pass(&Default::default());
|
||||
pass.set_pipeline(&pipeline);
|
||||
pass.set_bind_group(0, &group, &[]);
|
||||
pass.dispatch_workgroups((cases.len() as u32).div_ceil(64), 1, 1);
|
||||
}
|
||||
encoder.copy_buffer_to_buffer(&output, 0, &readback, 0, size);
|
||||
queue.submit([encoder.finish()]);
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
readback.map_async(wgpu::MapMode::Read, .., move |r| tx.send(r).unwrap());
|
||||
device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
|
||||
rx.recv().unwrap().unwrap();
|
||||
let mapped = readback.get_mapped_range(..).unwrap();
|
||||
let actual: &[[u32; 4]] = bytemuck::cast_slice(&mapped);
|
||||
for (i, (actual, expected)) in actual.iter().zip(&expected).enumerate() {
|
||||
assert_eq!(
|
||||
actual, expected,
|
||||
"case {i}, snow={}, time={:?}, animation={:?}",
|
||||
cases[i].snow, cases[i].time, cases[i].animation
|
||||
);
|
||||
}
|
||||
eprintln!("{} GPU weather UV cases matched bit for bit", cases.len());
|
||||
}
|
||||
}
|
||||
@@ -204,8 +204,6 @@ pub struct Graphics {
|
||||
pub resolution_scale: u32,
|
||||
/// FXAA over the world.
|
||||
pub fxaa: bool,
|
||||
/// The settings level last shown: Advanced, or Simple.
|
||||
pub advanced: bool,
|
||||
/// Battery mode: at most 60 frames per second in a world and 30 in menus
|
||||
/// or behind other windows, and half the worker threads. Off by default;
|
||||
/// it changes when frames are drawn, never what they show or the ticks.
|
||||
@@ -236,7 +234,6 @@ impl Default for Graphics {
|
||||
overlay: Overlay::Off,
|
||||
resolution_scale: 100,
|
||||
fxaa: false,
|
||||
advanced: false,
|
||||
battery: false,
|
||||
shader_pack: String::new(),
|
||||
api: GraphicsApi::Auto,
|
||||
@@ -288,7 +285,6 @@ impl Graphics {
|
||||
"workers" => g.workers = number(g.workers).min(64),
|
||||
"resolutionScale" => g.resolution_scale = number(g.resolution_scale).clamp(50, 200),
|
||||
"fxaa" => g.fxaa = flag(g.fxaa),
|
||||
"level" => g.advanced = value == "advanced",
|
||||
"batteryMode" => g.battery = flag(g.battery),
|
||||
"shaderPack" => g.shader_pack = value.to_string(),
|
||||
"graphicsApi" => g.api = GraphicsApi::from_name(value).unwrap_or_default(),
|
||||
@@ -306,7 +302,7 @@ impl Graphics {
|
||||
}
|
||||
pub fn serialize(&self) -> String {
|
||||
format!(
|
||||
"preset:{}\nlodDistance:{}\ncaveCulling:{}\ncullLeaves:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\nlevel:{}\nbatteryMode:{}\nshaderPack:{}\ngraphicsApi:{}\n",
|
||||
"preset:{}\nlodDistance:{}\ncaveCulling:{}\ncullLeaves:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\nbatteryMode:{}\nshaderPack:{}\ngraphicsApi:{}\n",
|
||||
self.preset.name(),
|
||||
self.lod_distance,
|
||||
bool_text(self.cave_culling),
|
||||
@@ -331,7 +327,6 @@ impl Graphics {
|
||||
},
|
||||
self.resolution_scale,
|
||||
bool_text(self.fxaa),
|
||||
if self.advanced { "advanced" } else { "simple" },
|
||||
bool_text(self.battery),
|
||||
self.shader_pack,
|
||||
self.api.name(),
|
||||
@@ -425,13 +420,14 @@ mod tests {
|
||||
overlay: Overlay::Graph,
|
||||
resolution_scale: 75,
|
||||
fxaa: true,
|
||||
advanced: true,
|
||||
battery: true,
|
||||
shader_pack: "horizon-sample".into(),
|
||||
api: GraphicsApi::Dx12,
|
||||
};
|
||||
assert_eq!(Graphics::parse(&g.serialize()), g);
|
||||
assert_eq!(Graphics::parse(""), Graphics::default());
|
||||
// The old menus' Simple / Advanced choice is ignored.
|
||||
assert_eq!(Graphics::parse("level:advanced\n"), Graphics::default());
|
||||
assert_eq!(
|
||||
Graphics::parse("workers:abc\nsky:maybe\ncullLeaves:maybe\nentityCulling:maybe\n"),
|
||||
Graphics::default()
|
||||
|
||||
@@ -285,7 +285,7 @@ pub fn rows(level: Level) -> Vec<Row> {
|
||||
|
||||
const UPLOAD_STEPS: [u32; 8] = [0, 256, 512, 1024, 2048, 4096, 8192, 16384];
|
||||
|
||||
/// Classic's submenus supplement the vanilla options on their parent screens.
|
||||
/// Horizon's graphics screens supplement the vanilla options on Video Settings.
|
||||
fn extra_rows(level: Level) -> Vec<Row> {
|
||||
let mut rows = rows(level);
|
||||
rows.retain(|row| !matches!(row, Row::Setting(s) if matches!(s.item, Item::Vanilla(_))));
|
||||
@@ -444,7 +444,7 @@ fn max_workers() -> u32 {
|
||||
}
|
||||
|
||||
impl Item {
|
||||
/// On/off settings, drawn as switches by the Horizon menus.
|
||||
/// On/off settings and their value.
|
||||
pub fn switch(self, s: &Settings) -> Option<bool> {
|
||||
let g = &s.horizon;
|
||||
Some(match self {
|
||||
|
||||
@@ -2,8 +2,8 @@
|
||||
//! launcher's "N playing now". While the game runs, a thread of its own sends a random session
|
||||
//! ID made here and kept only in memory, the version, the platform and whether a LAN or
|
||||
//! play-with-friends world is open, every minute and at once when that last one changes.
|
||||
//! It sends nothing when there is no server (`HORIZON_TELEMETRY_URL`, none by default) or
|
||||
//! with `HORIZON_NO_HEARTBEAT=1` (automated runs).
|
||||
//! It sends nothing when sending is turned off (`HORIZON_TELEMETRY_URL=off`) or with
|
||||
//! `HORIZON_NO_HEARTBEAT=1` (automated runs).
|
||||
use std::sync::OnceLock;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::thread::Thread;
|
||||
|
||||
@@ -160,7 +160,7 @@ impl HudAtlas {
|
||||
)
|
||||
}
|
||||
/// Empty slots written at run time: map textures (game/maps.rs), the
|
||||
/// minimap, downloaded skins, world icons and the Horizon menu text.
|
||||
/// minimap, downloaded skins, world icons and the on-screen keyboard's text.
|
||||
fn slots(images: &mut Vec<PackedImage>) {
|
||||
for i in 0..MAP_SLOTS {
|
||||
images.push((format!("horizon/map{i}"), 128, 128, vec![0; 128 * 128 * 4]));
|
||||
@@ -184,7 +184,7 @@ impl HudAtlas {
|
||||
vec![0; 64 * 64 * 4],
|
||||
));
|
||||
}
|
||||
// Horizon-style menu text and corner masks (ui_theme), rasterized at run time.
|
||||
// The on-screen keyboard's text and corner masks (ui_theme), rasterized at run time.
|
||||
images.push((
|
||||
"horizon/ui-text".into(),
|
||||
2048,
|
||||
|
||||
@@ -71,6 +71,13 @@ pub struct Guest {
|
||||
/// The permission level (0 none, 2 game masters, 4 owners).
|
||||
pub permission: u8,
|
||||
pub sneaking: bool,
|
||||
/// The last `ServerboundPlayerInputPacket` flags (forward 1, backward 2,
|
||||
/// left 4, right 8, jump 16, shift 32, sprint 64).
|
||||
pub input: u8,
|
||||
/// The boat or minecart the player rides (`Entity.getVehicle`).
|
||||
pub vehicle: Option<u32>,
|
||||
/// `ServerGamePacketListenerImpl.lastGoodX/Y/Z` of the vehicle it controls.
|
||||
pub vehicle_good: Option<[f64; 3]>,
|
||||
pub sprinting: bool,
|
||||
pub fall_flying: bool,
|
||||
pub flying: bool,
|
||||
@@ -233,6 +240,9 @@ impl Guest {
|
||||
game_mode: SURVIVAL,
|
||||
permission: 0,
|
||||
sneaking: false,
|
||||
input: 0,
|
||||
vehicle: None,
|
||||
vehicle_good: None,
|
||||
sprinting: false,
|
||||
fall_flying: false,
|
||||
flying: false,
|
||||
|
||||
@@ -1968,6 +1968,7 @@ impl Hub {
|
||||
g.center = None;
|
||||
}
|
||||
S::PlayerInput(p) => {
|
||||
self.guests[i].input = p.flags;
|
||||
self.guests[i].sneaking = p.flags & 32 != 0;
|
||||
self.guests[i].sprinting = p.flags & 64 != 0 && p.flags & 1 != 0;
|
||||
}
|
||||
@@ -2050,6 +2051,11 @@ impl Hub {
|
||||
to[2].clamp(-3.0E7, 3.0E7),
|
||||
];
|
||||
let (yaw, pitch) = (wrap_degrees(yaw), wrap_degrees(pitch));
|
||||
// A passenger only turns: its vehicle carries it (absSnapTo where it is).
|
||||
if g.vehicle.is_some() {
|
||||
(g.yaw, g.pitch) = (yaw, pitch);
|
||||
return;
|
||||
}
|
||||
let d = [0, 1, 2].map(|k| to[k] - g.first_good[k]);
|
||||
let moved = d[0] * d[0] + d[1] * d[1] + d[2] * d[2];
|
||||
if g.sleeping {
|
||||
|
||||
@@ -69,7 +69,7 @@ pub mod first_person;
|
||||
pub mod flatgen;
|
||||
pub mod fog;
|
||||
pub mod font;
|
||||
pub mod front;
|
||||
pub mod friends_screen;
|
||||
pub mod game_mode_switcher;
|
||||
pub mod gamepad;
|
||||
pub mod gamerules;
|
||||
@@ -127,7 +127,6 @@ pub mod nether_portal;
|
||||
pub mod offline_name;
|
||||
pub mod options_file;
|
||||
pub mod options_fixes;
|
||||
pub mod options_horizon;
|
||||
pub mod options_ui;
|
||||
pub mod osk;
|
||||
pub mod overlay;
|
||||
@@ -141,7 +140,6 @@ pub mod player_sync;
|
||||
pub mod poi_sections;
|
||||
pub mod portal_sections;
|
||||
pub mod pose;
|
||||
pub mod post;
|
||||
pub mod projectiles;
|
||||
pub mod raid;
|
||||
pub mod random_sequences;
|
||||
|
||||
@@ -338,15 +338,21 @@ pub fn ridden_step(m: &mut Mob) {
|
||||
// Pig/Strider: always forward along the rider's look, at a fraction
|
||||
// of the movement speed, boosted by the stick.
|
||||
m.head_pitch = r.pitch * 0.5;
|
||||
m.ai.xxa = 0.0;
|
||||
m.ai.zza = 1.0;
|
||||
// Strider.getRiddenSpeed: slower while it shivers out of the warmth.
|
||||
let factor = if m.species() == Species::Pig {
|
||||
0.225
|
||||
} else if super::strider::suffocating(m) {
|
||||
0.35
|
||||
} else {
|
||||
0.55
|
||||
};
|
||||
let boost = boost_factor(m);
|
||||
m.set_speed((m.attrs.speed * factor) as f32 * boost);
|
||||
// travelRidden: setSpeed(getRiddenSpeed), then travel(getRiddenInput);
|
||||
// the input is set after the speed (Mob.setSpeed also sets zza).
|
||||
// getAttributeValue(MOVEMENT_SPEED): with the cold strider's modifier.
|
||||
m.set_speed((m.movement_speed() * factor) as f32 * boost);
|
||||
m.ai.xxa = 0.0;
|
||||
m.ai.zza = 1.0;
|
||||
return;
|
||||
}
|
||||
if super::camel::is_camel(m.species()) {
|
||||
@@ -366,14 +372,14 @@ pub fn ridden_step(m: &mut Mob) {
|
||||
} else {
|
||||
r.forward
|
||||
};
|
||||
m.ai.xxa = r.strafe * 0.5;
|
||||
m.ai.zza = forward;
|
||||
let bonus = if r.sprint && m.extra.anim_ticks == 0 {
|
||||
0.1
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
m.set_speed(m.attrs.speed as f32 + bonus);
|
||||
m.set_speed(m.movement_speed() as f32 + bonus);
|
||||
m.ai.xxa = r.strafe * 0.5;
|
||||
m.ai.zza = forward;
|
||||
if r.jump > 0.0 {
|
||||
let mut ev = Vec::new();
|
||||
super::camel::dash(m, r.jump, &mut ev);
|
||||
@@ -394,10 +400,10 @@ pub fn ridden_step(m: &mut Mob) {
|
||||
} else {
|
||||
r.forward
|
||||
};
|
||||
let speed = m.movement_speed() as f32;
|
||||
m.set_speed(speed);
|
||||
m.ai.xxa = r.strafe * 0.5;
|
||||
m.ai.zza = forward;
|
||||
let speed = m.attrs.speed as f32;
|
||||
m.set_speed(speed);
|
||||
if m.on_ground && r.jump > 0.0 {
|
||||
// executeRidersJump
|
||||
let impulse = m.extra.vector[0] as f32 * r.jump;
|
||||
|
||||
@@ -78,8 +78,8 @@ pub enum Screen {
|
||||
name: String,
|
||||
lines: std::cell::Cell<usize>,
|
||||
},
|
||||
/// Join a friend's world with its invite code (Horizon's own, reached
|
||||
/// from Horizon's multiplayer page).
|
||||
/// Join a friend's world with its invite code (Horizon's own, behind the
|
||||
/// title screen's Friends button).
|
||||
Friend {
|
||||
code: String,
|
||||
/// The relay for short codes (optional; saved on Join).
|
||||
@@ -373,13 +373,6 @@ impl Screen {
|
||||
}
|
||||
}
|
||||
|
||||
/// The address of list row `row` (saved servers, then LAN games).
|
||||
pub fn address_of(&self, row: usize) -> Option<String> {
|
||||
match self {
|
||||
Self::List { servers, lan, .. } => entry_address(servers, lan, row),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
pub fn list(saves: &Path) -> Self {
|
||||
let servers = servers::load(&servers_file(saves));
|
||||
let pings: Pings = Arc::default();
|
||||
@@ -1162,7 +1155,7 @@ impl Screen {
|
||||
) => *self = Self::list(saves),
|
||||
(Self::Disconnected { retry, .. }, Some(55)) => *retry = None,
|
||||
(Self::Direct { address }, Some(52)) => {
|
||||
return Outcome::Connect(address.trim().to_owned());
|
||||
return Outcome::Connect(direct_address(address));
|
||||
}
|
||||
(Self::Friend { code, relay, .. }, Some(56)) => {
|
||||
if horizon_friends::invite::parse(code).is_some() {
|
||||
@@ -1326,6 +1319,19 @@ impl Screen {
|
||||
}
|
||||
}
|
||||
|
||||
/// Direct Connection's address; a full invite code pasted there joins the
|
||||
/// friend (a short relay code could be a host name, so it needs Join a Friend).
|
||||
fn direct_address(address: &str) -> String {
|
||||
let code: String = address.chars().filter(|c| !c.is_whitespace()).collect();
|
||||
if matches!(
|
||||
horizon_friends::invite::parse(&code),
|
||||
Some(horizon_friends::invite::Parsed::Long(_))
|
||||
) {
|
||||
format!("{}{code}", crate::net::FRIEND)
|
||||
} else {
|
||||
address.trim().to_owned()
|
||||
}
|
||||
}
|
||||
/// Greedy word wrap to a pixel width.
|
||||
pub fn wrap(text: &str, width: f32, atlas: &HudAtlas) -> Vec<String> {
|
||||
let mut lines = Vec::new();
|
||||
@@ -1353,6 +1359,24 @@ pub fn wrap(text: &str, width: f32, atlas: &HudAtlas) -> Vec<String> {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn direct_connection_joins_a_pasted_invite_and_keeps_host_names() {
|
||||
let invite = horizon_friends::invite::Invite {
|
||||
secret: *b"0123456789",
|
||||
port: 25580,
|
||||
endpoints: vec!["192.168.1.20:25580".parse().unwrap()],
|
||||
relay: None,
|
||||
}
|
||||
.encode();
|
||||
assert_eq!(
|
||||
direct_address(&format!(" {invite} ")),
|
||||
format!("{}{invite}", crate::net::FRIEND)
|
||||
);
|
||||
for host in ["localhost", "example.org:25566", "abcdefgh", "[::1]:25568"] {
|
||||
assert_eq!(direct_address(host), host);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ping_tooltip_follows_only_visible_status_bars_and_current_ping() {
|
||||
let servers: Vec<_> = (0..6)
|
||||
|
||||
@@ -130,7 +130,7 @@ pub(crate) enum Kind {
|
||||
Slider(f32),
|
||||
Cycle,
|
||||
}
|
||||
/// Options shared by the Classic page and Horizon's Accessibility section.
|
||||
/// The Accessibility Settings page:
|
||||
/// `AccessibilityOptionsScreen.options`, with the Controls link inserted separately.
|
||||
pub(crate) const ACCESSIBILITY_OPTIONS: &[Opt] = &[
|
||||
Opt::Narrator,
|
||||
@@ -873,6 +873,9 @@ pub enum Page {
|
||||
Extras,
|
||||
/// CreditsAndAttributionScreen.
|
||||
Credits,
|
||||
/// Horizon Settings: every page Horizon adds, as a mod's settings
|
||||
/// screen hangs off vanilla's Options.
|
||||
Horizon,
|
||||
}
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
enum Act {
|
||||
@@ -888,8 +891,6 @@ enum Act {
|
||||
PadKey(&'static str),
|
||||
ResetPadKey(&'static str),
|
||||
ResetPadKeys,
|
||||
/// Back to Horizon's own menus (Horizon only, see `list_rows`).
|
||||
HorizonMenus,
|
||||
ToggleMod(usize),
|
||||
OpenModFolder,
|
||||
/// Pick shader pack `i` of `OptionsUi::shader_packs` (again: off).
|
||||
@@ -974,15 +975,8 @@ pub struct OptionsUi {
|
||||
/// when it last moved: the handle follows the pointer while the option
|
||||
/// keeps its stepped value, then snaps to it (`resetValue`).
|
||||
slider_value: Option<(Opt, f32, Instant)>,
|
||||
/// The pointer's last y while a Classic or Horizon scrollbar is held.
|
||||
/// The pointer's last y while a scrollbar is held.
|
||||
pub(crate) scrollbar_drag_y: Option<f32>,
|
||||
/// Horizon style: the selected sidebar section, the one last drawn and
|
||||
/// the rows' scroll in dp (`options_horizon`).
|
||||
pub section: usize,
|
||||
pub(crate) section_shown: Option<usize>,
|
||||
pub(crate) hscroll: f32,
|
||||
/// The slider being dragged on the Horizon options shell.
|
||||
pub(crate) hdragging: Option<crate::graphics_ui::Item>,
|
||||
/// Key Binds: the mapping waiting for a key.
|
||||
pub selected_key: Option<&'static str>,
|
||||
/// Controller Binds: the action waiting for a pad button.
|
||||
@@ -1023,10 +1017,6 @@ impl Default for OptionsUi {
|
||||
dragging: None,
|
||||
slider_value: None,
|
||||
scrollbar_drag_y: None,
|
||||
section: 0,
|
||||
section_shown: None,
|
||||
hscroll: 0.0,
|
||||
hdragging: None,
|
||||
selected_key: None,
|
||||
selected_pad_action: None,
|
||||
pad_style: GlyphStyle::Xbox,
|
||||
@@ -1087,6 +1077,27 @@ fn option_widget(s: &Settings, opt: Opt, x: f32, y: f32, w: f32) -> Widget {
|
||||
Kind::Cycle => button(x, y, w, opt.label(s), Act::Cycle(opt)),
|
||||
}
|
||||
}
|
||||
/// What a button opening one of Horizon's pages says on hover.
|
||||
fn horizon_page_tooltip(page: Page) -> Option<&'static str> {
|
||||
Some(match page {
|
||||
Page::Horizon => {
|
||||
"Horizon's own settings: graphics, shader packs, controllers, extras and mods."
|
||||
}
|
||||
Page::Graphics => "Graphics, simply: each setting says what it costs.",
|
||||
Page::GraphicsAdvanced => {
|
||||
"Every graphics setting, Horizon's included, with what each costs."
|
||||
}
|
||||
Page::ShaderPacks => "Packs that redraw the world. Off is the vanilla look.",
|
||||
Page::Controller => "Controllers: their buttons, sticks, vibration and menu navigation.",
|
||||
Page::Extras => {
|
||||
"Optional additions, all off by default: the game stays vanilla until you turn one on."
|
||||
}
|
||||
Page::Mods => {
|
||||
"Mods made for Horizon, from the horizon-mods folder. Each runs in a sandbox and stays off until you turn it on."
|
||||
}
|
||||
_ => return None,
|
||||
})
|
||||
}
|
||||
/// Rows of an OptionsList: (big?, options) or a header.
|
||||
enum Row {
|
||||
Big(Opt),
|
||||
@@ -1104,10 +1115,7 @@ fn pairs(opts: &[Opt]) -> Vec<Row> {
|
||||
impl OptionsUi {
|
||||
fn settings_search_active(&self) -> bool {
|
||||
self.settings_search.focused
|
||||
&& (matches!(self.page(), Page::Video | Page::Controls | Page::KeyBinds)
|
||||
|| (crate::ui_theme::horizon()
|
||||
&& self.page() == Page::Main
|
||||
&& crate::options_horizon::searchable_section(self.section)))
|
||||
&& matches!(self.page(), Page::Video | Page::Controls | Page::KeyBinds)
|
||||
}
|
||||
pub fn page(&self) -> Page {
|
||||
*self.stack.last().unwrap_or(&Page::Main)
|
||||
@@ -1128,10 +1136,6 @@ impl OptionsUi {
|
||||
self.in_world = in_world;
|
||||
self.selected_key = None;
|
||||
}
|
||||
/// Open one of vanilla's pages over the current one.
|
||||
pub(crate) fn open_page(&mut self, page: Page) {
|
||||
self.push(page);
|
||||
}
|
||||
fn push(&mut self, page: Page) {
|
||||
self.stack.push(page);
|
||||
self.scroll = 0.0;
|
||||
@@ -1170,14 +1174,9 @@ impl OptionsUi {
|
||||
.as_ref()
|
||||
.is_some_and(|(e, _)| e == id)
|
||||
}
|
||||
/// Whether the Shader Packs page (or the Horizon menus' section) shows.
|
||||
/// Whether the Shader Packs page shows.
|
||||
fn shader_packs_shown(&self) -> bool {
|
||||
self.page() == Page::ShaderPacks
|
||||
|| crate::ui_theme::horizon()
|
||||
&& self.page() == Page::Main
|
||||
&& crate::options_horizon::SECTIONS
|
||||
.get(self.section)
|
||||
.is_some_and(|s| s.name == crate::options_horizon::SHADER_PACKS)
|
||||
}
|
||||
/// The graphics screen level of `page`, if it is one.
|
||||
fn graphics_level(page: Page) -> Option<crate::graphics_ui::Level> {
|
||||
@@ -1207,6 +1206,7 @@ impl OptionsUi {
|
||||
Page::PadBinds => "Controller Binds",
|
||||
Page::Extras => "Horizon Extras",
|
||||
Page::Credits => "credits_and_attribution.screen.title",
|
||||
Page::Horizon => "Horizon Settings",
|
||||
}
|
||||
}
|
||||
fn scrollbar_x(&self, width: f32) -> f32 {
|
||||
@@ -1270,7 +1270,17 @@ impl OptionsUi {
|
||||
} else {
|
||||
Text::literal(value)
|
||||
};
|
||||
button(0.0, 0.0, 150.0, label, Act::Extra(item))
|
||||
let widget = button(0.0, 0.0, 150.0, label, Act::Extra(item));
|
||||
// A setting of a switch that is off does nothing: inactive,
|
||||
// as vanilla greys out an option that can't apply.
|
||||
if item
|
||||
.parent()
|
||||
.is_some_and(|parent| parent.switch(&s.extras) == Some(false))
|
||||
{
|
||||
inactive(widget)
|
||||
} else {
|
||||
widget
|
||||
}
|
||||
};
|
||||
let mut rows = Vec::new();
|
||||
let mut section = Vec::new();
|
||||
@@ -1294,6 +1304,27 @@ impl OptionsUi {
|
||||
flush(&mut rows, &mut section);
|
||||
rows
|
||||
}
|
||||
Page::Horizon => {
|
||||
// Two to a row, as vanilla's OptionsList.addSmall lays out
|
||||
// buttons; each opens a page built from vanilla's widgets.
|
||||
let open = |label: &str, page: Page| {
|
||||
button(0.0, 0.0, 150.0, Text::literal(label), Act::Push(page))
|
||||
};
|
||||
vec![
|
||||
Row::Buttons(
|
||||
open("Graphics...", Page::Graphics),
|
||||
Some(open("Advanced Graphics...", Page::GraphicsAdvanced)),
|
||||
),
|
||||
Row::Buttons(
|
||||
open("Shader Packs...", Page::ShaderPacks),
|
||||
Some(open("Controller Settings...", Page::Controller)),
|
||||
),
|
||||
Row::Buttons(
|
||||
open("Extras...", Page::Extras),
|
||||
Some(open("Mods...", Page::Mods)),
|
||||
),
|
||||
]
|
||||
}
|
||||
Page::Video => {
|
||||
// Horizon's graphics screens, Simple and Advanced.
|
||||
let mut rows = vec![Row::Buttons(
|
||||
@@ -1322,22 +1353,6 @@ impl OptionsUi {
|
||||
),
|
||||
None,
|
||||
));
|
||||
// The way back from Classic menus. Horizon-only like the row
|
||||
// above, here rather than on the main Options screen so that
|
||||
// one keeps vanilla's exact layout; vanilla's interface
|
||||
// settings (GUI Scale) are on this page too.
|
||||
if !crate::ui_theme::horizon() {
|
||||
rows.push(Row::Buttons(
|
||||
button(
|
||||
0.0,
|
||||
0.0,
|
||||
310.0,
|
||||
Text::literal("Menu Style: Classic"),
|
||||
Act::HorizonMenus,
|
||||
),
|
||||
None,
|
||||
));
|
||||
}
|
||||
rows.push(Row::Header("options.video.display.header"));
|
||||
rows.extend(pairs(&[
|
||||
Opt::MaxFps,
|
||||
@@ -1585,8 +1600,11 @@ impl OptionsUi {
|
||||
("options.chat", Some(Page::Chat)),
|
||||
("options.resourcepack", Some(Page::Packs)),
|
||||
("options.accessibility", Some(Page::Accessibility)),
|
||||
// Vanilla's Telemetry Data and Credits slots: Horizon's
|
||||
// settings and its mods, as a mod adds its button here.
|
||||
// Credits & Attribution (WinScreen's credits) follows them.
|
||||
("Horizon Settings...", Some(Page::Horizon)),
|
||||
("Mods...", Some(Page::Mods)),
|
||||
("Horizon Extras...", Some(Page::Extras)),
|
||||
("options.credits_and_attribution", Some(Page::Credits)),
|
||||
];
|
||||
let rows = entries.len().div_ceil(2) as f32;
|
||||
@@ -2101,10 +2119,6 @@ impl OptionsUi {
|
||||
);
|
||||
return;
|
||||
}
|
||||
if crate::ui_theme::horizon() && self.page() == Page::Main {
|
||||
self.draw_horizon(s, batch, atlas, cursor);
|
||||
return;
|
||||
}
|
||||
if let Some(level) = Self::graphics_level(self.page()) {
|
||||
self.graphics
|
||||
.draw(level, s, batch, atlas, cursor, self.in_world);
|
||||
@@ -2143,6 +2157,14 @@ impl OptionsUi {
|
||||
{
|
||||
tooltip = Some(atlas.font.split(&Text::literal(item.description()), 170.0));
|
||||
}
|
||||
if let WKind::Button {
|
||||
act: Act::Push(page),
|
||||
..
|
||||
} = &wd.kind
|
||||
&& let Some(text) = horizon_page_tooltip(*page)
|
||||
{
|
||||
tooltip = Some(atlas.font.split(&Text::literal(text), 170.0));
|
||||
}
|
||||
let key = match &wd.kind {
|
||||
WKind::Button {
|
||||
act: Act::Cycle(opt),
|
||||
@@ -2349,9 +2371,6 @@ impl OptionsUi {
|
||||
}
|
||||
return Vec::new();
|
||||
}
|
||||
if crate::ui_theme::horizon() && self.page() == Page::Main {
|
||||
return self.click_horizon(s, atlas, x, y, framebuffer, drag, right);
|
||||
}
|
||||
if let Some(level) = Self::graphics_level(self.page()) {
|
||||
use crate::graphics_ui::Action;
|
||||
let mut events = Vec::new();
|
||||
@@ -2520,12 +2539,6 @@ impl OptionsUi {
|
||||
s.controller.reset_bindings();
|
||||
events.push(Event::Changed);
|
||||
}
|
||||
Act::HorizonMenus => {
|
||||
self.horizon_menus();
|
||||
if let Ok(dir) = std::env::current_dir() {
|
||||
crate::ui_theme::save_preferences(&dir);
|
||||
}
|
||||
}
|
||||
Act::ToggleMod(i) => {
|
||||
s.mods.toggle(i);
|
||||
events.push(Event::Changed);
|
||||
@@ -2560,20 +2573,6 @@ impl OptionsUi {
|
||||
}
|
||||
events
|
||||
}
|
||||
/// Switch to Horizon's menus and show where the choice lives there
|
||||
/// (Options, Interface, Menu style).
|
||||
fn horizon_menus(&mut self) {
|
||||
crate::ui_theme::set_style(crate::ui_theme::MenuStyle::Horizon);
|
||||
self.stack.truncate(1);
|
||||
self.scroll = 0.0;
|
||||
self.scrollbar_drag_y = None;
|
||||
self.section = crate::options_horizon::SECTIONS
|
||||
.iter()
|
||||
.position(|section| section.name == "Interface")
|
||||
.unwrap_or(0);
|
||||
self.section_shown = None;
|
||||
self.hscroll = 0.0;
|
||||
}
|
||||
/// Where a slider's handle sits: its own position while held (or until
|
||||
/// a delayed one applies), else the option's stepped value.
|
||||
fn slider_shown(&self, opt: Opt, value: f32) -> f32 {
|
||||
@@ -2590,7 +2589,6 @@ impl OptionsUi {
|
||||
// AbstractSliderButton suppresses the press sound and plays once on
|
||||
// release, even if the pointer has left the widget or its value stayed.
|
||||
let slider = self.dragging.take().is_some();
|
||||
self.hdragging = None;
|
||||
let graphics_slider = self.graphics.release();
|
||||
if slider || graphics_slider {
|
||||
vec![Event::ButtonClick]
|
||||
@@ -2608,10 +2606,6 @@ impl OptionsUi {
|
||||
if self.resource_error.is_some() {
|
||||
return;
|
||||
}
|
||||
if crate::ui_theme::horizon() && self.page() == Page::Main {
|
||||
self.scroll_horizon(amount);
|
||||
return;
|
||||
}
|
||||
if let Some(level) = Self::graphics_level(self.page()) {
|
||||
self.graphics.scroll(level, size.1, amount);
|
||||
return;
|
||||
@@ -2833,7 +2827,6 @@ impl OptionsUi {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::ui_theme::{MenuStyle, set_style, style};
|
||||
|
||||
#[test]
|
||||
fn accessibility_sliders_and_toggles_survive_options_round_trip() {
|
||||
@@ -3387,9 +3380,7 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn classic_extras_entry_edits_shared_settings_and_returns_without_changing_style() {
|
||||
let previous_style = style();
|
||||
set_style(MenuStyle::Classic);
|
||||
fn extras_from_horizon_settings_edit_shared_settings_and_return() {
|
||||
let atlas = atlas();
|
||||
let mut s = Settings::default();
|
||||
let mut ui = OptionsUi::default();
|
||||
@@ -3413,11 +3404,13 @@ mod tests {
|
||||
false,
|
||||
)
|
||||
};
|
||||
assert_eq!(
|
||||
click(&mut ui, &mut s, Act::Push(Page::Extras)),
|
||||
vec![Event::ButtonClick]
|
||||
);
|
||||
assert_eq!(ui.page(), Page::Extras);
|
||||
for page in [Page::Horizon, Page::Extras] {
|
||||
assert_eq!(
|
||||
click(&mut ui, &mut s, Act::Push(page)),
|
||||
vec![Event::ButtonClick]
|
||||
);
|
||||
assert_eq!(ui.page(), page);
|
||||
}
|
||||
let (widgets, _, _, _) = ui.layout(&s, size.0, size.1);
|
||||
assert_eq!(
|
||||
widgets
|
||||
@@ -3458,9 +3451,7 @@ mod tests {
|
||||
ui.key(&mut s, &atlas, winit::keyboard::KeyCode::Escape, None),
|
||||
vec![Event::Changed]
|
||||
);
|
||||
assert_eq!(ui.page(), Page::Main);
|
||||
assert_eq!(style(), MenuStyle::Classic);
|
||||
set_style(previous_style);
|
||||
assert_eq!(ui.page(), Page::Horizon);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -4044,15 +4035,25 @@ mod tests {
|
||||
let atlas = atlas();
|
||||
let mut s = Settings::default();
|
||||
let mut ui = OptionsUi::default();
|
||||
ui.show(Page::Extras);
|
||||
for (right, expected) in [(false, "key.mouse.left"), (true, "key.mouse.right")] {
|
||||
ui.selected_key = Some(crate::extras::SORT_KEY);
|
||||
assert_eq!(
|
||||
ui.click_horizon(&mut s, &atlas, 2.0, 2.0, [960, 480], false, right),
|
||||
ui.click(
|
||||
&mut s,
|
||||
&atlas,
|
||||
2.0,
|
||||
2.0,
|
||||
(480.0, 240.0),
|
||||
[960, 480],
|
||||
false,
|
||||
right
|
||||
),
|
||||
vec![Event::Changed]
|
||||
);
|
||||
assert_eq!(s.extras.sort_key, expected);
|
||||
assert_eq!(ui.selected_key, None);
|
||||
assert_eq!(ui.section, 0);
|
||||
assert_eq!(ui.page(), Page::Extras);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4166,30 +4167,45 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn classic_video_settings_lead_back_to_horizon_menus() {
|
||||
let previous_style = style();
|
||||
set_style(MenuStyle::Horizon);
|
||||
fn horizon_settings_hang_off_options_and_reach_every_horizon_page() {
|
||||
let s = Settings::default();
|
||||
let mut ui = OptionsUi::default();
|
||||
ui.push(Page::Video);
|
||||
let way_back = |ui: &OptionsUi| {
|
||||
ui.list_rows(&s).iter().any(|row| {
|
||||
matches!(row, Row::Buttons(w, _)
|
||||
if matches!(&w.kind, WKind::Button { act: Act::HorizonMenus, .. }))
|
||||
})
|
||||
let pushes = |ui: &mut OptionsUi| -> Vec<Page> {
|
||||
let (widgets, _, _, _) = ui.layout(&s, 427.0, 240.0);
|
||||
widgets
|
||||
.iter()
|
||||
.filter_map(|w| match &w.kind {
|
||||
WKind::Button {
|
||||
act: Act::Push(page),
|
||||
active: true,
|
||||
..
|
||||
} => Some(*page),
|
||||
_ => None,
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
// Horizon's own menus have the choice on their Interface page.
|
||||
assert!(!way_back(&ui));
|
||||
set_style(MenuStyle::Classic);
|
||||
let classic = way_back(&ui);
|
||||
ui.horizon_menus();
|
||||
assert!(classic, "Classic Video Settings offer Menu Style");
|
||||
assert_eq!(style(), MenuStyle::Horizon);
|
||||
assert_eq!(ui.stack, vec![Page::Main]);
|
||||
// Vanilla's ten Options buttons, the last two Horizon's.
|
||||
let main = pushes(&mut ui);
|
||||
assert_eq!(&main[main.len() - 2..], [Page::Horizon, Page::Mods]);
|
||||
ui.push(Page::Horizon);
|
||||
assert_eq!(
|
||||
crate::options_horizon::SECTIONS[ui.section].name,
|
||||
"Interface"
|
||||
pushes(&mut ui),
|
||||
[
|
||||
Page::Graphics,
|
||||
Page::GraphicsAdvanced,
|
||||
Page::ShaderPacks,
|
||||
Page::Controller,
|
||||
Page::Extras,
|
||||
Page::Mods,
|
||||
]
|
||||
);
|
||||
set_style(previous_style);
|
||||
// Vanilla's own pages keep the Horizon pages they had.
|
||||
ui.stack = vec![Page::Main, Page::Video];
|
||||
let video = pushes(&mut ui);
|
||||
for page in [Page::Graphics, Page::GraphicsAdvanced, Page::ShaderPacks] {
|
||||
assert!(video.contains(&page), "{page:?}");
|
||||
}
|
||||
ui.stack = vec![Page::Main, Page::Controls];
|
||||
assert!(pushes(&mut ui).contains(&Page::Controller));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,273 +0,0 @@
|
||||
//! The menus' backdrop treatment (`ui_theme`'s Horizon style): the finished
|
||||
//! world frame is blurred (dual Kawase: three halvings down, back up) and
|
||||
//! colour graded before the HUD is drawn over it. Needs a swapchain that can
|
||||
//! be copied from; without one the frame is left as it is.
|
||||
|
||||
/// How the frame under a Horizon-style menu is treated.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub struct PostGrade {
|
||||
/// Colour multiplier and lift (`c * tint + lift`).
|
||||
pub tint: [f32; 3],
|
||||
pub lift: [f32; 3],
|
||||
/// Toward grey, 0..1.
|
||||
pub desaturate: f32,
|
||||
/// Darkening toward the corners, 0..1.
|
||||
pub vignette: f32,
|
||||
}
|
||||
impl PostGrade {
|
||||
/// The title backdrop: icy, slightly lifted shadows.
|
||||
pub const FROST: Self = Self {
|
||||
tint: [0.62, 0.78, 1.0],
|
||||
lift: [0.0, 0.01, 0.035],
|
||||
desaturate: 0.45,
|
||||
vignette: 0.5,
|
||||
};
|
||||
/// Behind the pause menu: the world stays recognisable.
|
||||
pub const PAUSE: Self = Self {
|
||||
tint: [0.8, 0.86, 0.98],
|
||||
lift: [0.0, 0.004, 0.012],
|
||||
desaturate: 0.25,
|
||||
vignette: 0.3,
|
||||
};
|
||||
}
|
||||
#[repr(C)]
|
||||
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
|
||||
struct Uniform {
|
||||
texel: [f32; 4],
|
||||
tint: [f32; 4],
|
||||
lift: [f32; 4],
|
||||
params: [f32; 4],
|
||||
}
|
||||
const LEVELS: usize = 3;
|
||||
pub struct Post {
|
||||
layout: wgpu::BindGroupLayout,
|
||||
down: wgpu::RenderPipeline,
|
||||
up: wgpu::RenderPipeline,
|
||||
finish: wgpu::RenderPipeline,
|
||||
sampler: wgpu::Sampler,
|
||||
/// The copied frame, then the halvings.
|
||||
levels: Vec<(wgpu::Texture, wgpu::TextureView, [u32; 2])>,
|
||||
uniforms: Vec<wgpu::Buffer>,
|
||||
size: [u32; 2],
|
||||
format: wgpu::TextureFormat,
|
||||
}
|
||||
impl Post {
|
||||
pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Self {
|
||||
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
|
||||
label: Some("Menu backdrop"),
|
||||
source: wgpu::ShaderSource::Wgsl(include_str!("post.wgsl").into()),
|
||||
});
|
||||
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||||
label: Some("Menu backdrop bindings"),
|
||||
entries: &[
|
||||
wgpu::BindGroupLayoutEntry {
|
||||
binding: 0,
|
||||
visibility: wgpu::ShaderStages::FRAGMENT,
|
||||
ty: wgpu::BindingType::Texture {
|
||||
sample_type: wgpu::TextureSampleType::Float { filterable: true },
|
||||
view_dimension: wgpu::TextureViewDimension::D2,
|
||||
multisampled: false,
|
||||
},
|
||||
count: None,
|
||||
},
|
||||
wgpu::BindGroupLayoutEntry {
|
||||
binding: 1,
|
||||
visibility: wgpu::ShaderStages::FRAGMENT,
|
||||
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
|
||||
count: None,
|
||||
},
|
||||
wgpu::BindGroupLayoutEntry {
|
||||
binding: 2,
|
||||
visibility: wgpu::ShaderStages::FRAGMENT,
|
||||
ty: wgpu::BindingType::Buffer {
|
||||
ty: wgpu::BufferBindingType::Uniform,
|
||||
has_dynamic_offset: false,
|
||||
min_binding_size: None,
|
||||
},
|
||||
count: None,
|
||||
},
|
||||
],
|
||||
});
|
||||
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
||||
label: Some("Menu backdrop"),
|
||||
bind_group_layouts: &[Some(&layout)],
|
||||
..Default::default()
|
||||
});
|
||||
let pipeline = |entry: &str| {
|
||||
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
|
||||
label: Some("Menu backdrop pass"),
|
||||
layout: Some(&pipeline_layout),
|
||||
vertex: wgpu::VertexState {
|
||||
module: &shader,
|
||||
entry_point: Some("vs_main"),
|
||||
buffers: &[],
|
||||
compilation_options: Default::default(),
|
||||
},
|
||||
fragment: Some(wgpu::FragmentState {
|
||||
module: &shader,
|
||||
entry_point: Some(entry),
|
||||
targets: &[Some(wgpu::ColorTargetState {
|
||||
format,
|
||||
blend: None,
|
||||
write_mask: wgpu::ColorWrites::ALL,
|
||||
})],
|
||||
compilation_options: Default::default(),
|
||||
}),
|
||||
primitive: Default::default(),
|
||||
depth_stencil: None,
|
||||
multisample: Default::default(),
|
||||
multiview_mask: None,
|
||||
cache: None,
|
||||
})
|
||||
};
|
||||
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
|
||||
label: Some("Menu backdrop"),
|
||||
mag_filter: wgpu::FilterMode::Linear,
|
||||
min_filter: wgpu::FilterMode::Linear,
|
||||
address_mode_u: wgpu::AddressMode::ClampToEdge,
|
||||
address_mode_v: wgpu::AddressMode::ClampToEdge,
|
||||
..Default::default()
|
||||
});
|
||||
let uniforms = (0..LEVELS * 2 + 1)
|
||||
.map(|_| {
|
||||
device.create_buffer(&wgpu::BufferDescriptor {
|
||||
label: Some("Menu backdrop pass"),
|
||||
size: std::mem::size_of::<Uniform>() as u64,
|
||||
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
|
||||
mapped_at_creation: false,
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
Self {
|
||||
down: pipeline("fs_down"),
|
||||
up: pipeline("fs_up"),
|
||||
finish: pipeline("fs_final"),
|
||||
layout,
|
||||
sampler,
|
||||
levels: Vec::new(),
|
||||
uniforms,
|
||||
size: [0, 0],
|
||||
format,
|
||||
}
|
||||
}
|
||||
fn ensure(&mut self, device: &wgpu::Device, size: [u32; 2]) {
|
||||
if self.size == size && !self.levels.is_empty() {
|
||||
return;
|
||||
}
|
||||
self.size = size;
|
||||
self.levels = (0..=LEVELS)
|
||||
.map(|i| {
|
||||
let s = [(size[0] >> i).max(1), (size[1] >> i).max(1)];
|
||||
let texture = device.create_texture(&wgpu::TextureDescriptor {
|
||||
label: Some("Menu backdrop level"),
|
||||
size: wgpu::Extent3d {
|
||||
width: s[0],
|
||||
height: s[1],
|
||||
depth_or_array_layers: 1,
|
||||
},
|
||||
mip_level_count: 1,
|
||||
sample_count: 1,
|
||||
dimension: wgpu::TextureDimension::D2,
|
||||
format: self.format,
|
||||
usage: wgpu::TextureUsages::TEXTURE_BINDING
|
||||
| wgpu::TextureUsages::RENDER_ATTACHMENT
|
||||
| wgpu::TextureUsages::COPY_DST,
|
||||
view_formats: &[],
|
||||
});
|
||||
let view = texture.create_view(&Default::default());
|
||||
(texture, view, s)
|
||||
})
|
||||
.collect();
|
||||
}
|
||||
fn pass(
|
||||
&self,
|
||||
device: &wgpu::Device,
|
||||
queue: &wgpu::Queue,
|
||||
encoder: &mut wgpu::CommandEncoder,
|
||||
pipeline: &wgpu::RenderPipeline,
|
||||
(from, uniform): (usize, usize),
|
||||
target: &wgpu::TextureView,
|
||||
data: Uniform,
|
||||
) {
|
||||
let (_, view, s) = &self.levels[from];
|
||||
let mut data = data;
|
||||
data.texel = [0.5 / s[0] as f32, 0.5 / s[1] as f32, 0.0, 0.0];
|
||||
queue.write_buffer(&self.uniforms[uniform], 0, bytemuck::bytes_of(&data));
|
||||
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
|
||||
label: Some("Menu backdrop pass"),
|
||||
layout: &self.layout,
|
||||
entries: &[
|
||||
wgpu::BindGroupEntry {
|
||||
binding: 0,
|
||||
resource: wgpu::BindingResource::TextureView(view),
|
||||
},
|
||||
wgpu::BindGroupEntry {
|
||||
binding: 1,
|
||||
resource: wgpu::BindingResource::Sampler(&self.sampler),
|
||||
},
|
||||
wgpu::BindGroupEntry {
|
||||
binding: 2,
|
||||
resource: self.uniforms[uniform].as_entire_binding(),
|
||||
},
|
||||
],
|
||||
});
|
||||
let attachments = [Some(wgpu::RenderPassColorAttachment {
|
||||
view: target,
|
||||
resolve_target: None,
|
||||
depth_slice: None,
|
||||
ops: wgpu::Operations {
|
||||
load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
|
||||
store: wgpu::StoreOp::Store,
|
||||
},
|
||||
})];
|
||||
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
||||
label: Some("Menu backdrop pass"),
|
||||
color_attachments: &attachments,
|
||||
..Default::default()
|
||||
});
|
||||
pass.set_pipeline(pipeline);
|
||||
pass.set_bind_group(0, &group, &[]);
|
||||
pass.draw(0..3, 0..1);
|
||||
}
|
||||
/// Blur and grade `frame` (the swapchain texture) into `target`.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn apply(
|
||||
&mut self,
|
||||
device: &wgpu::Device,
|
||||
queue: &wgpu::Queue,
|
||||
encoder: &mut wgpu::CommandEncoder,
|
||||
frame: &wgpu::Texture,
|
||||
target: &wgpu::TextureView,
|
||||
size: [u32; 2],
|
||||
grade: &PostGrade,
|
||||
) {
|
||||
self.ensure(device, size);
|
||||
encoder.copy_texture_to_texture(
|
||||
frame.as_image_copy(),
|
||||
self.levels[0].0.as_image_copy(),
|
||||
wgpu::Extent3d {
|
||||
width: size[0],
|
||||
height: size[1],
|
||||
depth_or_array_layers: 1,
|
||||
},
|
||||
);
|
||||
let data = Uniform {
|
||||
texel: [0.0; 4],
|
||||
tint: [grade.tint[0], grade.tint[1], grade.tint[2], 1.0],
|
||||
lift: [grade.lift[0], grade.lift[1], grade.lift[2], 0.0],
|
||||
params: [grade.desaturate, grade.vignette, 0.0, 0.0],
|
||||
};
|
||||
let mut u = 0;
|
||||
for i in 1..=LEVELS {
|
||||
let target = &self.levels[i].1;
|
||||
self.pass(device, queue, encoder, &self.down, (i - 1, u), target, data);
|
||||
u += 1;
|
||||
}
|
||||
for i in (1..LEVELS).rev() {
|
||||
let target = &self.levels[i].1;
|
||||
self.pass(device, queue, encoder, &self.up, (i + 1, u), target, data);
|
||||
u += 1;
|
||||
}
|
||||
self.pass(device, queue, encoder, &self.finish, (1, u), target, data);
|
||||
}
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
// Menu backdrop: dual-Kawase blur (down and up passes) and a cold colour grade.
|
||||
struct Post {
|
||||
// Half a source texel (u, v), unused, unused.
|
||||
texel: vec4<f32>,
|
||||
// Multiplier and lift of the grade.
|
||||
tint: vec4<f32>,
|
||||
lift: vec4<f32>,
|
||||
// Desaturation, vignette, unused, unused.
|
||||
params: vec4<f32>,
|
||||
}
|
||||
@group(0) @binding(0) var src: texture_2d<f32>;
|
||||
@group(0) @binding(1) var samp: sampler;
|
||||
@group(0) @binding(2) var<uniform> post: Post;
|
||||
struct Out {
|
||||
@builtin(position) clip: vec4<f32>,
|
||||
@location(0) uv: vec2<f32>,
|
||||
}
|
||||
@vertex fn vs_main(@builtin(vertex_index) i: u32) -> Out {
|
||||
let p = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
|
||||
var out: Out;
|
||||
out.clip = vec4(p * 2.0 - 1.0, 0.0, 1.0);
|
||||
out.uv = vec2(p.x, 1.0 - p.y);
|
||||
return out;
|
||||
}
|
||||
fn s(uv: vec2<f32>) -> vec3<f32> {
|
||||
return textureSampleLevel(src, samp, uv, 0.0).rgb;
|
||||
}
|
||||
@fragment fn fs_down(in: Out) -> @location(0) vec4<f32> {
|
||||
let h = post.texel.xy;
|
||||
let c = s(in.uv) * 4.0 + s(in.uv - h) + s(in.uv + h) + s(in.uv + vec2(h.x, -h.y)) + s(in.uv - vec2(h.x, -h.y));
|
||||
return vec4(c / 8.0, 1.0);
|
||||
}
|
||||
fn up(uv: vec2<f32>) -> vec3<f32> {
|
||||
let h = post.texel.xy;
|
||||
var c = s(uv + vec2(-h.x * 2.0, 0.0)) + s(uv + vec2(h.x * 2.0, 0.0));
|
||||
c += s(uv + vec2(0.0, -h.y * 2.0)) + s(uv + vec2(0.0, h.y * 2.0));
|
||||
c += (s(uv + vec2(-h.x, h.y)) + s(uv + vec2(h.x, h.y)) + s(uv + vec2(-h.x, -h.y)) + s(uv + vec2(h.x, -h.y))) * 2.0;
|
||||
return c / 12.0;
|
||||
}
|
||||
@fragment fn fs_up(in: Out) -> @location(0) vec4<f32> {
|
||||
return vec4(up(in.uv), 1.0);
|
||||
}
|
||||
@fragment fn fs_final(in: Out) -> @location(0) vec4<f32> {
|
||||
var c = up(in.uv);
|
||||
let l = dot(c, vec3(0.2126, 0.7152, 0.0722));
|
||||
c = mix(c, vec3(l), post.params.x);
|
||||
c = c * post.tint.rgb + post.lift.rgb;
|
||||
let d = length((in.uv - 0.5) * vec2(1.25, 1.0));
|
||||
c *= 1.0 - post.params.y * smoothstep(0.35, 0.95, d);
|
||||
return vec4(clamp(c, vec3(0.0), vec3(1.0)), 1.0);
|
||||
}
|
||||
@@ -33,7 +33,7 @@ pub fn mark_start() {
|
||||
STARTED.get_or_init(Instant::now);
|
||||
}
|
||||
|
||||
/// The menu bundle is ready: the title backdrop can draw. The first writer wins.
|
||||
/// The menu bundle is ready: the title screen can draw. The first writer wins.
|
||||
pub fn mark_ui_ready() {
|
||||
if let Some(started) = STARTED.get() {
|
||||
let ms = started.elapsed().as_millis() as u32;
|
||||
|
||||
@@ -142,10 +142,6 @@ pub struct Title {
|
||||
toast: Option<(crate::toasts::Slide, BackupToast)>,
|
||||
icons: RefCell<std::collections::HashMap<PathBuf, (std::time::SystemTime, Option<Vec<u8>>)>>,
|
||||
splash: Option<String>,
|
||||
/// The mode last drawn and when it appeared (Horizon's screen fades).
|
||||
shown: std::cell::Cell<(std::mem::Discriminant<Mode>, std::time::Instant)>,
|
||||
/// The launcher-style opening (Horizon style, first title of the session).
|
||||
pub opening: std::cell::Cell<Option<crate::front::Opening>>,
|
||||
/// The saves listed for Home, re-read every couple of seconds.
|
||||
recent: std::cell::RefCell<Option<(std::time::Instant, Vec<WorldEntry>)>>,
|
||||
}
|
||||
@@ -232,7 +228,6 @@ impl Title {
|
||||
let mode = Mode::Main;
|
||||
let now = std::time::Instant::now();
|
||||
Self {
|
||||
shown: std::cell::Cell::new((std::mem::discriminant(&mode), now)),
|
||||
mode,
|
||||
last_server: String::new(),
|
||||
saves,
|
||||
@@ -256,7 +251,6 @@ impl Title {
|
||||
.subsec_nanos() as usize,
|
||||
(today.month(), today.day()),
|
||||
),
|
||||
opening: std::cell::Cell::new(None),
|
||||
recent: std::cell::RefCell::new(None),
|
||||
}
|
||||
}
|
||||
@@ -517,17 +511,6 @@ impl Title {
|
||||
}
|
||||
}
|
||||
}
|
||||
/// When the current mode first appeared.
|
||||
pub fn entered(&self) -> std::time::Instant {
|
||||
let now = std::mem::discriminant(&self.mode);
|
||||
let (mode, at) = self.shown.get();
|
||||
if mode == now {
|
||||
return at;
|
||||
}
|
||||
let at = std::time::Instant::now();
|
||||
self.shown.set((now, at));
|
||||
at
|
||||
}
|
||||
/// Create New World: the folder name and options (FileUtil.findAvailableName).
|
||||
pub fn create_action(&self) -> Action {
|
||||
let Mode::Create {
|
||||
@@ -597,7 +580,9 @@ impl Title {
|
||||
b(cx + 2.0, y + 96.0, 98.0, "Quit Game", true, 2),
|
||||
];
|
||||
for (i, (label, enabled, id, icon, size)) in [
|
||||
("Friends", false, 5, "friends/friends", 15.0),
|
||||
// Horizon's Join a Friend (an invite code) behind
|
||||
// vanilla's Friends button.
|
||||
("Friends", true, 5, "friends/friends", 15.0),
|
||||
("Language", true, 6, "icon/language", 15.0),
|
||||
(
|
||||
"Accessibility Settings",
|
||||
@@ -1207,6 +1192,10 @@ impl Title {
|
||||
crate::multiplayer::Outcome::Connect(address) => Action::Connect { address },
|
||||
crate::multiplayer::Outcome::None => Action::None,
|
||||
},
|
||||
(Mode::Main, Some(5)) => {
|
||||
self.mode = Mode::Multiplayer(crate::multiplayer::Screen::friend());
|
||||
Action::None
|
||||
}
|
||||
(Mode::Main, Some(3)) => Action::Options,
|
||||
(Mode::Main, Some(7)) => Action::Accessibility,
|
||||
(Mode::Main, Some(6)) => Action::Language,
|
||||
@@ -1669,7 +1658,7 @@ mod classic_tests {
|
||||
let cx = (w / 2.0).floor();
|
||||
let y = (h / 4.0).floor() + 48.0;
|
||||
for (id, x, enabled, icon) in [
|
||||
(5, cx - 34.0, false, "friends/friends"),
|
||||
(5, cx - 34.0, true, "friends/friends"),
|
||||
(6, cx - 10.0, true, "icon/language"),
|
||||
(7, cx + 14.0, true, "icon/accessibility"),
|
||||
] {
|
||||
@@ -1683,9 +1672,16 @@ mod classic_tests {
|
||||
match id {
|
||||
6 => (Action::Language, true),
|
||||
7 => (Action::Accessibility, true),
|
||||
_ => (Action::None, false),
|
||||
_ => (Action::None, true),
|
||||
}
|
||||
);
|
||||
if id == 5 {
|
||||
assert!(matches!(
|
||||
title.mode,
|
||||
Mode::Multiplayer(crate::multiplayer::Screen::Friend { .. })
|
||||
));
|
||||
title.mode = Mode::Main;
|
||||
}
|
||||
}
|
||||
for id in [2, 3] {
|
||||
assert_eq!(buttons.iter().find(|b| b.id == id).unwrap().y, y + 96.0);
|
||||
|
||||
@@ -38,7 +38,7 @@ pub(super) fn reset_icon(saves: &Path, folder: &str) -> crate::Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// `LevelStorageAccess.deleteLevel`, shared by both menu styles. The world's
|
||||
/// `LevelStorageAccess.deleteLevel`. The world's
|
||||
/// session lock is taken first, so a world open in this or another instance is
|
||||
/// refused rather than pulled from under it; everything but the lock goes,
|
||||
/// then the lock is released and removed with the folder. A failed pass (a
|
||||
|
||||
@@ -3,8 +3,9 @@
|
||||
//! Vanilla draws each column as one camera-facing quad whose texture
|
||||
//! coordinates run past 0..1 (`v` advances a quarter of the texture per block,
|
||||
//! so `rain.png` repeats every 4 blocks) and relies on a repeating sampler.
|
||||
//! Horizon samples the sprite from its atlas, so [`tile`] splits a quad at
|
||||
//! every whole texture repeat into pieces that stay inside the sprite.
|
||||
//! The live renderer repeats UVs inside the atlas sprite in its shader, using
|
||||
//! cached coordinate-only [`Parameters`]. The reference [`tile`] path splits
|
||||
//! at whole repeats and remains available for CPU callers and parity probes.
|
||||
use horizon_core::random::{LegacyRandom, RandomSource};
|
||||
|
||||
/// `WeatherEffectRenderer.ColumnInstance`.
|
||||
@@ -47,6 +48,176 @@ pub fn column_random(x: i32, z: i32) -> LegacyRandom {
|
||||
LegacyRandom::new(i64::from(column_seed(x, z)))
|
||||
}
|
||||
|
||||
/// Coordinate-only random values. Keep the snow bases as doubles: rounding them
|
||||
/// before adding the float drift changes vanilla's UVs at rounding boundaries.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct Parameters {
|
||||
pub rain_speed: f32,
|
||||
pub rain_tick_offset: f32,
|
||||
pub snow_base: [f64; 2],
|
||||
pub snow_drift: [f32; 2],
|
||||
}
|
||||
impl Parameters {
|
||||
pub fn new(x: i32, z: i32) -> Self {
|
||||
let rain_speed = 3.0 + column_random(x, z).next_float();
|
||||
let mut random = column_random(x, z);
|
||||
let u = random.next_double();
|
||||
let du = random.next_gaussian() as f32;
|
||||
let v = random.next_double();
|
||||
let dv = random.next_gaussian() as f32;
|
||||
Self {
|
||||
rain_speed,
|
||||
rain_tick_offset: (x
|
||||
.wrapping_mul(x)
|
||||
.wrapping_mul(3121)
|
||||
.wrapping_add(x.wrapping_mul(45_238_971))
|
||||
.wrapping_add(z.wrapping_mul(z).wrapping_mul(418_711))
|
||||
.wrapping_add(z.wrapping_mul(13761))
|
||||
& 255) as f32,
|
||||
snow_base: [u, v],
|
||||
snow_drift: [du, dv],
|
||||
}
|
||||
}
|
||||
|
||||
/// CPU reference for fixtures and GPU differential tests. The public random
|
||||
/// source helpers below retain their original draw/advancement semantics.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn column(
|
||||
self,
|
||||
snow: bool,
|
||||
ticks: i64,
|
||||
x: i32,
|
||||
bottom_y: i32,
|
||||
top_y: i32,
|
||||
z: i32,
|
||||
light_coords: i32,
|
||||
partial: f32,
|
||||
) -> Column {
|
||||
let time = (ticks & 131_071) as f32 + partial;
|
||||
let (u_offset, v_offset, light_coords) = if snow {
|
||||
let u = (self.snow_base[0] + f64::from(time * 0.01 * self.snow_drift[0])) as f32;
|
||||
let v = (self.snow_base[1] + f64::from(time * self.snow_drift[1] * 0.001)) as f32;
|
||||
let fall = -((ticks & 511) as f32 + partial) / 512.0;
|
||||
let (block, sky) = (light_coords >> 4 & 15, light_coords >> 20 & 15);
|
||||
(
|
||||
u,
|
||||
fall + v,
|
||||
((block * 3 + 15) / 4) << 4 | ((sky * 3 + 15) / 4) << 20,
|
||||
)
|
||||
} else {
|
||||
let offset = -(((ticks & 131_071) as f32 + self.rain_tick_offset) + partial) / 32.0
|
||||
* self.rain_speed;
|
||||
(0.0, offset % 32.0, light_coords)
|
||||
};
|
||||
Column {
|
||||
x,
|
||||
z,
|
||||
bottom_y,
|
||||
top_y,
|
||||
u_offset,
|
||||
v_offset,
|
||||
light_coords,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Direct-mapped 32x32 cache: at most 1024 coordinate keys, including after
|
||||
/// teleports or radius changes. Full keys disambiguate collisions and wrapping.
|
||||
/// Nothing world-dependent is cached, so dimension/biome/pack changes need no
|
||||
/// invalidation; the caller still samples heights, precipitation and light.
|
||||
pub struct ParameterCache {
|
||||
entries: Box<[Option<((i32, i32), Parameters)>]>,
|
||||
}
|
||||
impl Default for ParameterCache {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
entries: vec![None; 32 * 32].into_boxed_slice(),
|
||||
}
|
||||
}
|
||||
}
|
||||
impl ParameterCache {
|
||||
pub fn get(&mut self, x: i32, z: i32) -> Parameters {
|
||||
let index = ((z as u32 & 31) * 32 + (x as u32 & 31)) as usize;
|
||||
let entry = &mut self.entries[index];
|
||||
if let Some((key, parameters)) = entry
|
||||
&& *key == (x, z)
|
||||
{
|
||||
return *parameters;
|
||||
}
|
||||
let parameters = Parameters::new(x, z);
|
||||
*entry = Some(((x, z), parameters));
|
||||
parameters
|
||||
}
|
||||
}
|
||||
|
||||
/// One unsplit camera-relative weather vertex. UV animation and atlas-local
|
||||
/// repetition happen in the weather shader, rather than rebuilding tiled quads.
|
||||
#[repr(C)]
|
||||
#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)]
|
||||
pub struct Vertex {
|
||||
pub pos: [f32; 3],
|
||||
pub uv: [f32; 2],
|
||||
pub rect: [f32; 4],
|
||||
pub animation: [f32; 4],
|
||||
pub bases: [u32; 4],
|
||||
pub color: u32,
|
||||
pub light: u32,
|
||||
pub snow: u32,
|
||||
}
|
||||
|
||||
/// Current ticks are masked on the CPU before conversion to float, including
|
||||
/// negative/large tick values. Do not use the renderer's unbounded game_time.
|
||||
#[repr(C)]
|
||||
#[derive(Clone, Copy, Debug, bytemuck::Pod, bytemuck::Zeroable)]
|
||||
pub struct Time {
|
||||
pub values: [f32; 4],
|
||||
}
|
||||
impl Time {
|
||||
pub fn new(ticks: i64, partial: f32) -> Self {
|
||||
Self {
|
||||
values: [(ticks & 131_071) as f32, (ticks & 511) as f32, partial, 0.0],
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Emit a single quad, retaining column_quad's position, fade, UV rounding and
|
||||
/// light semantics. The zero phase leaves the shader to animate both UV axes.
|
||||
pub fn vertices(
|
||||
column: &Column,
|
||||
parameters: Parameters,
|
||||
snow: bool,
|
||||
camera: [f64; 3],
|
||||
radius: i32,
|
||||
intensity: f32,
|
||||
rect: [f32; 4],
|
||||
) -> [Vertex; 4] {
|
||||
let quad = column_quad(
|
||||
column,
|
||||
camera,
|
||||
if snow { 0.8 } else { 1.0 },
|
||||
radius,
|
||||
intensity,
|
||||
);
|
||||
let lc = column.light_coords;
|
||||
let light = ((lc >> 20 & 15) * 16) as u32 | (((lc >> 4 & 15) * 16) as u32) << 8;
|
||||
let [u, v] = parameters.snow_base.map(f64::to_bits);
|
||||
quad.map(|q| Vertex {
|
||||
pos: q.pos,
|
||||
uv: q.uv,
|
||||
rect,
|
||||
animation: [
|
||||
parameters.rain_speed,
|
||||
parameters.rain_tick_offset,
|
||||
parameters.snow_drift[0],
|
||||
parameters.snow_drift[1],
|
||||
],
|
||||
bases: [u as u32, (u >> 32) as u32, v as u32, (v >> 32) as u32],
|
||||
color: q.color,
|
||||
light,
|
||||
snow: u32::from(snow),
|
||||
})
|
||||
}
|
||||
|
||||
/// `createRainColumnInstance`.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn rain_column(
|
||||
@@ -140,8 +311,8 @@ pub fn column_quad(
|
||||
let t = (distance_sq / radius_sq).min(1.0);
|
||||
let alpha = (max_alpha + t * (0.5 - max_alpha)) * intensity;
|
||||
let color = ((alpha * 255.0).floor() as i32 as u32) << 24 | 0xFF_FFFF;
|
||||
let index =
|
||||
(column.z - camera[2].floor() as i32 + 16) * 32 + column.x - camera[0].floor() as i32 + 16;
|
||||
let index = (column.z - camera[2].floor() as i32 + 16) * 32
|
||||
+ (column.x - camera[0].floor() as i32 + 16);
|
||||
let (size_x, size_z) = column_size(index as usize);
|
||||
let (half_x, half_z) = (size_x / 2.0, size_z / 2.0);
|
||||
let (x0, x1) = (relative_x - half_x, relative_x + half_x);
|
||||
@@ -245,6 +416,82 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cached_parameters_match_original_random_draws() {
|
||||
let mut cache = ParameterCache::default();
|
||||
for i in 0..2048i32 {
|
||||
let x = i.wrapping_mul(45_238_971);
|
||||
let z = i.wrapping_mul(-418_711).wrapping_add(i32::MIN);
|
||||
for ticks in [i64::MIN, -1, 0, 511, 512, 131_071, 131_072, i64::MAX] {
|
||||
for partial in [0.0, 0.5, 0.999] {
|
||||
for snow in [false, true] {
|
||||
let mut random = column_random(x, z);
|
||||
let reference = if snow {
|
||||
snow_column(&mut random, ticks, x, -64, 320, z, 0xf000f0, partial)
|
||||
} else {
|
||||
rain_column(&mut random, ticks, x, -64, 320, z, 0xf000f0, partial)
|
||||
};
|
||||
assert_eq!(
|
||||
cache
|
||||
.get(x, z)
|
||||
.column(snow, ticks, x, -64, 320, z, 0xf000f0, partial),
|
||||
reference
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parameter_cache_reuses_full_keys_and_stays_bounded() {
|
||||
let mut cache = ParameterCache::default();
|
||||
let expected = cache.get(-1, i32::MAX);
|
||||
// A changed entry proves that a hit does not regenerate random values.
|
||||
let index = 31 * 32 + 31;
|
||||
cache.entries[index].as_mut().unwrap().1.rain_speed = 123.0;
|
||||
assert_eq!(cache.get(-1, i32::MAX).rain_speed, 123.0);
|
||||
// Colliding positions must replace the entry, rather than reuse it.
|
||||
cache.get(31, -1);
|
||||
assert_eq!(cache.get(-1, i32::MAX).rain_speed, expected.rain_speed);
|
||||
for i in 0..100_000i32 {
|
||||
cache.get(i.wrapping_mul(3121), i.wrapping_mul(418_711));
|
||||
}
|
||||
assert_eq!(cache.entries.len(), 1024);
|
||||
assert!(cache.entries.iter().flatten().count() <= 1024);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unsplit_vertices_keep_live_geometry_light_and_atlas_inputs() {
|
||||
let x = i32::MAX - 5;
|
||||
let z = i32::MIN + 5;
|
||||
let parameters = Parameters::new(x, z);
|
||||
let camera = [f64::from(x) - 2.25, 80.75, f64::from(z) + 0.25];
|
||||
for (bottom_y, top_y, light_coords, radius, intensity, rect) in [
|
||||
(64, 90, 0, 5, 0.25, [0.1, 0.2, 0.03, 0.04]),
|
||||
(85, 95, 0xf000f0, 10, 1.0, [0.5, 0.5, 0.1, 0.2]),
|
||||
] {
|
||||
let column = Column {
|
||||
x,
|
||||
z,
|
||||
bottom_y,
|
||||
top_y,
|
||||
light_coords,
|
||||
u_offset: 0.0,
|
||||
v_offset: 0.0,
|
||||
};
|
||||
let quad = column_quad(&column, camera, 1.0, radius, intensity);
|
||||
let vertices = vertices(&column, parameters, false, camera, radius, intensity, rect);
|
||||
for (a, b) in vertices.iter().zip(quad) {
|
||||
assert_eq!(a.pos, b.pos);
|
||||
assert_eq!(a.uv, b.uv);
|
||||
assert_eq!(a.color, b.color);
|
||||
assert_eq!(a.rect, rect);
|
||||
assert_eq!(a.light, if light_coords == 0 { 0 } else { 0xf0f0 });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rain_repeats_every_four_blocks() {
|
||||
let column = Column {
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
//! The labelled widgets and focus targets drawn in the last frame, for the
|
||||
//! control socket: a script clicks a button by its label (`horizon-ctl
|
||||
//! click-button Respawn`) or any widget by its id in [`tree`] (`horizon-ctl
|
||||
//! click done`), whatever screen or menu style drew it.
|
||||
//! click done`), whatever screen drew it.
|
||||
use std::cell::RefCell;
|
||||
|
||||
/// A labelled widget in GUI pixels (the coordinates screens take input in).
|
||||
@@ -21,7 +21,7 @@ pub struct Widget {
|
||||
/// navigation").
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum Kind {
|
||||
/// Clicked with A (buttons, switches, segments, sidebar items).
|
||||
/// Clicked with A (buttons, icon buttons, keys).
|
||||
Button,
|
||||
/// Left and right move the value instead of focus; A does nothing (a
|
||||
/// click would jump the handle to the middle). `value` is 0..1 as drawn;
|
||||
@@ -53,9 +53,8 @@ impl Target {
|
||||
thread_local! {
|
||||
/// Buttons drawn since the last `end_frame`, and the last frame's.
|
||||
static WIDGETS: RefCell<(Vec<Widget>, Vec<Widget>, u64)> = const { RefCell::new((Vec::new(), Vec::new(), 0)) };
|
||||
/// Every interactive rectangle (Horizon-style menus' sidebar items,
|
||||
/// switches, sliders, segments; classic sliders, fields and list rows),
|
||||
/// labelled or not: where a controller can move focus. Drawn since
|
||||
/// Every interactive rectangle (sliders, fields, list rows, the
|
||||
/// on-screen keyboard's keys), labelled or not: where a controller can move focus. Drawn since
|
||||
/// `end_frame`, the last frame's, and how many frames rotated.
|
||||
static TARGETS: RefCell<(Vec<Target>, Vec<Target>, u64)> = const { RefCell::new((Vec::new(), Vec::new(), 0)) };
|
||||
}
|
||||
|
||||
@@ -672,6 +672,11 @@ packet!(
|
||||
/// ClientboundSetPassengersPacket: a vehicle and every entity riding it.
|
||||
SetPassengers { vehicle: i32 => VarInt, passengers: Vec<i32> => List<VarInt> }
|
||||
);
|
||||
packet!(
|
||||
/// ClientboundMoveVehiclePacket: the server puts a vehicle its rider
|
||||
/// controls back where it was (PositionAndRotation: x, y, z, yRot, xRot).
|
||||
MoveVehicle { position: [f64; 3] => Vec3d, yaw: f32 => Float, pitch: f32 => Float }
|
||||
);
|
||||
/// ClientboundSetEquipmentPacket: (EquipmentSlot ordinal, stack) pairs.
|
||||
pub struct Equipment;
|
||||
impl Codec<Vec<(u8, Option<Stack>)>> for Equipment {
|
||||
@@ -1529,6 +1534,7 @@ packet_enum!(Clientbound, crate::ids::play::clientbound {
|
||||
SetHeldSlot(SetHeldSlot) = SET_HELD_SLOT,
|
||||
SetObjective(SetObjective) = SET_OBJECTIVE,
|
||||
SetPassengers(SetPassengers) = SET_PASSENGERS,
|
||||
MoveVehicle(MoveVehicle) = MOVE_VEHICLE,
|
||||
ProjectilePower(ProjectilePower) = PROJECTILE_POWER,
|
||||
SetPlayerInventory(SetPlayerInventory) = SET_PLAYER_INVENTORY,
|
||||
SetPlayerTeam(SetPlayerTeam) = SET_PLAYER_TEAM,
|
||||
@@ -1802,6 +1808,15 @@ packet!(
|
||||
packet!(MovePlayerPosRot { x: f64 => Double, y: f64 => Double, z: f64 => Double, yaw: f32 => Float, pitch: f32 => Float, flags: u8 => UByte });
|
||||
packet!(MovePlayerRot { yaw: f32 => Float, pitch: f32 => Float, flags: u8 => UByte });
|
||||
packet!(MovePlayerStatus { flags: u8 => UByte });
|
||||
packet!(
|
||||
/// ServerboundMoveVehiclePacket: where the rider moved the vehicle it
|
||||
/// controls (PositionAndRotation, then onGround).
|
||||
MoveVehicleRequest { position: [f64; 3] => Vec3d, yaw: f32 => Float, pitch: f32 => Float, on_ground: bool => Bool }
|
||||
);
|
||||
packet!(
|
||||
/// ServerboundPaddleBoatPacket: the boat's left and right paddles.
|
||||
PaddleBoat { left: bool => Bool, right: bool => Bool }
|
||||
);
|
||||
packet!(PickItemFromBlock { pos: [i32; 3] => Pos, include_data: bool => Bool });
|
||||
packet!(
|
||||
/// ServerboundPlayerActionPacket.Action: 0 start destroy, 1 change destroy
|
||||
@@ -1869,6 +1884,8 @@ packet_enum!(Serverbound, crate::ids::play::serverbound {
|
||||
MovePlayerPosRot(MovePlayerPosRot) = MOVE_PLAYER_POS_ROT,
|
||||
MovePlayerRot(MovePlayerRot) = MOVE_PLAYER_ROT,
|
||||
MovePlayerStatus(MovePlayerStatus) = MOVE_PLAYER_STATUS_ONLY,
|
||||
MoveVehicle(MoveVehicleRequest) = MOVE_VEHICLE,
|
||||
PaddleBoat(PaddleBoat) = PADDLE_BOAT,
|
||||
PickItemFromBlock(PickItemFromBlock) = PICK_ITEM_FROM_BLOCK,
|
||||
PingRequest(crate::packets::status::Ping) = PING_REQUEST,
|
||||
PlayerAbilities(PlayerAbilitiesRequest) = PLAYER_ABILITIES,
|
||||
|
||||
@@ -5,7 +5,7 @@ This server receives what players choose to send (performance summaries, crash a
|
||||
cargo run --release # in this folder: its own workspace, like the launcher's
|
||||
PORT=8080 HORIZON_TELEMETRY_DB=/data/telemetry.sqlite3 horizon-telemetry-server
|
||||
|
||||
The launcher sends to it when `HORIZON_TELEMETRY_URL` is set (and to `DEFAULT_ENDPOINT` in `crates/horizon-telemetry` once there is one).
|
||||
It runs at **https://telemetry.playhorizon.dev** (`DEFAULT_ENDPOINT` in `crates/horizon-telemetry`). The game and the launcher use it unless `HORIZON_TELEMETRY_URL` names another server, or is `off` (tests and automated runs send nothing).
|
||||
|
||||
## Endpoints
|
||||
|
||||
@@ -14,11 +14,34 @@ The launcher sends to it when `HORIZON_TELEMETRY_URL` is set (and to `DEFAULT_EN
|
||||
| `POST /v1/batch` | A zstd batch (`Content-Encoding: zstd`, at most 256 KiB, 1 MiB inflated, 64 items). Returns 204. Returns 400 for a bad batch, 413 for one too large, 415 if it is not zstd, 429 when over a limit. |
|
||||
| `DELETE /v1/installs/<id>` | Deletes everything that install sent. Its share of the daily totals is rebuilt at once. |
|
||||
| `GET /v1/aggregate?days=30` | The totals the website reads. Cached 10 minutes, with `Access-Control-Allow-Origin` set to the website. |
|
||||
| `GET /v1/benchmarks/summary` | Players' benchmark uploads grouped by GPU, CPU, render distance and game, for the website's Benchmarks page (below). Cached 10 minutes, same `Access-Control-Allow-Origin`. |
|
||||
| `POST /v1/live` | A game's "I'm playing" ping (JSON, at most 512 bytes). Returns 204. Returns 400 for a bad ping, 413 for one too large, 429 over the address's limit, 503 when it holds `LIVE_MAX_SESSIONS` already. |
|
||||
| `GET /v1/live` | How many play now, rounded: `playing`, `lan`, `versions`, `platforms`. Made again at most every 15 seconds, with the same `Access-Control-Allow-Origin`. |
|
||||
| `GET /healthz` | `ok` |
|
||||
|
||||
The totals are grouped per version, OS, GPU vendor and render distance. Each group has its sessions, install-days, hours played, the 14 frame-time buckets summed, and the mean p50 and p99 frame times. Groups with fewer than 5 install-days are left out. The totals also list crash counts per version and the newest 50 benchmark uploads.
|
||||
The totals are grouped per version, OS, GPU vendor and render distance. Each group has its sessions, install-days, hours played, the 14 frame-time buckets summed, and the mean p50 and p99 frame times. Groups with fewer than 5 install-days are left out. The totals also list crash counts per version. Benchmark uploads are published only through the summary below, never one by one.
|
||||
|
||||
## Benchmarks summary
|
||||
|
||||
`src/summary.rs` makes it with the same rules as `website/scripts/benchmarks.mjs`, which bakes the page's fallback copy; both are tested against the same fixtures (`website/scripts/fixtures/benchmarks/`).
|
||||
|
||||
- Only reports that compare: a version 1 `horizon-benchmark-report` of the standard flight over the four scenes, VSync off, no frame cap, on screen, from Horizon or plain vanilla, naming its GPU and CPU.
|
||||
- A group (GPU, CPU, render distance, game) is published only with **at least 3 different installs**. Each install counts once: the median of its runs, then the median across installs.
|
||||
- Out go the names, the counts, the newest three versions and the medians. Never an install ID, a day, an OS version, a driver, a memory size or a screen.
|
||||
|
||||
```json
|
||||
{
|
||||
"format": "horizon-benchmark-summary", "version": 1, "generated": "2026-10-22T20:00:00Z", "min_installs": 3,
|
||||
"groups": [{
|
||||
"gpu": "NVIDIA GeForce RTX 4080", "cpu": "13th Gen Intel Core i7-13700KF", "render_distance": 12,
|
||||
"game": "horizon", "source": "players", "installs": 3, "reports": 4, "versions": ["v0.2.1", "v0.2.0"],
|
||||
"medians": { "avg_fps": 515, "low_1pct_fps": 120, "p95_ms": 3.5, "world_ms": 4500,
|
||||
"chunk_load_ms": 1400, "rss_peak_mb": 1450, "rss_steady_mb": 1250 }
|
||||
}]
|
||||
}
|
||||
```
|
||||
|
||||
Frame rates are whole numbers, milliseconds have one decimal under 10, megabytes are whole. Groups come most installs first. A deleted install leaves its groups at once.
|
||||
|
||||
## Storage
|
||||
|
||||
@@ -45,7 +68,7 @@ All are environment variables:
|
||||
- `HORIZON_TELEMETRY_MIN_INSTALL_DAYS` (5)
|
||||
- `HORIZON_TELEMETRY_REQUESTS_PER_HOUR` per address (60, bursts of 6)
|
||||
- `HORIZON_TELEMETRY_ITEMS_PER_DAY` per install (100)
|
||||
- `HORIZON_TELEMETRY_TRUST_PROXY=1` behind a proxy (the client's address is then the first of `X-Forwarded-For`)
|
||||
- `HORIZON_TELEMETRY_TRUST_PROXY=1` behind a proxy (the client's address is then the proxy's `X-Real-IP`, else the last `X-Forwarded-For` entry; it is used only for the rate limits, in memory, and never stored or logged)
|
||||
- `HORIZON_TELEMETRY_ALLOW_ORIGIN` (`https://playhorizon.dev`)
|
||||
- `HORIZON_TELEMETRY_LIVE_PER_HOUR` per address, pings and reads (600, bursts of 60: ten players behind one address)
|
||||
- `HORIZON_TELEMETRY_LIVE_WINDOW_SECONDS` (120)
|
||||
@@ -55,6 +78,14 @@ All are environment variables:
|
||||
|
||||
`Dockerfile` builds it from the repository root (`docker build -f crates/horizon-telemetry-server/Dockerfile .`). The database goes on a volume mounted at `/data`.
|
||||
|
||||
On Railway it is a service of the same project as the website:
|
||||
|
||||
- Source: this repository, root directory `/` (the Dockerfile needs the shared crate), config file `/crates/horizon-telemetry-server/railway.json` (Dockerfile build, health check `/healthz`, one replica in `europe-west4`, Amsterdam: one SQLite file can't be shared).
|
||||
- A volume mounted at `/data`. The Dockerfile already sets `HORIZON_TELEMETRY_DB=/data/telemetry.sqlite3` and `HORIZON_TELEMETRY_TRUST_PROXY=1`; Railway sets `PORT`.
|
||||
- The custom domain `telemetry.playhorizon.dev`: a `CNAME` at Porkbun to the target Railway gives.
|
||||
|
||||
Check it with `curl https://telemetry.playhorizon.dev/healthz`.
|
||||
|
||||
At Railway's prices (RAM $10/GB-month, CPU $20/vCPU-month, volumes $0.15/GB-month, egress $0.05/GB), one more service with a 1 GB volume uses about $0.35 a month:
|
||||
|
||||
- RAM about 15 MB: $0.15
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
{
|
||||
"$schema": "https://railway.com/railway.schema.json",
|
||||
"build": {
|
||||
"builder": "DOCKERFILE",
|
||||
"dockerfilePath": "crates/horizon-telemetry-server/Dockerfile",
|
||||
"watchPatterns": [
|
||||
"/crates/horizon-telemetry/**",
|
||||
"/crates/horizon-telemetry-server/**",
|
||||
"/Cargo.toml"
|
||||
]
|
||||
},
|
||||
"deploy": {
|
||||
"healthcheckPath": "/healthz",
|
||||
"healthcheckTimeout": 60,
|
||||
"restartPolicyType": "ON_FAILURE",
|
||||
"restartPolicyMaxRetries": 5,
|
||||
"multiRegionConfig": {
|
||||
"europe-west4-drams3a": { "numReplicas": 1 }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -3,6 +3,8 @@
|
||||
//! - `POST /v1/batch`: a zstd batch from the launcher, checked by `horizon_telemetry::batch`.
|
||||
//! - `DELETE /v1/installs/<id>`: everything an install sent goes.
|
||||
//! - `GET /v1/aggregate?days=30`: the anonymous totals the website reads, cached.
|
||||
//! - `GET /v1/benchmarks/summary`: players' benchmark results grouped by GPU and CPU, groups of at
|
||||
//! least 3 installs only (`summary`), cached; the website's Benchmarks page reads it.
|
||||
//! - `POST /v1/live`: a game's anonymous "I'm playing" ping (`live`, in memory only).
|
||||
//! - `GET /v1/live`: how many play now, rounded, cached briefly.
|
||||
//! - `GET /healthz`.
|
||||
@@ -26,6 +28,7 @@ use horizon_telemetry::batch;
|
||||
|
||||
pub mod live;
|
||||
pub mod store;
|
||||
pub mod summary;
|
||||
|
||||
use horizon_telemetry::live::{MAX_PING_BYTES, Ping};
|
||||
use live::Live;
|
||||
@@ -40,7 +43,8 @@ pub struct Config {
|
||||
pub requests_per_hour: f64,
|
||||
/// Items one install may send a day.
|
||||
pub items_per_day: u32,
|
||||
/// Behind a proxy (Railway, Fly…): the client's address is the first of X-Forwarded-For.
|
||||
/// Behind a proxy (Railway, Fly…): the client's address is the proxy's `X-Real-IP`, else the
|
||||
/// last `X-Forwarded-For` entry.
|
||||
pub trust_proxy: bool,
|
||||
/// The website allowed to read the totals from a browser.
|
||||
pub allow_origin: String,
|
||||
@@ -117,6 +121,8 @@ pub struct App {
|
||||
live_cache: Mutex<Option<(Instant, String)>>,
|
||||
/// `/v1/aggregate` answers by `days`, with when they were made.
|
||||
cache: Mutex<HashMap<u32, (Instant, String)>>,
|
||||
/// `/v1/benchmarks/summary`'s answer and when it was made.
|
||||
summary_cache: Mutex<Option<(Instant, String)>>,
|
||||
/// Today, in days since 1970 (a test moves it).
|
||||
today: Box<dyn Fn() -> u32 + Send + Sync>,
|
||||
}
|
||||
@@ -148,6 +154,7 @@ impl App {
|
||||
live: Mutex::new(live),
|
||||
live_cache: Mutex::default(),
|
||||
cache: Mutex::default(),
|
||||
summary_cache: Mutex::default(),
|
||||
today,
|
||||
})
|
||||
}
|
||||
@@ -170,20 +177,26 @@ impl App {
|
||||
self.live.lock().unwrap_or_else(|e| e.into_inner())
|
||||
}
|
||||
|
||||
/// The address requests are counted under, for the rate limits only: kept in memory, never
|
||||
/// stored or logged. Behind a proxy (Railway) the TCP peer is the proxy, so it is the proxy's
|
||||
/// `X-Real-IP`, else the last `X-Forwarded-For` entry: the one the proxy added, which a client
|
||||
/// can't choose (the first one it can).
|
||||
fn client(&self, headers: &HeaderMap, peer: Option<SocketAddr>) -> IpAddr {
|
||||
let header = |name: &str| headers.get(name)?.to_str().ok();
|
||||
let forwarded = self
|
||||
.config
|
||||
.trust_proxy
|
||||
.then(|| {
|
||||
headers
|
||||
.get("x-forwarded-for")?
|
||||
.to_str()
|
||||
.ok()?
|
||||
.split(',')
|
||||
.next()?
|
||||
.trim()
|
||||
.parse()
|
||||
.ok()
|
||||
header("x-real-ip")
|
||||
.and_then(|ip| ip.trim().parse().ok())
|
||||
.or_else(|| {
|
||||
header("x-forwarded-for")?
|
||||
.rsplit(',')
|
||||
.next()?
|
||||
.trim()
|
||||
.parse()
|
||||
.ok()
|
||||
})
|
||||
})
|
||||
.flatten();
|
||||
forwarded
|
||||
@@ -196,6 +209,12 @@ impl App {
|
||||
self.store().newest_day(install).ok().flatten()
|
||||
}
|
||||
|
||||
/// Drops the cached public answers (after a deletion or expiry).
|
||||
fn forget_cached(&self) {
|
||||
self.cache.lock().unwrap_or_else(|e| e.into_inner()).clear();
|
||||
*self.summary_cache.lock().unwrap_or_else(|e| e.into_inner()) = None;
|
||||
}
|
||||
|
||||
/// Daily upkeep: totals rebuilt, expired rows removed, idle rate-limit entries and live
|
||||
/// sessions forgotten.
|
||||
pub fn maintain(&self) -> rusqlite::Result<usize> {
|
||||
@@ -209,7 +228,7 @@ impl App {
|
||||
}
|
||||
self.live().forget_expired(Instant::now());
|
||||
if removed > 0 {
|
||||
self.cache.lock().unwrap_or_else(|e| e.into_inner()).clear();
|
||||
self.forget_cached();
|
||||
}
|
||||
Ok(removed)
|
||||
}
|
||||
@@ -288,7 +307,7 @@ async fn forget(State(app): State<Arc<App>>, Path(id): Path<String>, req: Reques
|
||||
};
|
||||
match app.store().delete_install(&install) {
|
||||
Ok(_) => {
|
||||
app.cache.lock().unwrap_or_else(|e| e.into_inner()).clear();
|
||||
app.forget_cached();
|
||||
StatusCode::NO_CONTENT.into_response()
|
||||
}
|
||||
Err(e) => {
|
||||
@@ -338,6 +357,60 @@ async fn aggregate(State(app): State<Arc<App>>, Query(window): Query<Window>) ->
|
||||
json_response(&app, json, CACHE_FOR.as_secs())
|
||||
}
|
||||
|
||||
/// `GET /v1/benchmarks/summary`: players' benchmark groups (`summary`), made again at most every
|
||||
/// ten minutes.
|
||||
async fn benchmarks(State(app): State<Arc<App>>) -> Response {
|
||||
let cached = app
|
||||
.summary_cache
|
||||
.lock()
|
||||
.unwrap_or_else(|e| e.into_inner())
|
||||
.as_ref()
|
||||
.filter(|(at, _)| at.elapsed() < CACHE_FOR)
|
||||
.map(|(_, json)| json.clone());
|
||||
let json = match cached {
|
||||
Some(json) => json,
|
||||
None => {
|
||||
let oldest = (app.today)().saturating_sub(app.config.retention_days);
|
||||
let uploads = match app.store().benchmark_uploads(oldest) {
|
||||
Ok(uploads) => uploads,
|
||||
Err(e) => {
|
||||
eprintln!("horizon-telemetry-server: could not read the benchmarks: {e}");
|
||||
return status(StatusCode::SERVICE_UNAVAILABLE, "try again later");
|
||||
}
|
||||
};
|
||||
let json = summary::summary(&uploads, summary::MIN_INSTALLS, &utc_now()).to_string();
|
||||
*app.summary_cache.lock().unwrap_or_else(|e| e.into_inner()) =
|
||||
Some((Instant::now(), json.clone()));
|
||||
json
|
||||
}
|
||||
};
|
||||
json_response(&app, json, CACHE_FOR.as_secs())
|
||||
}
|
||||
|
||||
/// Now as `YYYY-MM-DDTHH:MM:SSZ`.
|
||||
fn utc_now() -> String {
|
||||
let secs = std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.map_or(0, |d| d.as_secs());
|
||||
let (days, rest) = (secs / 86_400, secs % 86_400);
|
||||
// Days since 1970 to a civil date (Howard Hinnant's algorithm).
|
||||
let z = days as i64 + 719_468;
|
||||
let era = z.div_euclid(146_097);
|
||||
let doe = z - era * 146_097;
|
||||
let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
|
||||
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
|
||||
let mp = (5 * doy + 2) / 153;
|
||||
let day = doy - (153 * mp + 2) / 5 + 1;
|
||||
let month = if mp < 10 { mp + 3 } else { mp - 9 };
|
||||
let year = yoe + era * 400 + i64::from(month <= 2);
|
||||
format!(
|
||||
"{year:04}-{month:02}-{day:02}T{:02}:{:02}:{:02}Z",
|
||||
rest / 3600,
|
||||
rest / 60 % 60,
|
||||
rest % 60
|
||||
)
|
||||
}
|
||||
|
||||
/// `POST /v1/live`: one "I'm playing". 204, or 400 for a bad ping, 413 for one too large, 429
|
||||
/// over the address's limit, 503 when the table is full.
|
||||
async fn ping(State(app): State<Arc<App>>, req: Request) -> Response {
|
||||
@@ -407,6 +480,7 @@ pub fn router(app: Arc<App>) -> Router {
|
||||
.route("/v1/live", post(ping).get(playing))
|
||||
.route("/v1/installs/{id}", delete(forget))
|
||||
.route("/v1/aggregate", get(aggregate))
|
||||
.route("/v1/benchmarks/summary", get(benchmarks))
|
||||
.route("/healthz", get(|| async { "ok" }))
|
||||
.with_state(app)
|
||||
}
|
||||
|
||||
@@ -357,27 +357,33 @@ impl Store {
|
||||
})?
|
||||
.collect::<Result<_, _>>()?
|
||||
};
|
||||
let benchmarks: Vec<serde_json::Value> = {
|
||||
let mut q = self.db.prepare(
|
||||
"SELECT day, version, body FROM reports WHERE kind = ?1 AND day BETWEEN ?2 AND ?3
|
||||
ORDER BY rowid DESC LIMIT 50",
|
||||
)?;
|
||||
q.query_map(params![kind_code(Kind::Benchmark), from, to], |r| {
|
||||
let body: Vec<u8> = r.get(2)?;
|
||||
Ok(serde_json::json!({
|
||||
"day": r.get::<_, u32>(0)?, "version": r.get::<_, String>(1)?, "report": inflate(&body),
|
||||
}))
|
||||
})?
|
||||
.collect::<Result<_, _>>()?
|
||||
};
|
||||
Ok(serde_json::json!({
|
||||
"from_day": from, "to_day": to, "min_install_days": k,
|
||||
"bucket_edges_ms": BUCKET_EDGES_MS.map(|e| (f64::from(e) * 10.0).round() / 10.0),
|
||||
"totals": { "sessions": sessions, "hours": (hours * 10.0).round() / 10.0 },
|
||||
"groups": out, "crashes_by_version": crashes, "benchmarks": benchmarks,
|
||||
"groups": out, "crashes_by_version": crashes,
|
||||
}))
|
||||
}
|
||||
|
||||
/// Every benchmark upload received since `from_day`, with its install (to count installs, never shown)
|
||||
/// and release, for `summary`.
|
||||
pub fn benchmark_uploads(
|
||||
&self,
|
||||
from_day: u32,
|
||||
) -> rusqlite::Result<Vec<crate::summary::Upload>> {
|
||||
let mut q = self
|
||||
.db
|
||||
.prepare("SELECT install, version, body FROM reports WHERE kind = ?1 AND day >= ?2")?;
|
||||
q.query_map(params![kind_code(Kind::Benchmark), from_day], |r| {
|
||||
Ok(crate::summary::Upload {
|
||||
install: r.get(0)?,
|
||||
version: r.get(1)?,
|
||||
report: inflate(&r.get::<_, Vec<u8>>(2)?),
|
||||
})
|
||||
})?
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The day an install's newest row came in, if any (tests, and checking a deletion).
|
||||
pub fn newest_day(&self, install: &[u8]) -> rusqlite::Result<Option<u32>> {
|
||||
self.db
|
||||
|
||||
@@ -0,0 +1,266 @@
|
||||
//! `GET /v1/benchmarks/summary`: players' benchmark uploads, grouped for the website's Benchmarks page.
|
||||
//!
|
||||
//! The same rules as `website/scripts/benchmarks.mjs` (which builds the page's baked copy), checked against the
|
||||
//! same fixtures (`website/scripts/fixtures/benchmarks/`):
|
||||
//!
|
||||
//! - Only reports that compare: `horizon-benchmark-report` version 1, kind `game`, Horizon or plain vanilla, the
|
||||
//! standard flight over the four scenes, VSync off, no frame cap, drawn on a screen, with a GPU and CPU name.
|
||||
//! - Groups by GPU, CPU, render distance and game. A group is published only with at least `min_installs`
|
||||
//! different installs, so no one can be picked out.
|
||||
//! - Each install counts once: the median of its runs first, then the median across installs.
|
||||
//! - Out go the group's names, its counts, the newest three versions and the medians. Never the install ID, the
|
||||
//! day, the OS version, the driver, the memory size or the screen.
|
||||
use std::collections::{BTreeMap, BTreeSet, HashMap};
|
||||
|
||||
use serde_json::{Value, json};
|
||||
|
||||
pub const FORMAT: &str = "horizon-benchmark-summary";
|
||||
pub const MIN_INSTALLS: usize = 3;
|
||||
pub const SCENES: [&str; 4] = ["village", "forest", "ocean", "mountain"];
|
||||
pub const FIELDS: [&str; 7] = [
|
||||
"avg_fps",
|
||||
"low_1pct_fps",
|
||||
"p95_ms",
|
||||
"world_ms",
|
||||
"chunk_load_ms",
|
||||
"rss_peak_mb",
|
||||
"rss_steady_mb",
|
||||
];
|
||||
|
||||
/// One stored upload: who sent it (only to count installs), the release, and the report.
|
||||
pub struct Upload {
|
||||
pub install: Vec<u8>,
|
||||
pub version: String,
|
||||
pub report: Value,
|
||||
}
|
||||
|
||||
/// "Intel(R) Core(TM) i7" -> "Intel Core i7", spaces collapsed.
|
||||
fn trim(s: &str) -> String {
|
||||
s.replace("(R)", "")
|
||||
.replace("(TM)", "")
|
||||
.replace("(tm)", "")
|
||||
.split_whitespace()
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ")
|
||||
}
|
||||
|
||||
fn game(app: &Value) -> Option<&'static str> {
|
||||
match app.get("name").and_then(Value::as_str) {
|
||||
Some("horizon-client") => Some("horizon"),
|
||||
Some("minecraft") => {
|
||||
let mods = app.get("mods").and_then(Value::as_array);
|
||||
let plain = mods.is_none_or(|m| {
|
||||
m.iter()
|
||||
.all(|m| m.get("name").and_then(Value::as_str) == Some("fabric-loader"))
|
||||
});
|
||||
plain.then_some("vanilla")
|
||||
}
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Why a report can't be compared with the others, or `None` when it can.
|
||||
pub fn rejection(report: &Value) -> Option<&'static str> {
|
||||
if report.get("format").and_then(Value::as_str) != Some("horizon-benchmark-report")
|
||||
|| report.get("version").and_then(Value::as_u64) != Some(1)
|
||||
{
|
||||
return Some("not a version 1 benchmark report");
|
||||
}
|
||||
if report.get("kind").and_then(Value::as_str) != Some("game") {
|
||||
return Some("not a game run");
|
||||
}
|
||||
game(&report["app"])?;
|
||||
let c = &report["conditions"];
|
||||
let scenario = c.get("scenario").and_then(Value::as_str).unwrap_or("");
|
||||
if !(scenario == "standard" || scenario == "flight" || scenario.starts_with("perf_bench:")) {
|
||||
return Some("not the standard flight");
|
||||
}
|
||||
if c.get("vsync") != Some(&Value::Bool(false)) {
|
||||
return Some("VSync on or unknown");
|
||||
}
|
||||
if c.get("fps_cap").is_some_and(|v| !v.is_null()) {
|
||||
return Some("frame rate capped");
|
||||
}
|
||||
if c.get("offscreen") == Some(&Value::Bool(true)) {
|
||||
return Some("offscreen");
|
||||
}
|
||||
if !c.get("render_distance").is_some_and(Value::is_number) {
|
||||
return Some("no render distance");
|
||||
}
|
||||
let phases: BTreeSet<&str> = report["frames"]
|
||||
.as_array()
|
||||
.map(|f| f.iter().filter_map(|f| f["phase"].as_str()).collect())
|
||||
.unwrap_or_default();
|
||||
if !SCENES.iter().all(|s| phases.contains(s)) {
|
||||
return Some("not every scene");
|
||||
}
|
||||
let named = |v: &Value| v.as_str().is_some_and(|s| !trim(s).is_empty());
|
||||
if !named(&report["hardware"]["gpu"]["name"]) || !named(&report["hardware"]["cpu"]) {
|
||||
return Some("no GPU or CPU name");
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn mean(xs: &[f64]) -> Option<f64> {
|
||||
(!xs.is_empty()).then(|| xs.iter().sum::<f64>() / xs.len() as f64)
|
||||
}
|
||||
|
||||
pub fn median(xs: &[f64]) -> Option<f64> {
|
||||
let mut v: Vec<f64> = xs.iter().copied().filter(|x| x.is_finite()).collect();
|
||||
if v.is_empty() {
|
||||
return None;
|
||||
}
|
||||
v.sort_by(f64::total_cmp);
|
||||
let m = v.len() / 2;
|
||||
Some(if v.len() % 2 == 1 {
|
||||
v[m]
|
||||
} else {
|
||||
(v[m - 1] + v[m]) / 2.0
|
||||
})
|
||||
}
|
||||
|
||||
/// fps to integers, milliseconds to a tenth under 10 and to integers above, megabytes to integers.
|
||||
pub fn round(field: &str, x: f64) -> f64 {
|
||||
if field.ends_with("_ms") && x < 10.0 {
|
||||
(x * 10.0).round() / 10.0
|
||||
} else {
|
||||
x.round()
|
||||
}
|
||||
}
|
||||
|
||||
/// Whole numbers as integers (`515`, not `515.0`), as JavaScript writes them.
|
||||
fn number(x: f64) -> Value {
|
||||
if x.fract() == 0.0 && x.abs() < 9e15 {
|
||||
json!(x as i64)
|
||||
} else {
|
||||
json!(x)
|
||||
}
|
||||
}
|
||||
|
||||
/// A report's figures: frame figures averaged over every flight, the rest from its metrics.
|
||||
pub fn figures(report: &Value) -> [Option<f64>; 7] {
|
||||
let frames = report["frames"]
|
||||
.as_array()
|
||||
.map(Vec::as_slice)
|
||||
.unwrap_or(&[]);
|
||||
let avg = |key: &str| {
|
||||
mean(
|
||||
&frames
|
||||
.iter()
|
||||
.filter_map(|f| f[key].as_f64())
|
||||
.collect::<Vec<_>>(),
|
||||
)
|
||||
};
|
||||
let metrics = report["metrics"].as_object();
|
||||
let metric = |name: &str| metrics.and_then(|m| m.get(name)?.get("mean")?.as_f64());
|
||||
let loads: Vec<f64> = metrics
|
||||
.map(|m| {
|
||||
m.iter()
|
||||
.filter(|(k, _)| {
|
||||
k.strip_prefix("chunks.")
|
||||
.and_then(|k| k.strip_suffix(".load_ms"))
|
||||
.is_some_and(|scene| !scene.contains('.'))
|
||||
})
|
||||
.filter_map(|(_, v)| v.get("mean")?.as_f64())
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
[
|
||||
avg("avg_fps"),
|
||||
avg("low_1pct_fps"),
|
||||
avg("p95_ms"),
|
||||
metric("startup.world_ms"),
|
||||
mean(&loads),
|
||||
metric("memory.rss_peak_mb"),
|
||||
metric("memory.rss_steady_mb"),
|
||||
]
|
||||
}
|
||||
|
||||
/// "v0.2.10" after "v0.2.9", dated tags by their numbers: newest first.
|
||||
fn newest_first(a: &str, b: &str) -> std::cmp::Ordering {
|
||||
let n = |v: &str| -> Vec<u64> {
|
||||
v.split(|c: char| !c.is_ascii_digit())
|
||||
.filter(|p| !p.is_empty())
|
||||
.filter_map(|p| p.parse().ok())
|
||||
.collect()
|
||||
};
|
||||
n(b).cmp(&n(a))
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct Group {
|
||||
installs: HashMap<Vec<u8>, Vec<[Option<f64>; 7]>>,
|
||||
reports: usize,
|
||||
versions: BTreeSet<String>,
|
||||
}
|
||||
|
||||
/// Players' groups of at least `min_installs` installs, as `website/scripts/benchmarks.mjs` makes them.
|
||||
pub fn groups(uploads: &[Upload], min_installs: usize) -> Vec<Value> {
|
||||
let mut by: BTreeMap<(String, String, i64, &str), Group> = BTreeMap::new();
|
||||
for u in uploads {
|
||||
if u.install.is_empty() || rejection(&u.report).is_some() {
|
||||
continue;
|
||||
}
|
||||
let r = &u.report;
|
||||
let key = (
|
||||
trim(r["hardware"]["gpu"]["name"].as_str().unwrap_or_default()),
|
||||
trim(r["hardware"]["cpu"].as_str().unwrap_or_default()),
|
||||
r["conditions"]["render_distance"]
|
||||
.as_f64()
|
||||
.unwrap_or_default() as i64,
|
||||
game(&r["app"]).unwrap_or_default(),
|
||||
);
|
||||
let g = by.entry(key).or_default();
|
||||
g.reports += 1;
|
||||
if !u.version.is_empty() {
|
||||
g.versions.insert(u.version.clone());
|
||||
}
|
||||
g.installs
|
||||
.entry(u.install.clone())
|
||||
.or_default()
|
||||
.push(figures(r));
|
||||
}
|
||||
let mut out: Vec<(usize, Value)> = by
|
||||
.into_iter()
|
||||
.filter(|(_, g)| g.installs.len() >= min_installs)
|
||||
.map(|((gpu, cpu, rd, game), g)| {
|
||||
let per_install: Vec<[Option<f64>; 7]> = g
|
||||
.installs
|
||||
.values()
|
||||
.map(|runs| {
|
||||
std::array::from_fn(|i| median(&runs.iter().filter_map(|r| r[i]).collect::<Vec<_>>()))
|
||||
})
|
||||
.collect();
|
||||
let medians: serde_json::Map<String, Value> = FIELDS
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(i, f)| {
|
||||
let m = median(&per_install.iter().filter_map(|r| r[i]).collect::<Vec<_>>());
|
||||
(f.to_string(), m.map_or(Value::Null, |m| number(round(f, m))))
|
||||
})
|
||||
.collect();
|
||||
let mut versions: Vec<String> = g.versions.into_iter().collect();
|
||||
versions.sort_by(|a, b| newest_first(a, b));
|
||||
versions.truncate(3);
|
||||
let installs = g.installs.len();
|
||||
(
|
||||
installs,
|
||||
json!({
|
||||
"gpu": gpu, "cpu": cpu, "render_distance": rd, "game": game, "source": "players",
|
||||
"installs": installs, "reports": g.reports, "versions": versions, "medians": medians,
|
||||
}),
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
// Most installs first, then by GPU and render distance (the map's order).
|
||||
out.sort_by_key(|g| std::cmp::Reverse(g.0));
|
||||
out.into_iter().map(|(_, v)| v).collect()
|
||||
}
|
||||
|
||||
/// The whole answer; `generated` is an RFC 3339 UTC time.
|
||||
pub fn summary(uploads: &[Upload], min_installs: usize, generated: &str) -> Value {
|
||||
json!({
|
||||
"format": FORMAT, "version": 1, "generated": generated, "min_installs": min_installs,
|
||||
"groups": groups(uploads, min_installs),
|
||||
})
|
||||
}
|
||||
@@ -198,14 +198,30 @@ async fn an_address_is_rate_limited() {
|
||||
s.post(&install(9), vec![perf("x", 8)]).await,
|
||||
StatusCode::TOO_MANY_REQUESTS
|
||||
);
|
||||
let from = |forwarded: &str, real: Option<&str>| {
|
||||
let body = batch::encode(&Batch::new(&install(9), vec![perf("x", 8)]));
|
||||
let mut req = Request::post("/v1/batch")
|
||||
.header("x-forwarded-for", forwarded)
|
||||
.header("content-encoding", "zstd");
|
||||
if let Some(ip) = real {
|
||||
req = req.header("x-real-ip", ip);
|
||||
}
|
||||
req.body(Body::from(body)).unwrap()
|
||||
};
|
||||
// A client can't pick its address: the proxy adds the real one last, or sets X-Real-IP.
|
||||
assert_eq!(
|
||||
s.send(from("198.51.100.7, 203.0.113.9", None)).await.0,
|
||||
StatusCode::TOO_MANY_REQUESTS
|
||||
);
|
||||
assert_eq!(
|
||||
s.send(from("198.51.100.7", Some("203.0.113.9"))).await.0,
|
||||
StatusCode::TOO_MANY_REQUESTS
|
||||
);
|
||||
// Another address has its own allowance.
|
||||
let body = batch::encode(&Batch::new(&install(9), vec![perf("x", 8)]));
|
||||
let req = Request::post("/v1/batch")
|
||||
.header("x-forwarded-for", "198.51.100.7, 10.0.0.1")
|
||||
.header("content-encoding", "zstd")
|
||||
.body(Body::from(body))
|
||||
.unwrap();
|
||||
assert_eq!(s.send(req).await.0, StatusCode::NO_CONTENT);
|
||||
assert_eq!(
|
||||
s.send(from("203.0.113.9, 198.51.100.7", None)).await.0,
|
||||
StatusCode::NO_CONTENT
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
||||
@@ -0,0 +1,180 @@
|
||||
//! `GET /v1/benchmarks/summary` against the website's fixtures (website/scripts/fixtures/benchmarks/): the same
|
||||
//! uploads must give the groups `website/scripts/benchmarks.mjs` gives.
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::AtomicU32;
|
||||
|
||||
use axum::body::Body;
|
||||
use axum::http::{Request, StatusCode};
|
||||
use horizon_telemetry::Item;
|
||||
use horizon_telemetry::batch::{self, Batch};
|
||||
use horizon_telemetry::payload::{Payload, Source};
|
||||
use horizon_telemetry_server::store::Store;
|
||||
use horizon_telemetry_server::summary::{self, Upload};
|
||||
use horizon_telemetry_server::{App, Config, router};
|
||||
use http_body_util::BodyExt;
|
||||
use serde_json::Value;
|
||||
use tower::ServiceExt;
|
||||
|
||||
const FIXTURES: &str = concat!(
|
||||
env!("CARGO_MANIFEST_DIR"),
|
||||
"/../../website/scripts/fixtures/benchmarks"
|
||||
);
|
||||
|
||||
fn items() -> Vec<Value> {
|
||||
std::fs::read_to_string(format!("{FIXTURES}/items.jsonl"))
|
||||
.unwrap()
|
||||
.lines()
|
||||
.filter(|l| !l.trim().is_empty())
|
||||
.map(|l| serde_json::from_str(l).unwrap())
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn expected() -> Value {
|
||||
serde_json::from_str(&std::fs::read_to_string(format!("{FIXTURES}/expected.json")).unwrap())
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
/// The fixtures' short install names as the 32 hex digits real installs have.
|
||||
fn install_id(name: &str) -> String {
|
||||
format!(
|
||||
"{:032x}",
|
||||
name.bytes().fold(0u128, |n, b| n * 257 + u128::from(b))
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_fixtures_give_the_websites_groups() {
|
||||
let uploads: Vec<Upload> = items()
|
||||
.into_iter()
|
||||
.map(|i| Upload {
|
||||
install: i["install_id"]
|
||||
.as_str()
|
||||
.unwrap_or_default()
|
||||
.as_bytes()
|
||||
.to_vec(),
|
||||
version: i["version"].as_str().unwrap_or_default().to_owned(),
|
||||
report: i["data"].clone(),
|
||||
})
|
||||
.collect();
|
||||
let s = summary::summary(&uploads, summary::MIN_INSTALLS, "2026-11-03T00:00:00Z");
|
||||
let want = expected();
|
||||
assert_eq!(s["format"], "horizon-benchmark-summary");
|
||||
assert_eq!(s["version"], 1);
|
||||
assert_eq!(s["min_installs"], want["min_installs"]);
|
||||
assert_eq!(s["groups"], want["groups"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_comparable_runs_count() {
|
||||
let reasons: Vec<&str> = items()
|
||||
.iter()
|
||||
.filter_map(|i| summary::rejection(&i["data"]))
|
||||
.collect();
|
||||
assert_eq!(
|
||||
reasons,
|
||||
[
|
||||
"VSync on or unknown",
|
||||
"offscreen",
|
||||
"frame rate capped",
|
||||
"not every scene",
|
||||
"not the standard flight",
|
||||
"not a version 1 benchmark report"
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn medians_and_rounding() {
|
||||
assert_eq!(summary::median(&[3.0, 1.0, 2.0]), Some(2.0));
|
||||
assert_eq!(summary::median(&[4.0, 1.0, 2.0, 3.0]), Some(2.5));
|
||||
assert_eq!(summary::median(&[f64::NAN]), None);
|
||||
assert_eq!(summary::round("p95_ms", 3.46), 3.5);
|
||||
assert_eq!(summary::round("world_ms", 4512.4), 4512.0);
|
||||
assert_eq!(summary::round("avg_fps", 99.5), 100.0);
|
||||
}
|
||||
|
||||
async fn get(app: &Arc<App>, uri: &str) -> (StatusCode, String, Option<String>) {
|
||||
let res = router(app.clone())
|
||||
.oneshot(Request::get(uri).body(Body::empty()).unwrap())
|
||||
.await
|
||||
.unwrap();
|
||||
let code = res.status();
|
||||
let origin = res
|
||||
.headers()
|
||||
.get("access-control-allow-origin")
|
||||
.map(|v| v.to_str().unwrap().to_owned());
|
||||
let body = res.into_body().collect().await.unwrap().to_bytes();
|
||||
(code, String::from_utf8_lossy(&body).into_owned(), origin)
|
||||
}
|
||||
|
||||
/// Uploaded through `POST /v1/batch` as the launcher sends them, then read back from the endpoint.
|
||||
#[tokio::test]
|
||||
async fn uploads_come_back_grouped_and_anonymous() {
|
||||
let day = Arc::new(AtomicU32::new(20_396));
|
||||
let clock = day.clone();
|
||||
let config = Config {
|
||||
requests_per_hour: 1e6,
|
||||
..Config::default()
|
||||
};
|
||||
let app = App::with_clock(
|
||||
Store::open(":memory:").unwrap(),
|
||||
config,
|
||||
Box::new(move || clock.load(std::sync::atomic::Ordering::SeqCst)),
|
||||
);
|
||||
for i in items() {
|
||||
let Some(name) = i["install_id"].as_str() else {
|
||||
continue; // an item without an install can't be sent
|
||||
};
|
||||
let item = Item::new(
|
||||
Source::Game,
|
||||
i["version"].as_str().unwrap(),
|
||||
Payload::Benchmark(i["data"].clone()),
|
||||
);
|
||||
let body = batch::encode(&Batch::new(&install_id(name), vec![item]));
|
||||
let res = router(app.clone())
|
||||
.oneshot(
|
||||
Request::post("/v1/batch")
|
||||
.header("content-encoding", "zstd")
|
||||
.body(Body::from(body))
|
||||
.unwrap(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(res.status(), StatusCode::NO_CONTENT, "{name}");
|
||||
}
|
||||
|
||||
let (code, body, origin) = get(&app, "/v1/benchmarks/summary").await;
|
||||
assert_eq!(code, StatusCode::OK);
|
||||
assert_eq!(origin.as_deref(), Some("https://playhorizon.dev"));
|
||||
let s: Value = serde_json::from_str(&body).unwrap();
|
||||
assert_eq!(s["groups"], expected()["groups"]);
|
||||
let generated = s["generated"].as_str().unwrap();
|
||||
assert!(
|
||||
generated.len() == 20 && generated.ends_with('Z'),
|
||||
"{generated}"
|
||||
);
|
||||
for secret in [
|
||||
install_id("a1").as_str(),
|
||||
"install_id",
|
||||
"secret-os-version",
|
||||
"secret-driver",
|
||||
"20394",
|
||||
"ram_mb",
|
||||
] {
|
||||
assert!(!body.contains(secret), "{secret} in {body}");
|
||||
}
|
||||
|
||||
// Deleting one of the three installs takes the group below three: it goes at once.
|
||||
let res = router(app.clone())
|
||||
.oneshot(
|
||||
Request::delete(format!("/v1/installs/{}", install_id("a3")))
|
||||
.body(Body::empty())
|
||||
.unwrap(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(res.status(), StatusCode::NO_CONTENT);
|
||||
let (_, body, _) = get(&app, "/v1/benchmarks/summary").await;
|
||||
let s: Value = serde_json::from_str(&body).unwrap();
|
||||
assert_eq!(s["groups"], serde_json::json!([]));
|
||||
}
|
||||
@@ -33,16 +33,21 @@ pub const SCHEMA: u32 = 1;
|
||||
/// and until the player answers nothing new is kept or sent.
|
||||
pub const CONSENT_VERSION: u32 = 1;
|
||||
|
||||
/// The ingest server, or none while there isn't one: then nothing is ever sent (no ping either)
|
||||
/// and the outbox stays within its caps. `HORIZON_TELEMETRY_URL` overrides it (tests, a local
|
||||
/// server).
|
||||
pub const DEFAULT_ENDPOINT: Option<&str> = None;
|
||||
/// The ingest server (`crates/horizon-telemetry-server`, on Railway). `HORIZON_TELEMETRY_URL`
|
||||
/// overrides it (a local server); `HORIZON_TELEMETRY_URL=off` sends nothing at all, no ping
|
||||
/// either (tests and automated runs). What is sent still depends on the player's switches.
|
||||
pub const DEFAULT_ENDPOINT: &str = "https://telemetry.playhorizon.dev";
|
||||
|
||||
/// Where items are sent, if anywhere.
|
||||
pub fn endpoint() -> Option<String> {
|
||||
match std::env::var("HORIZON_TELEMETRY_URL") {
|
||||
Ok(url) if !url.trim().is_empty() => Some(url.trim().trim_end_matches('/').to_owned()),
|
||||
_ => DEFAULT_ENDPOINT.map(str::to_owned),
|
||||
resolve(std::env::var("HORIZON_TELEMETRY_URL").ok().as_deref())
|
||||
}
|
||||
|
||||
fn resolve(var: Option<&str>) -> Option<String> {
|
||||
match var.map(str::trim) {
|
||||
Some("off" | "none" | "0") => None,
|
||||
Some(url) if !url.is_empty() => Some(url.trim_end_matches('/').to_owned()),
|
||||
_ => Some(DEFAULT_ENDPOINT.to_owned()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -100,3 +105,20 @@ pub(crate) mod test_home {
|
||||
dir
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn the_endpoint_defaults_to_the_server_and_can_be_moved_or_turned_off() {
|
||||
assert_eq!(resolve(None).as_deref(), Some(DEFAULT_ENDPOINT));
|
||||
assert_eq!(resolve(Some(" ")).as_deref(), Some(DEFAULT_ENDPOINT));
|
||||
assert_eq!(
|
||||
resolve(Some("http://127.0.0.1:8080/")).as_deref(),
|
||||
Some("http://127.0.0.1:8080")
|
||||
);
|
||||
assert_eq!(resolve(Some("off")), None);
|
||||
assert!(DEFAULT_ENDPOINT.starts_with("https://") && !DEFAULT_ENDPOINT.ends_with('/'));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3,6 +3,6 @@ name = "horizon-theme"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
license = "MIT"
|
||||
description = "Horizon's design tokens and fonts, shared by the launcher and the game's menus"
|
||||
description = "Horizon's design tokens, fonts and icons, shared by the launcher, the website and the game's menus"
|
||||
|
||||
[dependencies]
|
||||
|
||||
@@ -0,0 +1,93 @@
|
||||
Copyright 2021 The Pixelify Sans Project Authors (https://github.com/eifetx/Pixelify-Sans)
|
||||
|
||||
This Font Software is licensed under the SIL Open Font License, Version 1.1.
|
||||
This license is copied below, and is also available with a FAQ at:
|
||||
https://scripts.sil.org/OFL
|
||||
|
||||
|
||||
-----------------------------------------------------------
|
||||
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
|
||||
-----------------------------------------------------------
|
||||
|
||||
PREAMBLE
|
||||
The goals of the Open Font License (OFL) are to stimulate worldwide
|
||||
development of collaborative font projects, to support the font creation
|
||||
efforts of academic and linguistic communities, and to provide a free and
|
||||
open framework in which fonts may be shared and improved in partnership
|
||||
with others.
|
||||
|
||||
The OFL allows the licensed fonts to be used, studied, modified and
|
||||
redistributed freely as long as they are not sold by themselves. The
|
||||
fonts, including any derivative works, can be bundled, embedded,
|
||||
redistributed and/or sold with any software provided that any reserved
|
||||
names are not used by derivative works. The fonts and derivatives,
|
||||
however, cannot be released under any other type of license. The
|
||||
requirement for fonts to remain under this license does not apply
|
||||
to any document created using the fonts or their derivatives.
|
||||
|
||||
DEFINITIONS
|
||||
"Font Software" refers to the set of files released by the Copyright
|
||||
Holder(s) under this license and clearly marked as such. This may
|
||||
include source files, build scripts and documentation.
|
||||
|
||||
"Reserved Font Name" refers to any names specified as such after the
|
||||
copyright statement(s).
|
||||
|
||||
"Original Version" refers to the collection of Font Software components as
|
||||
distributed by the Copyright Holder(s).
|
||||
|
||||
"Modified Version" refers to any derivative made by adding to, deleting,
|
||||
or substituting -- in part or in whole -- any of the components of the
|
||||
Original Version, by changing formats or by porting the Font Software to a
|
||||
new environment.
|
||||
|
||||
"Author" refers to any designer, engineer, programmer, technical
|
||||
writer or other person who contributed to the Font Software.
|
||||
|
||||
PERMISSION & CONDITIONS
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of the Font Software, to use, study, copy, merge, embed, modify,
|
||||
redistribute, and sell modified and unmodified copies of the Font
|
||||
Software, subject to the following conditions:
|
||||
|
||||
1) Neither the Font Software nor any of its individual components,
|
||||
in Original or Modified Versions, may be sold by itself.
|
||||
|
||||
2) Original or Modified Versions of the Font Software may be bundled,
|
||||
redistributed and/or sold with any software, provided that each copy
|
||||
contains the above copyright notice and this license. These can be
|
||||
included either as stand-alone text files, human-readable headers or
|
||||
in the appropriate machine-readable metadata fields within text or
|
||||
binary files as long as those fields can be easily viewed by the user.
|
||||
|
||||
3) No Modified Version of the Font Software may use the Reserved Font
|
||||
Name(s) unless explicit written permission is granted by the corresponding
|
||||
Copyright Holder. This restriction only applies to the primary font name as
|
||||
presented to the users.
|
||||
|
||||
4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
|
||||
Software shall not be used to promote, endorse or advertise any
|
||||
Modified Version, except to acknowledge the contribution(s) of the
|
||||
Copyright Holder(s) and the Author(s) or with their explicit written
|
||||
permission.
|
||||
|
||||
5) The Font Software, modified or unmodified, in part or in whole,
|
||||
must be distributed entirely under this license, and must not be
|
||||
distributed under any other license. The requirement for fonts to
|
||||
remain under this license does not apply to any document created
|
||||
using the Font Software.
|
||||
|
||||
TERMINATION
|
||||
This license becomes null and void if any of the above conditions are
|
||||
not met.
|
||||
|
||||
DISCLAIMER
|
||||
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
|
||||
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
|
||||
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
|
||||
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
|
||||
OTHER DEALINGS IN THE FONT SOFTWARE.
|
||||
@@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2019 Gerrit Halfmann
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M3 2h18v2H3zm0 5h18v2H3zM1 4h2v3H1zm20 0h2v3h-2zm-2 5h2v11h-2zM3 9h2v11H3zm2 11h14v2H5zm4-9h6v2H9z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 224 B |
@@ -0,0 +1,4 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M20 11v2H4v-2zM8 13v2H6v-2zm2 2v2H8v-2zm2 2v2h-2v-2zm-4-6V9H6v2z"/>
|
||||
<path d="M10 15V7H8v8zm2 2V5h-2v12z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 231 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M2 3h9v2H2zM0 19h11v2H0zM13 3h9v2h-9zm0 16h11v2H13zM11 5h2v18h-2zM0 5h2v14H0zm22 0h2v14h-2zm-7 2h5v2h-5zm0 4h5v2h-5zm0 4h2v2h-2z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 254 B |
@@ -0,0 +1,4 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M14 4h4v2h-4zm-4-2h4v2h-4zM6 8h4v2H6zm0 10h4v2H6zm4-8h4v2h-4zm0 10h4v2h-4zm4-12h4v2h-4zm0 10h4v2h-4zM6 4h4v2H6zM2 6h4v2H2zm0 10h4v2H2zM18 6h4v2h-4zm0 10h4v2h-4z"/>
|
||||
<path d="M2 6h2v12H2zm18 0h2v12h-2zm-8 6h2v8h-2z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 340 B |
@@ -0,0 +1,5 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M2 5h2v4H2zm20 0h-2v4h2zM4 9h2v2H4zm16 0h-2v2h2zM2 13h4v2H2zm20 0h-4v2h4zM4 17h2v2H4zm16 0h-2v2h2zM2 19h2v2H2zm20 0h-2v2h2zM6 11h12v2H6z"/>
|
||||
<path d="M6 7h2v12H6zm10 0h2v12h-2zM8 19h8v2H8zM8 5h8v2H8z"/>
|
||||
<path d="M11 15h2v6h-2zM8 1h2v6H8zm6 0h2v6h-2z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 378 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M10 18H8v-2h2v2Zm-2-2H6v-2h2v2Zm4-2v2h-2v-2h2Zm-6 0H4v-2h2v2Zm8 0h-2v-2h2v2Zm2-2h-2v-2h2v2Zm2-2h-2V8h2v2Zm2-2h-2V6h2v2Z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 245 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M13 16h-2v-2h2v2Zm-2-2H9v-2h2v2Zm4 0h-2v-2h2v2Zm-6-2H7v-2h2v2Zm8 0h-2v-2h2v2ZM7 10H5V8h2v2Zm12 0h-2V8h2v2Z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 232 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M16 13v-2h-2v2h2Zm-2-2V9h-2v2h2Zm0 4v-2h-2v2h2Zm-2-6V7h-2v2h2Zm0 8v-2h-2v2h2ZM10 7V5H8v2h2Zm0 12v-2H8v2h2Z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 232 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M6 2h12v2H6zM2 6h2v12H2zm18 0h2v12h-2zm-2-2h2v2h-2zM4 4h2v2H4zm2 18h12v-2H6zm12-2h2v-2h-2zM4 20h2v-2H4zm7-14h2v7h-2zm2 7h2v2h-2zm2 2h2v2h-2z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 266 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M7 19H5V17H7V19ZM19 19H17V17H19V19ZM9 15V17H7V15H9ZM17 17H15V15H17V17ZM11 15H9V13H11V15ZM15 15H13V13H15V15ZM13 13H11V11H13V13ZM11 11H9V9H11V11ZM15 11H13V9H15V11ZM9 9H7V7H9V9ZM17 9H15V7H17V9ZM7 7H5V5H7V7ZM19 7H17V5H19V7Z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 343 B |
@@ -0,0 +1,5 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M21 15v4h-2v-4zm-2 4v2H5v-2zM5 15v4H3v-4zm8-12v14h-2V3z"/>
|
||||
<path d="M7 11v2h10v-2zm2 2v2h2v-2zm4 0v2h2v-2z"/>
|
||||
<path d="M15 11v2h2v-2z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 263 B |
@@ -0,0 +1,4 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M11 5H5v2h6V5ZM5 7H3v12h2V7Zm12 12H5v2h12v-2Zm2-6h-2v6h2v-6Zm-8 0H9v2h2v-2Zm2-2h-2v2h2v-2Zm2-2h-2v2h2V9Zm2-2h-2v2h2V7Zm2-2h-2v2h2V5Zm2-2h-2v8h2V3Z"/>
|
||||
<path d="M21 3h-8v2h8V3Z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 302 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M4 4h6v2H4zm0 14h16v2H4zM20 8h2v10h-2zM2 6h2v12H2zm8 0h10v2H10z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 189 B |
@@ -0,0 +1,4 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M4 4h16v2H4zm0 14h16v2H4zM2 6h2v12H2zm18 0h2v12h-2zM8 9h2v6H8z"/>
|
||||
<path d="M6 11h6v2H6zm8-2h2v2h-2zm2 4h2v2h-2z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 239 B |
@@ -0,0 +1,4 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M6 2h12v2H6zm0 18h12v2H6zM4 4h2v2H4zm5 0h2v2H9zm0 14h2v2H9zm4 0h2v2h-2zM7 6h2v12H7zm8 0h2v12h-2zm-2-2h2v2h-2zm7 0h-2v2h2zM2 6h2v12H2zm20 0h-2v12h2zM4 18h2v2H4zm16 0h-2v2h2z"/>
|
||||
<path d="M3 11h18v2H3z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 326 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M13 22h-2v-2h2v2Zm-2-2H9v-2h2v2Zm4 0h-2v-2h2v2Zm-6-2H7v-2h2v2Zm8 0h-2v-2h2v2ZM7 16H5v-2h2v2Zm12 0h-2v-2h2v2ZM5 14H3v-2h2v2Zm16 0h-2v-2h2v2ZM3 12H1V6h2v6Zm20 0h-2V6h2v6ZM13 8h-2V6h2v2ZM5 6H3V4h2v2Zm6 0H9V4h2v2Zm4 0h-2V4h2v2Zm6 0h-2V4h2v2ZM9 4H5V2h4v2Zm10 0h-4V2h4v2Z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 391 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M4 20h16v2H4zm16-10h2v10h-2zM2 10h2v10H2zm2-2h2v2H4zm2-2h2v2H6zm2-2h2v2H8zm2-2h4v2h-4zm4 2h2v2h-2zm2 2h2v2h-2zm2 2h2v2h-2zM8 14h2v6H8zm2-2h4v2h-4zm4 2h2v6h-2z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 284 B |
@@ -0,0 +1,4 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M4 2h16v2H4zm0 18h16v2H4zM2 4h2v16H2zm18 0h2v16h-2zm-4 8h2v2h-2zm-2 2h2v2h-2zm4 0h2v2h-2zm-8 0h2v2h-2zm2 2h2v2h-2zm2 2h2v2h-2z"/>
|
||||
<path d="M20 16h2v2h-2zM8 16h2v2H8zm-2 2h2v2H6zM8 6h2v2H8zM6 8h2v2H6zm2 2h2v2H8zm2-2h2v2h-2z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 350 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M4 2h16v2H4zm0 18h16v2H4zM2 4h2v16H2zm18 0h2v16h-2zm-9 5h2V7h-2zm0 8h2v-6h-2z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 203 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M20 2H4v2h16zm0 14H6v2h14zm2-12h-2v12h2zM4 4H2v18h2zm2 14H4v2h2z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 190 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M4 2h16v2H4zm0 14h16v2H4zM2 4h2v12H2zm18 0h2v12h-2zm-9 14h2v2h-2zm-3 2h8v2H8z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 203 B |
@@ -0,0 +1,4 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M6 8h2v12H6zM2 4h2v12H2zm18 4h2v8h-2zM8 6h12v2H8zM4 2h12v2H4zm14 14h2v2h-2zm-2 2h2v2h-2zm-8 2h8v2H8zm6-6h6v2h-6z"/>
|
||||
<path d="M14 14h2v6h-2zm2-10h2v2h-2zM4 16h2v2H4z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 292 B |
@@ -0,0 +1,4 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M10 20h4v2h-4zm0-16h4V2h-4zm0 6h4v2h-4zm4 8h4v2h-4zm0-12h4V4h-4zm0 2h4v2h-4zm4 8h4v2h-4zm0-8h4V6h-4zM6 18h4v2H6zM6 6h4V4H6zm0 2h4v2H6zm-4 8h4v2H2zm0-8h4V6H2z"/>
|
||||
<path d="M2 6h2v12H2zm18 0h2v12h-2zm-8 6h2v8h-2zm-2-6h4v2h-4z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 350 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M15 11h-2V9h2zm0 4h-2v-2h2zm-2 2h-2v-2h2zm0-8h-2V7h2zm-2-2H9V5h2zM9 21H7V3h2zm6-8h2v-2h-2zm-6 4h2v2H9z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 228 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M13 11h7v2h-7v7h-2v-7H4v-2h7V4h2v7Z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 161 B |
@@ -0,0 +1,5 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M16 4h2v6h-2zm-2-2h2v2h-2zm0 2h2v8h-2zM4 8H2v5h2z"/>
|
||||
<path d="M4 6h16v2H4zm4 14H6v-6h2zm2 2H8v-2h2zm0-2H8v-8h2zm10-4h2v-5h-2z"/>
|
||||
<path d="M20 18H4v-2h16z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 283 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M22 22h-2v-2h2v2Zm-2-2h-2v-2h2v2Zm-6-2H6v-2h8v2Zm4 0h-2v-2h2v2ZM6 16H4v-2h2v2Zm10 0h-2v-2h2v2ZM4 14H2V6h2v8Zm14 0h-2V6h2v8ZM6 6H4V4h2v2Zm10 0h-2V4h2v2Zm-2-2H6V2h8v2Z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 291 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M6 7h4v2H6zm0 8h4v2H6zM2 5h2v14H2zm18 0h2v14h-2zM4 19h16v2H4zM4 3h16v2H4zm0 8h16v2H4z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 211 B |
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" fill="currentColor" viewBox="0 0 24 24"><path d="M8 14H7v6H5v-6H2v-2h6v2Zm5 6h-2V10h2v10Zm9-2h-3v2h-2v-2h-1v-2h6v2Zm-3-4h-2V4h2v10ZM7 10H5V4h2v6Zm6-4h2v2H9V6h2V4h2v2Z"/></svg>
|
||||
|
After Width: | Height: | Size: 215 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M4 2h16v2H4zm0 18h16v2H4zM2 4h2v16H2zm18 0h2v16h-2zM6 16h2v2H6zm2-2h2v2H8zm-2-2h2v2H6z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 212 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M18 22H6V20H18V22ZM9 6H15V4H17V6H22V8H20V20H18V8H6V20H4V8H2V6H7V4H9V6ZM15 4H9V2H15V4Z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 209 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M9 2h6v2H9zm0 8h6v2H9zm6-6h2v6h-2zM7 4h2v6H7zM4 18h2v4H4zm14 0h2v4h-2zM8 14h8v2H8zm-2 2h2v2H6zm10 0h2v2h-2z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 233 B |
@@ -0,0 +1,3 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
|
||||
<path d="M4 13h8v6h2v2h-2v2h-2v-8H2v-4h2v2Zm12 6h-2v-2h2v2Zm2-2h-2v-2h2v2Zm2-2h-2v-2h2v2Zm-6-6h8v4h-2v-2h-8V5h-2V3h2V1h2v8Zm-8 2H4V9h2v2Zm2-2H6V7h2v2Zm2-2H8V5h2v2Z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 280 B |