e3bd626688
The built-in extras become official mods; these are the calls the FPS counter and keystrokes overlay need to look and behave the same: - render.set-corner(corner, w, h, shapes): a box the game places with its own corner stacking (under the status effects, with the overlays and hud panels), clear-corner; text-width(text) in the HUD font (advances for U+0000..U+024F, 6 otherwise); frame-stats(): the game's FPS counter (fps, min, 1% low). - input.mapping(name): a movement or click mapping's key label and whether it is held; clicks-per-second() for attack and use. - ui: a button widget (200 x 20, select(id, 0)) for settings pages. - The game keeps its FPS and click counters running while a mod runs, and refreshes the snapshot every frame for mods with a frame hook. - The ui test guest gains /corner and /readings, with a sandbox test. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
185 lines
6.6 KiB
Rust
185 lines
6.6 KiB
Rust
//! Capability `render` (docs/mods.md): the shapes mods keep on the HUD,
|
|
//! drawn by the game's own HUD renderer, and their camera shakes. Mods
|
|
//! never supply shader code. With no mod drawing, each hook here returns
|
|
//! after one check.
|
|
use super::Game;
|
|
use horizon_client::hud::HudBatch;
|
|
#[cfg(feature = "mods")]
|
|
use {
|
|
horizon_client::{hud::rgba, items::ItemStack, text::Text},
|
|
horizon_mods::Shape,
|
|
std::time::Instant,
|
|
};
|
|
|
|
/// The camera's jolts from `render.shake`, while any is fading.
|
|
#[cfg(feature = "mods")]
|
|
#[derive(Default)]
|
|
pub(super) struct Shake {
|
|
jolts: Vec<Jolt>,
|
|
}
|
|
|
|
#[cfg(feature = "mods")]
|
|
struct Jolt {
|
|
start: Instant,
|
|
strength: f32,
|
|
seconds: f32,
|
|
}
|
|
|
|
/// The HUD batch's colour (ABGR) from a mod's 0xAARRGGBB.
|
|
#[cfg(feature = "mods")]
|
|
fn argb(color: u32) -> u32 {
|
|
let [a, r, g, b] = color.to_be_bytes();
|
|
rgba(r, g, b, a)
|
|
}
|
|
|
|
/// The view's turn at full strength, in degrees: yaw, then pitch.
|
|
#[cfg(feature = "mods")]
|
|
const SHAKE_DEGREES: (f32, f32) = (3.0, 2.0);
|
|
|
|
#[cfg(feature = "mods")]
|
|
impl Shake {
|
|
pub(super) fn add(&mut self, strength: f32, seconds: f32) {
|
|
self.jolts.push(Jolt {
|
|
start: Instant::now(),
|
|
strength,
|
|
seconds,
|
|
});
|
|
}
|
|
/// How far the view turns now (yaw, pitch degrees), `scale` being the
|
|
/// player's Distortion Effects; fades jolts out and forgets ended ones.
|
|
fn offset(&mut self, now: Instant, scale: f32) -> (f32, f32) {
|
|
self.jolts
|
|
.retain(|j| now.duration_since(j.start).as_secs_f32() < j.seconds);
|
|
let mut strength = 0.0;
|
|
for j in &self.jolts {
|
|
let left = 1.0 - now.duration_since(j.start).as_secs_f32() / j.seconds;
|
|
strength += j.strength * left * left;
|
|
}
|
|
let strength = strength.min(1.0) * scale.clamp(0.0, 1.0);
|
|
if strength <= 0.0 {
|
|
return (0.0, 0.0);
|
|
}
|
|
// Smooth noise: sines at unrelated rates, so it never repeats visibly.
|
|
let t = self
|
|
.jolts
|
|
.first()
|
|
.map_or(0.0, |j| now.duration_since(j.start).as_secs_f32());
|
|
let wave = |a: f32, b: f32, c: f32| {
|
|
((t * a).sin() * 0.5 + (t * b).sin() * 0.3 + (t * c).sin() * 0.2).clamp(-1.0, 1.0)
|
|
};
|
|
(
|
|
strength * SHAKE_DEGREES.0 * wave(23.0, 37.3, 51.7),
|
|
strength * SHAKE_DEGREES.1 * wave(29.1, 43.9, 61.3),
|
|
)
|
|
}
|
|
}
|
|
|
|
#[cfg(not(feature = "mods"))]
|
|
impl Game<'_> {
|
|
pub(super) fn draw_mod_shapes(&self, _batch: &mut HudBatch) {}
|
|
pub(super) fn shaken_view(&mut self, yaw: f32, pitch: f32) -> (f32, f32) {
|
|
(yaw, pitch)
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "mods")]
|
|
impl Game<'_> {
|
|
/// The running mods' HUD shapes, in order, over the HUD.
|
|
pub(super) fn draw_mod_shapes(&self, batch: &mut HudBatch) {
|
|
for shape in self.mods.mods.hud_shapes() {
|
|
self.draw_shapes(batch, std::slice::from_ref(shape), (0.0, 0.0));
|
|
}
|
|
}
|
|
/// Shapes with their GUI coordinates moved by `(ox, oy)`.
|
|
pub(super) fn draw_shapes(&self, batch: &mut HudBatch, shapes: &[Shape], (ox, oy): (f32, f32)) {
|
|
let atlas = &self.gui.atlas;
|
|
for shape in shapes {
|
|
match shape {
|
|
Shape::Fill(f) => {
|
|
let r = f.rect;
|
|
batch.fill(atlas, ox + r.x, oy + r.y, r.w, r.h, argb(f.color));
|
|
}
|
|
Shape::Quad(q) => {
|
|
let (a, b, c, d) = q.corners;
|
|
let corners = [a, b, c, d].map(|p| [ox + p.x, oy + p.y]);
|
|
batch.fill_quad(atlas, corners, argb(q.color));
|
|
}
|
|
Shape::Sprite(s) => {
|
|
let r = s.rect;
|
|
let name = s.sprite.strip_prefix("minecraft:").unwrap_or(&s.sprite);
|
|
let name = format!("gui/sprites/{name}");
|
|
batch.sprite_scaled(atlas, &name, ox + r.x, oy + r.y, r.w, r.h, argb(s.color));
|
|
}
|
|
Shape::Item(i) => {
|
|
if self.res.items().get(&i.item).is_none() {
|
|
continue;
|
|
}
|
|
let start = batch.vertices.len();
|
|
let stack = ItemStack::new(i.item.as_str(), 1);
|
|
let (x, y) = (ox + i.at.x, oy + i.at.y);
|
|
self.draw_item_model(batch, &stack, x, y);
|
|
batch.scale_since(start, x, y, i.scale, i.scale);
|
|
}
|
|
Shape::Text(t) => {
|
|
let text = Text::literal(t.text.clone());
|
|
let centre = if t.centered {
|
|
(HudBatch::text_width(atlas, &t.text) / 2.0).floor()
|
|
} else {
|
|
0.0
|
|
};
|
|
let x = ox + t.at.x - centre;
|
|
batch.text_styled(
|
|
atlas,
|
|
&text,
|
|
x,
|
|
oy + t.at.y,
|
|
argb(t.color | 0xFF00_0000),
|
|
t.shadow,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// The view's yaw and pitch after the mods' camera shakes; unchanged
|
|
/// while none is fading.
|
|
pub(super) fn shaken_view(&mut self, yaw: f32, pitch: f32) -> (f32, f32) {
|
|
if self.mods.shake.jolts.is_empty() {
|
|
return (yaw, pitch);
|
|
}
|
|
let scale = self.settings.file.double("screenEffectScale") as f32;
|
|
let (dy, dp) = self.mods.shake.offset(Instant::now(), scale);
|
|
(yaw + dy, (pitch + dp).clamp(-90.0, 90.0))
|
|
}
|
|
}
|
|
|
|
#[cfg(all(test, feature = "mods"))]
|
|
mod tests {
|
|
use super::*;
|
|
use std::time::Duration;
|
|
|
|
#[test]
|
|
fn a_jolt_fades_out_and_distortion_scales_it() {
|
|
let mut shake = Shake::default();
|
|
shake.add(1.0, 2.0);
|
|
let start = shake.jolts[0].start;
|
|
let at = |s: f32| start + Duration::from_secs_f32(s);
|
|
let size = |(y, p): (f32, f32)| y.abs() + p.abs();
|
|
// Off with Distortion Effects at 0, inside the limits otherwise.
|
|
assert_eq!(shake.offset(at(0.3), 0.0), (0.0, 0.0));
|
|
let (y, p) = shake.offset(at(0.3), 1.0);
|
|
assert!(y.abs() <= SHAKE_DEGREES.0 && p.abs() <= SHAKE_DEGREES.1);
|
|
// Fading: the largest turn over a window shrinks.
|
|
let mut peak = |from: f32| {
|
|
(0..50)
|
|
.map(|i| size(shake.offset(at(from + i as f32 * 0.002), 1.0)))
|
|
.fold(0.0, f32::max)
|
|
};
|
|
let early = peak(0.1);
|
|
let late = peak(1.6);
|
|
assert!(late < early, "{late} !< {early}");
|
|
// Gone once it ends.
|
|
assert_eq!(shake.offset(at(2.1), 1.0), (0.0, 0.0));
|
|
assert!(shake.jolts.is_empty());
|
|
}
|
|
}
|