Files
horizon-airdef/crates/horizon-client/src/overlay.rs
T
Ludovic Marie 74821bf188 Overlay texels from OverlayTexture, and the creeper's white flash
The hurt red and the white row's alphas come from overlay.rs, which
reproduces OverlayTexture's texels (checked against values printed by
the 26.3 JVM) and is prepended to entity.wgsl; a test parses and
validates the composed shader with naga.

Swelling creepers flash white as CreeperRenderer.getWhiteOverlayProgress
says (the white row's column, red winning while hurt; layers keep the
red only), and CreeperRenderer.scale's wobble uses the unclamped
swelling as vanilla does.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-14 18:07:31 +02:00

103 lines
3.3 KiB
Rust

//! OverlayTexture: the hurt red and white flash entity.wgsl mixes over a lit
//! entity before the lightmap (entity.fsh), and the overlay codes models carry.
//!
//! Vanilla's 16 by 16 texture: rows 0 to 7 are the hurt red, row 10 is white
//! with an alpha falling with u; LivingEntityRenderer.getOverlayCoords picks
//! u from the white overlay progress and row 3 when the entity is hurt.
/// The overlay code of white flashes: `WHITE + u`, u in 1..=15.
pub const WHITE: u32 = 16;
/// The hurt red (rows 0 to 7) as RGBA bytes: 0xB2FF0000.
pub const HURT_TEXEL: [u8; 4] = [255, 0, 0, 0xB2];
/// The white row's alpha at column u: `(int) ((1 - u / 15 * 0.75) * 255)`
/// in float precision.
pub fn white_alpha(u: u32) -> u8 {
((1.0f32 - u as f32 / 15.0 * 0.75) * 255.0) as u8
}
/// OverlayTexture.u: the column of a white overlay progress.
pub fn white_column(progress: f32) -> u32 {
(progress * 15.0) as u32
}
/// LivingEntityRenderer.getOverlayCoords as entity.wgsl's overlay code: the
/// red row hides the white column; column 0 of the white row is opaque white
/// with full alpha, so no overlay.
pub fn living(white_progress: f32, red: bool) -> u32 {
if red {
return 1;
}
match white_column(white_progress) {
0 => 0,
u => WHITE + u.min(15),
}
}
/// CreeperRenderer.getWhiteOverlayProgress: flashing every other tenth of
/// the swelling, at least half white.
pub fn creeper_progress(swelling: f32) -> f32 {
if (swelling * 10.0) as i32 % 2 == 0 {
0.0
} else {
swelling.clamp(0.5, 1.0)
}
}
/// The texels as WGSL constants, prepended to entity.wgsl.
pub fn wgsl_constants() -> String {
let [r, g, b, a] = HURT_TEXEL.map(|v| format!("{v}.0 / 255.0"));
let white: Vec<String> = (0..16)
.map(|u| format!("{}.0 / 255.0", white_alpha(u)))
.collect();
format!(
"// OverlayTexture (overlay.rs): the hurt texel and the white row's alpha by column.\n\
const HURT_OVERLAY = vec4({r}, {g}, {b}, {a});\n\
const WHITE_OVERLAY_ALPHA = array<f32, 16>({});\n",
white.join(", ")
)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn texels_are_vanilla_s() {
// OverlayTexture's constructor, printed by the 26.3 JVM.
let vanilla = [
255, 242, 229, 216, 203, 191, 178, 165, 152, 140, 127, 114, 101, 89, 76, 63,
];
assert_eq!((0..16).map(white_alpha).collect::<Vec<_>>(), vanilla);
assert_eq!(
u32::from_be_bytes([HURT_TEXEL[3], HURT_TEXEL[0], HURT_TEXEL[1], HURT_TEXEL[2]]),
0xB2FF_0000
);
}
#[test]
fn creeper_flashes_like_vanilla() {
// (swelling, OverlayTexture.u(getWhiteOverlayProgress)) from the JVM.
let vanilla = [
(0.05, 0),
(0.1, 7),
(0.19, 7),
(0.2, 0),
(0.3, 7),
(0.49, 0),
(0.5, 7),
(0.55, 8),
(0.7, 10),
(0.75, 11),
(0.95, 14),
(1.0, 0),
];
for (swelling, u) in vanilla {
assert_eq!(white_column(creeper_progress(swelling)), u, "{swelling}");
}
assert_eq!(living(creeper_progress(0.55), false), WHITE + 8);
assert_eq!(living(creeper_progress(0.55), true), 1);
assert_eq!(living(0.0, false), 0);
}
}