Merge pull request #188 from rdbtCVS/fix/title-panorama-quality

Fix pixelated Classic menu panorama
This commit is contained in:
Ludovic Marie
2026-10-15 01:10:47 +02:00
committed by GitHub
6 changed files with 409 additions and 104 deletions
+5 -86
View File
@@ -598,6 +598,7 @@ pub struct Resources {
biomes: Arc<Biomes>,
environment: Environment,
atlas: HudAtlas,
panorama: horizon_client::gfx::panorama::Faces,
layer_names: HashMap<u32, String>,
mob_types: HashMap<String, Arc<MobType>>,
mob_data: horizon_client::mobs::MobData,
@@ -6040,91 +6041,6 @@ impl Game<'_> {
self.capture(false);
Ok(())
}
/// The title panorama as six camera-centred faces (panorama_0..5:
/// front, right, back, left, up, down).
fn panorama_geometry(&self) -> Vec<Vertex> {
let mut out = Vec::new();
let d = 100.0;
let faces: [(&str, [glam::Vec3; 4]); 6] = [
(
"0",
[
glam::Vec3::new(-d, d, -d),
glam::Vec3::new(d, d, -d),
glam::Vec3::new(d, -d, -d),
glam::Vec3::new(-d, -d, -d),
],
),
(
"1",
[
glam::Vec3::new(d, d, -d),
glam::Vec3::new(d, d, d),
glam::Vec3::new(d, -d, d),
glam::Vec3::new(d, -d, -d),
],
),
(
"2",
[
glam::Vec3::new(d, d, d),
glam::Vec3::new(-d, d, d),
glam::Vec3::new(-d, -d, d),
glam::Vec3::new(d, -d, d),
],
),
(
"3",
[
glam::Vec3::new(-d, d, d),
glam::Vec3::new(-d, d, -d),
glam::Vec3::new(-d, -d, -d),
glam::Vec3::new(-d, -d, d),
],
),
(
"4",
[
glam::Vec3::new(-d, d, d),
glam::Vec3::new(d, d, d),
glam::Vec3::new(d, d, -d),
glam::Vec3::new(-d, d, -d),
],
),
(
"5",
[
glam::Vec3::new(-d, -d, -d),
glam::Vec3::new(d, -d, -d),
glam::Vec3::new(d, -d, d),
glam::Vec3::new(-d, -d, d),
],
),
];
for (index, corners) in faces {
let Some(r) = self
.res
.atlas
.sprites
.get(&format!("gui/title/background/panorama_{index}"))
.copied()
else {
continue;
};
let uv = [[r.u0, r.v0], [r.u1, r.v0], [r.u1, r.v1], [r.u0, r.v1]];
for (p, uv) in corners.iter().zip(uv) {
out.push(Vertex {
normal: [0; 4],
pos: p.to_array(),
uv,
layer: 2,
color: 0xFFFF_FFFF,
light: 0,
});
}
}
out
}
/// Equipment attribute modifiers (LivingEntity.collectEquipmentChanges).
fn apply_equipment(&mut self) {
let Some(player) = self.player.as_mut() else {
@@ -7006,6 +6922,7 @@ impl Game<'_> {
self.res.atlas.height,
),
(&self.res.forcefield.2, self.res.forcefield.0),
&self.res.panorama,
))
}
fn apply_settings(&mut self) {
@@ -7822,7 +7739,7 @@ impl Game<'_> {
}
}
let celestial = if title && !live {
self.panorama_geometry()
Vec::new()
} else if self.dim == Dim::Overworld
&& self.potions.effects.get("darkness").is_none()
&& self.potions.effects.get("blindness").is_none()
@@ -8949,6 +8866,7 @@ pub fn run() -> Result<()> {
let light = Arc::new(LightTables::load(&root, assets.registry, &facts)?);
log::info!("load tables: {:.2}s", started.elapsed().as_secs_f32());
let atlas = HudAtlas::build(&root)?;
let panorama = horizon_client::gfx::panorama::Faces::load(&root);
horizon_client::ui::load_metadata(&root);
horizon_client::lang::set(horizon_client::lang::Language::load(
&[&root],
@@ -9016,6 +8934,7 @@ pub fn run() -> Result<()> {
biomes,
environment,
atlas,
panorama,
item_renderer: Arc::new(horizon_client::item_render::ItemRenderer::load(&root)?),
layer_names,
providers: Providers::load(&root),
+2
View File
@@ -112,6 +112,7 @@ impl Game<'_> {
fn reload_resources(&mut self, root: &Path) -> horizon_client::Result<()> {
let assets = std::sync::Arc::new(self.res.assets.reload(root)?);
let mut atlas = HudAtlas::build(root)?;
let panorama = horizon_client::gfx::panorama::Faces::load(root);
atlas.font.uniform = self.settings.force_unicode;
atlas.font.japanese = self.settings.japanese_glyphs;
let item_renderer = horizon_client::item_render::ItemRenderer::load(root)?;
@@ -137,6 +138,7 @@ impl Game<'_> {
self.res.assets = assets;
self.res.context = context.clone();
self.res.atlas = atlas;
self.res.panorama = panorama;
self.res.item_renderer = std::sync::Arc::new(item_renderer);
self.res.clouds = super::load_clouds(root);
self.res.forcefield = super::load_forcefield(root);
+25 -3
View File
@@ -83,6 +83,7 @@ pub fn outline_vertices(edges: &[[f64; 6]], camera: glam::DVec3) -> Vec<[f32; 6]
mod arena;
mod occlusion;
pub mod panorama;
mod timing;
mod world_post;
@@ -137,7 +138,7 @@ pub struct Frame<'a> {
/// Skip sections the camera cannot see through open faces (vanilla's
/// occlusion graph; off in spectator-like views inside blocks).
pub cave_culling: bool,
/// Title screen: only the panorama (in `celestial`) and the HUD.
/// Title screen: only the dedicated panorama cube map and the HUD.
pub title: bool,
/// Dimensions without a skybox (the Nether) clear to the fog colour.
pub skybox: bool,
@@ -246,6 +247,7 @@ pub struct Renderer {
additive_pipeline: wgpu::RenderPipeline,
celestial_pipeline: wgpu::RenderPipeline,
celestial_buffer: wgpu::Buffer,
panorama: panorama::Panorama,
/// `RenderPipelines.WORLD_BORDER` and its buffers.
border_pipeline: wgpu::RenderPipeline,
border_group: wgpu::BindGroup,
@@ -401,6 +403,7 @@ impl Renderer {
animations: &[SpriteAnimation],
hud_atlas: (&[u8], u32, u32),
forcefield: (&[u8], u32),
panorama_faces: &panorama::Faces,
) -> Result<Self> {
let instance =
wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env());
@@ -1361,6 +1364,12 @@ impl Renderer {
.features()
.contains(wgpu::Features::INDIRECT_FIRST_INSTANCE);
let world_post = world_post::Post::new(&device, config.format.remove_srgb_suffix());
let panorama = panorama::Panorama::new(
&device,
&queue,
config.format.remove_srgb_suffix(),
panorama_faces,
);
Ok(Self {
instance,
surface,
@@ -1389,6 +1398,7 @@ impl Renderer {
additive_pipeline,
celestial_pipeline,
celestial_buffer,
panorama,
border_pipeline,
border_group,
border_uniform,
@@ -1875,6 +1885,15 @@ impl Renderer {
frame.block_flicker,
);
let view_proj = self.view_projection(frame);
if frame.title {
self.panorama.prepare(
&self.queue,
self.config.width,
self.config.height,
frame.yaw,
frame.pitch,
);
}
let aspect = self.config.width as f32 / self.config.height.max(1) as f32;
let view = crate::camera::view_matrix(frame.yaw, frame.pitch);
let sun_angle = frame.sky.sun_angle.to_radians();
@@ -2221,12 +2240,15 @@ impl Renderer {
Some(f) => f.sky_end > 2.0,
None => !frame.underwater,
};
if sky_visible && (frame.skybox || frame.end_sky) {
if frame.title || (sky_visible && (frame.skybox || frame.end_sky)) {
if !frame.title && frame.skybox {
pass.set_pipeline(&self.sky);
pass.draw(0..3, 0..1);
}
if celestial_vertices > 0 {
if frame.title {
self.panorama.draw(&mut pass);
pass.set_bind_group(0, &self.group, &[]);
} else if celestial_vertices > 0 {
pass.set_pipeline(&self.celestial_pipeline);
pass.set_bind_group(0, &self.entity_group, &[]);
pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
+346
View File
@@ -0,0 +1,346 @@
//! Vanilla 26.3's CubeMapTexture and CubeMap, separate from the pixel-filtered GUI atlas.
use crate::{Result, hud::decode};
use glam::Mat4;
use std::path::Path;
use wgpu::util::DeviceExt;
/// Native cube order: +X, -X, +Y, -Y, +Z, -Z (CubeMapTexture.SUFFIXES).
const FACE_ORDER: [u8; 6] = [1, 3, 5, 4, 0, 2];
#[derive(Debug)]
pub struct Faces {
pub size: u32,
pub pixels: Vec<u8>,
}
impl Faces {
pub fn load(root: &Path) -> Self {
Self::try_load(root).unwrap_or_else(|error| {
log::warn!("Horizon: title panorama unavailable ({error})");
Self {
size: 1,
pixels: [96, 110, 111, 255].repeat(6),
}
})
}
fn try_load(root: &Path) -> Result<Self> {
let background = root.join("assets/minecraft/textures/gui/title/background");
let mut size = 0;
let mut pixels = Vec::new();
for face in FACE_ORDER {
let path = background.join(format!("panorama_{face}.png"));
let (w, h, data) = decode(&path)?;
if w != h || (size != 0 && w != size) {
return Err(format!(
"{}: panorama faces must be equally sized squares",
path.display()
)
.into());
}
size = w;
// CubeMapTexture copies each original image with flipY=true. Keep every texel.
for row in data.chunks_exact((w * 4) as usize).rev() {
pixels.extend_from_slice(row);
}
}
Ok(Self { size, pixels })
}
}
fn projection(width: u32, height: u32, yaw: f32, pitch: f32) -> Mat4 {
// CubeMap.render: 85-degree FOV, near/far 0.05/10, rotationX(PI), rotateX, rotateY.
Mat4::perspective_rh(
85.0f32.to_radians(),
width as f32 / height.max(1) as f32,
0.05,
10.0,
) * Mat4::from_rotation_x(std::f32::consts::PI)
* Mat4::from_rotation_x(pitch.to_radians())
* Mat4::from_rotation_y(yaw.to_radians())
}
pub(super) struct Panorama {
pipeline: wgpu::RenderPipeline,
group: wgpu::BindGroup,
uniform: wgpu::Buffer,
}
impl Panorama {
pub(super) fn new(
device: &wgpu::Device,
queue: &wgpu::Queue,
format: wgpu::TextureFormat,
faces: &Faces,
) -> Self {
let texture = device.create_texture_with_data(
queue,
&wgpu::TextureDescriptor {
label: Some("Title panorama cube"),
size: wgpu::Extent3d {
width: faces.size,
height: faces.size,
depth_or_array_layers: 6,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: wgpu::TextureFormat::Rgba8Unorm,
usage: wgpu::TextureUsages::TEXTURE_BINDING,
view_formats: &[],
},
wgpu::util::TextureDataOrder::LayerMajor,
&faces.pixels,
);
let view = texture.create_view(&wgpu::TextureViewDescriptor {
dimension: Some(wgpu::TextureViewDimension::Cube),
..Default::default()
});
// CubeMapTexture's blur=true metadata: linear minification and magnification, no mips.
let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("Title panorama linear filtering"),
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Linear,
..Default::default()
});
let uniform = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Title panorama projection"),
size: 64,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: Some("Title panorama bindings"),
entries: &[
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: None,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::Cube,
multisampled: false,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 2,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
count: None,
},
],
});
let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("Title panorama resources"),
layout: &layout,
entries: &[
wgpu::BindGroupEntry {
binding: 0,
resource: uniform.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::TextureView(&view),
},
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::Sampler(&sampler),
},
],
});
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Title panorama shader"),
source: wgpu::ShaderSource::Wgsl(include_str!("panorama.wgsl").into()),
});
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("Title panorama layout"),
bind_group_layouts: &[Some(&layout)],
..Default::default()
});
let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("Title panorama"),
layout: Some(&pipeline_layout),
vertex: wgpu::VertexState {
module: &shader,
entry_point: Some("vs_panorama"),
compilation_options: Default::default(),
buffers: &[],
},
primitive: wgpu::PrimitiveState {
cull_mode: None,
..Default::default()
},
depth_stencil: Some(wgpu::DepthStencilState {
format: wgpu::TextureFormat::Depth32Float,
depth_write_enabled: Some(false),
depth_compare: Some(wgpu::CompareFunction::Always),
stencil: Default::default(),
bias: Default::default(),
}),
multisample: Default::default(),
fragment: Some(wgpu::FragmentState {
module: &shader,
entry_point: Some("fs_panorama"),
compilation_options: Default::default(),
targets: &[Some(wgpu::ColorTargetState {
format,
blend: None,
write_mask: wgpu::ColorWrites::ALL,
})],
}),
multiview_mask: None,
cache: None,
});
Self {
pipeline,
group,
uniform,
}
}
pub(super) fn prepare(
&self,
queue: &wgpu::Queue,
width: u32,
height: u32,
yaw: f32,
pitch: f32,
) {
queue.write_buffer(
&self.uniform,
0,
bytemuck::cast_slice(&projection(width, height, yaw, pitch).to_cols_array()),
);
}
pub(super) fn draw(&self, pass: &mut wgpu::RenderPass<'_>) {
pass.set_pipeline(&self.pipeline);
pass.set_bind_group(0, &self.group, &[]);
pass.draw(0..36, 0..1);
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::{
fs,
sync::atomic::{AtomicU32, Ordering},
};
struct Fixture(std::path::PathBuf);
impl Fixture {
fn new(size: u32) -> Self {
static NEXT: AtomicU32 = AtomicU32::new(0);
let root = std::env::temp_dir().join(format!(
"horizon-panorama-{}-{}",
std::process::id(),
NEXT.fetch_add(1, Ordering::Relaxed),
));
let fixture = Self(root);
fs::create_dir_all(fixture.background()).unwrap();
for face in 0..6 {
fixture.write(face, size, size);
}
fixture
}
fn background(&self) -> std::path::PathBuf {
self.0
.join("assets/minecraft/textures/gui/title/background")
}
fn write(&self, face: u8, w: u32, h: u32) {
let file =
fs::File::create(self.background().join(format!("panorama_{face}.png"))).unwrap();
let mut encoder = png::Encoder::new(file, w, h);
encoder.set_color(png::ColorType::Rgba);
encoder.set_depth(png::BitDepth::Eight);
let pixels: Vec<u8> = (0..h)
.flat_map(|y| {
(0..w).flat_map(move |x| [face, (x % 251) as u8, (y % 253) as u8, 255])
})
.collect();
encoder
.write_header()
.unwrap()
.write_image_data(&pixels)
.unwrap();
}
}
impl Drop for Fixture {
fn drop(&mut self) {
let _ = fs::remove_dir_all(&self.0);
}
}
#[test]
fn original_resolution_texels_and_vanilla_cube_orientation_are_preserved() {
let f = Fixture::new(1024);
let faces = Faces::try_load(&f.0).unwrap();
assert_eq!(faces.size, 1024);
assert_eq!(faces.pixels.len(), 6 * 1024 * 1024 * 4);
// CubeMapTexture's actual layer suffixes, with each source row flipped vertically.
for (layer, source_face) in [1, 3, 5, 4, 0, 2].into_iter().enumerate() {
for y in 0..1024 {
for x in 0..1024 {
let at = ((layer * 1024 + y) * 1024 + x) * 4;
assert_eq!(
faces.pixels[at..at + 4],
[source_face, (x % 251) as u8, ((1023 - y) % 253) as u8, 255]
);
}
}
}
}
#[test]
fn placeholders_load_and_incomplete_or_mismatched_cubes_fall_back() {
let f = Fixture::new(1);
assert_eq!(Faces::try_load(&f.0).unwrap().size, 1);
f.write(5, 2, 1);
assert!(
Faces::try_load(&f.0)
.unwrap_err()
.to_string()
.contains("equally sized squares")
);
let fallback = Faces::load(&f.0);
assert_eq!(fallback.pixels.len(), 24);
f.write(5, 2, 2);
assert!(Faces::try_load(&f.0).is_err());
fs::remove_file(f.background().join("panorama_5.png")).unwrap();
assert!(Faces::try_load(&f.0).is_err());
assert_eq!(Faces::load(&f.0).size, 1);
}
#[test]
fn cube_shader_validates() {
let module = naga::front::wgsl::parse_str(include_str!("panorama.wgsl")).unwrap();
naga::valid::Validator::new(
naga::valid::ValidationFlags::all(),
naga::valid::Capabilities::all(),
)
.validate(&module)
.unwrap();
}
#[test]
fn vanilla_camera_centres_the_positive_z_face_and_pitches_ten_degrees() {
let straight = projection(1920, 1080, 0.0, 0.0) * glam::Vec4::new(0.0, 0.0, 1.0, 1.0);
assert!((straight.x / straight.w).abs() < 1e-6);
assert!((straight.y / straight.w).abs() < 1e-6);
assert!(straight.w > 0.0);
let pitched = projection(1920, 1080, 0.0, 10.0) * glam::Vec4::new(0.0, 0.0, 1.0, 1.0);
let expected_y = 10.0f32.to_radians().tan() / 42.5f32.to_radians().tan();
assert!((pitched.y / pitched.w - expected_y).abs() < 1e-6);
}
}
@@ -0,0 +1,30 @@
// CubeMap's position-only cube and panorama.vsh/fsh: sample its untransformed direction.
struct Projection { view_proj: mat4x4<f32> }
@group(0) @binding(0) var<uniform> projection: Projection;
@group(0) @binding(1) var panorama: texture_cube<f32>;
@group(0) @binding(2) var panorama_sampler: sampler;
struct Out {
@builtin(position) clip: vec4<f32>,
@location(0) direction: vec3<f32>,
}
@vertex fn vs_panorama(@builtin(vertex_index) index: u32) -> Out {
let corners = array<vec3<f32>, 8>(
vec3(-1.0, -1.0, -1.0), vec3(1.0, -1.0, -1.0),
vec3(1.0, 1.0, -1.0), vec3(-1.0, 1.0, -1.0),
vec3(-1.0, -1.0, 1.0), vec3(1.0, -1.0, 1.0),
vec3(1.0, 1.0, 1.0), vec3(-1.0, 1.0, 1.0),
);
let indices = array<u32, 36>(
4, 7, 6, 4, 6, 5, 5, 6, 2, 5, 2, 1,
1, 2, 3, 1, 3, 0, 0, 3, 7, 0, 7, 4,
7, 3, 2, 7, 2, 6, 0, 4, 5, 0, 5, 1,
);
let position = corners[indices[index]];
var out: Out;
out.clip = projection.view_proj * vec4(position, 1.0);
out.direction = position;
return out;
}
@fragment fn fs_panorama(in: Out) -> @location(0) vec4<f32> {
return textureSample(panorama, panorama_sampler, in.direction);
}
+1 -15
View File
@@ -151,9 +151,7 @@ impl HudAtlas {
walk(&textures.join("map"), &mut files);
files.retain(|p| {
let s = p.to_string_lossy();
(!s.contains("title/background") || s.contains("panorama_"))
&& !s.contains("realms")
&& !s.contains("presets")
!s.contains("title/background") && !s.contains("realms") && !s.contains("presets")
});
let decode_one = |path: &PathBuf| -> Option<(String, u32, u32, Vec<u8>)> {
let name = path
@@ -170,18 +168,6 @@ impl HudAtlas {
} else {
pixels
};
// Title panorama faces are downsampled to 256 for the shared atlas.
if name.contains("panorama_") && w >= 512 && w == h {
let step = (w / 256) as usize;
let mut small = Vec::with_capacity(256 * 256 * 4);
for y in 0..256usize {
for x in 0..256usize {
let i = ((y * step) * w as usize + x * step) * 4;
small.extend_from_slice(&pixels[i..i + 4]);
}
}
return Some((name, 256, 256, small));
}
(w <= 1024 && (h <= 512 || name.starts_with("font/"))).then_some((name, w, h, pixels))
};
let threads = std::thread::available_parallelism().map_or(2, |n| n.get());