Merge pull request #1697 from ludovic111/feat/shader-packs-terrain

Shader packs, clean room 13: loading the terrain program
This commit is contained in:
Ludovic Marie
2026-10-25 14:21:33 +01:00
committed by GitHub
5 changed files with 173 additions and 64 deletions
@@ -42,7 +42,7 @@ impl Game<'_> {
);
}
let folder = dimension_folder(&pack, dimension);
let post = load_post(&pack, &folder, &properties, &macros);
let post = load_post(&pack, &folder, &properties, &macros, None);
if let Some((programs, notes)) = renderer.set_shader_pack(dimension, Some(post))
{
for note in notes {
+125 -60
View File
@@ -8,10 +8,11 @@
//! dimension when it exists; every stage file is read from it.
//! - OQ-29: a program with a geometry stage is reported and treated as missing.
//! - A program that fails to translate is reported and treated as missing (2.5).
//! - Terrain draws with the first program of its fallback chain that loads (2.3).
use crate::config::{self, Config};
use crate::{Macros, Pack, Preprocessed, Program, Properties, Target, eval_condition};
use crate::{preprocess, translate_composite};
use crate::{GbuffersInputs, Macros, Pack, Preprocessed, Program, Properties, Target};
use crate::{eval_condition, preprocess, translate_composite, translate_gbuffers};
/// Which group of 2.1 a program belongs to.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -20,8 +21,18 @@ pub enum Group {
Deferred,
Composite,
Final,
/// A gbuffers program: the game draws its geometry with it.
Gbuffers,
}
/// `gbuffers_terrain` and its fallbacks (2.3).
const TERRAIN: [&str; 4] = [
"gbuffers_terrain",
"gbuffers_textured_lit",
"gbuffers_textured",
"gbuffers_basic",
];
const GROUPS: [(Group, &str); 4] = [
(Group::Prepare, "prepare"),
(Group::Deferred, "deferred"),
@@ -47,6 +58,8 @@ pub struct Post {
/// The flips of the virtual `deferred_pre` and `composite_pre` (6.1.6).
pub deferred_pre: Vec<(u32, bool)>,
pub composite_pre: Vec<(u32, bool)>,
/// What draws solid and cutout terrain, when the game asked for it and one loads.
pub terrain: Option<PostProgram>,
pub config: Config,
/// Programs skipped and why, as `program: message` or `file:line: message`.
pub notes: Vec<String>,
@@ -63,19 +76,30 @@ pub fn dimension_folder(pack: &Pack, id: i32) -> String {
}
}
/// Loads the post-processing programs of `folder`.
pub fn load_post(pack: &Pack, folder: &str, properties: &Properties, macros: &Macros) -> Post {
/// Loads the post-processing programs of `folder` and, given the game's terrain vertices, the
/// program terrain draws with.
pub fn load_post(
pack: &Pack,
folder: &str,
properties: &Properties,
macros: &Macros,
terrain: Option<&GbuffersInputs>,
) -> Post {
let mut post = Post {
folder: folder.to_owned(),
programs: Vec::new(),
deferred_pre: flips(properties, "deferred_pre"),
composite_pre: flips(properties, "composite_pre"),
terrain: None,
config: Config::default(),
notes: Vec::new(),
};
let path = |name: &str, ext: &str| match folder {
"" => format!("{name}.{ext}"),
f => format!("{f}/{name}.{ext}"),
let mut loader = Loader {
pack,
folder,
properties,
macros,
post: &mut post,
};
for (group, base) in GROUPS {
let names: Vec<String> = if group == Group::Final {
@@ -85,63 +109,98 @@ pub fn load_post(pack: &Pack, folder: &str, properties: &Properties, macros: &Ma
.chain((1..=99).map(|n| format!("{base}{n}")))
.collect()
};
let target = match group {
Group::Final => Target::Window,
_ => Target::Buffers,
};
for name in names {
let (vsh, fsh) = (path(&name, "vsh"), path(&name, "fsh"));
if !pack.exists(&fsh) || !pack.exists(&vsh) {
continue;
if let Some(p) = loader.load(name, group, |v, f| translate_composite(v, f, target)) {
loader.post.programs.push(p);
}
if !enabled(properties, folder, &name, macros) {
continue;
}
if pack.exists(&path(&name, "gsh")) {
post.notes.push(format!(
"{name}: uses a geometry stage (not supported); skipped"
));
continue;
}
let vertex = preprocess(pack, &vsh, macros);
let fragment = preprocess(pack, &fsh, macros);
let problems: Vec<String> = [&vertex, &fragment]
.iter()
.flat_map(|pp| diagnostics(pp))
.collect();
if !problems.is_empty() {
post.notes.extend(problems);
post.notes.push(format!("{name}: skipped"));
continue;
}
let target = match group {
Group::Final => Target::Window,
_ => Target::Buffers,
};
let program = match translate_composite(&vertex, &fragment, target) {
Ok(p) => p,
Err(errors) => {
post.notes.extend(
errors
.iter()
.map(|e| format!("{}:{}: {}", e.file, e.line, e.message)),
);
post.notes.push(format!("{name}: skipped"));
continue;
}
};
post.config.read(&vertex);
post.config.read(&fragment);
let buffers = config::draw_buffers(&fragment).unwrap_or_else(|| (0..8).collect());
post.programs.push(PostProgram {
flips: flips(properties, &name),
name,
group,
program,
buffers,
});
}
}
if let Some(inputs) = terrain {
loader.post.terrain = TERRAIN.iter().find_map(|name| {
loader.load(name.to_string(), Group::Gbuffers, |v, f| {
translate_gbuffers(v, f, Target::Buffers, inputs)
})
});
}
post.config = std::mem::take(&mut post.config).finish();
post
}
struct Loader<'a> {
pack: &'a Pack,
folder: &'a str,
properties: &'a Properties,
macros: &'a Macros,
post: &'a mut Post,
}
impl Loader<'_> {
/// The program `name` translated by `translate`, or `None` when it is missing, disabled or
/// fails (with a note).
fn load(
&mut self,
name: String,
group: Group,
translate: impl FnOnce(&Preprocessed, &Preprocessed) -> Result<Program, Vec<crate::Error>>,
) -> Option<PostProgram> {
let path = |ext: &str| match self.folder {
"" => format!("{name}.{ext}"),
f => format!("{f}/{name}.{ext}"),
};
let (vsh, fsh) = (path("vsh"), path("fsh"));
let notes = &mut self.post.notes;
if !self.pack.exists(&fsh) || !self.pack.exists(&vsh) {
return None;
}
if !enabled(self.properties, self.folder, &name, self.macros) {
return None;
}
if self.pack.exists(&path("gsh")) {
notes.push(format!(
"{name}: uses a geometry stage (not supported); skipped"
));
return None;
}
let vertex = preprocess(self.pack, &vsh, self.macros);
let fragment = preprocess(self.pack, &fsh, self.macros);
let problems: Vec<String> = [&vertex, &fragment]
.iter()
.flat_map(|pp| diagnostics(pp))
.collect();
if !problems.is_empty() {
notes.extend(problems);
notes.push(format!("{name}: skipped"));
return None;
}
let program = match translate(&vertex, &fragment) {
Ok(p) => p,
Err(errors) => {
notes.extend(
errors
.iter()
.map(|e| format!("{}:{}: {}", e.file, e.line, e.message)),
);
notes.push(format!("{name}: skipped"));
return None;
}
};
self.post.config.read(&vertex);
self.post.config.read(&fragment);
let buffers = config::draw_buffers(&fragment).unwrap_or_else(|| (0..8).collect());
Some(PostProgram {
flips: flips(self.properties, &name),
name,
group,
program,
buffers,
})
}
}
fn diagnostics(pp: &Preprocessed) -> Vec<String> {
pp.diagnostics
.iter()
@@ -248,7 +307,7 @@ mod tests {
);
assert_eq!(dimension_folder(&pack, 0), "");
assert_eq!(dimension_folder(&pack, -1), "world-1");
let post = load_post(&pack, "", &properties, &Macros::standard());
let post = load_post(&pack, "", &properties, &Macros::standard(), None);
let names: Vec<&str> = post.programs.iter().map(|p| p.name.as_str()).collect();
assert_eq!(names, ["deferred", "composite", "composite2", "final"]);
let p = &post.programs;
@@ -268,10 +327,10 @@ mod tests {
let mut macros = Macros::standard();
macros.define("HQ", "");
let post = load_post(&pack, "world-1", &properties, &macros);
let post = load_post(&pack, "world-1", &properties, &macros, None);
let names: Vec<&str> = post.programs.iter().map(|p| p.name.as_str()).collect();
assert_eq!(names, ["final"]);
let post = load_post(&pack, "", &properties, &macros);
let post = load_post(&pack, "", &properties, &macros, None);
assert!(post.programs.iter().any(|p| p.name == "composite3"));
}
@@ -281,7 +340,13 @@ mod tests {
let pack = Pack::open(&dir).unwrap();
let macros = Macros::standard();
let properties = Properties::parse(&pack.read_text("shaders.properties").unwrap(), &macros);
let post = load_post(&pack, &dimension_folder(&pack, 0), &properties, &macros);
let post = load_post(
&pack,
&dimension_folder(&pack, 0),
&properties,
&macros,
None,
);
assert!(post.notes.is_empty(), "{:?}", post.notes);
let names: Vec<&str> = post.programs.iter().map(|p| p.name.as_str()).collect();
assert_eq!(names, ["composite", "composite1", "final"]);
@@ -583,6 +583,18 @@ mod tests {
);
}
#[test]
fn locals_may_hide_a_sampler() {
let fsh = "#version 120\nuniform sampler2D specular;\nstruct M { float specular; };\n\
float f(float x) { float specular = x * 2.0; return specular; }\n\
void main() { M m = M(0.5); gl_FragColor = texture2D(specular, vec2(0.5)) * f(m.specular); }\n";
program(
&[("composite.vsh", VSH_120), ("composite.fsh", fsh)],
Target::Buffers,
)
.unwrap_or_else(|e| panic!("{e:?}"));
}
#[test]
fn errors_point_at_the_pack_file_and_line() {
let fsh =
@@ -73,6 +73,8 @@ impl Stage<'_> {
let mut calls: Vec<(&str, &str, usize)> = Vec::new();
// Sampler parameters of the function being written: name → type.
let mut params: HashMap<String, String> = HashMap::new();
// Names of samplers a local variable or parameter of the function hides.
let mut hidden: Vec<&str> = Vec::new();
let mut depth = 0;
let mut skip_until = 0;
let next = |i: usize| (i + 1..self.tokens.len()).find(|&j| significant(self.tokens[j]));
@@ -99,6 +101,7 @@ impl Stage<'_> {
depth -= 1;
if depth == 0 {
params.clear();
hidden.clear();
}
}
"(" => {
@@ -147,6 +150,22 @@ impl Stage<'_> {
continue;
}
}
// `float specular`: a variable of the same name as a sampler, from here to the
// function's end; `.specular` a member.
if sampler_ty.contains_key(t) && !params.contains_key(t) {
let before = prev(i).map(|j| self.tokens[j]);
if before == Some(".") {
out.push_str(t);
continue;
}
if before.is_some_and(|b| is_ident(b) && !matches!(b, "return" | "case" | "else")) {
hidden.push(t);
}
}
if hidden.contains(&t) {
out.push_str(t);
continue;
}
let sampler = params
.get(t)
.map(String::as_str)
+16 -3
View File
@@ -162,14 +162,27 @@ fn real_packs_read() {
for id in [0, -1, 1] {
let start = std::time::Instant::now();
let folder = dimension_folder(&pack, id);
let post = load_post(&pack, &folder, &shaders, &Macros::standard());
// Vertex inputs like the game's (gfx/pack_post.rs writes the real ones).
let terrain = horizon_shaders::GbuffersInputs {
declarations: "layout(location = 0) in vec3 hz_v_pos;".into(),
body: " hz_Vertex = vec4(hz_v_pos, 1.0);\n hz_Color = vec4(1.0);\n".into(),
attributes: vec![("mc_Entity".into(), "vec4(-1.0)".into())],
};
let post = load_post(
&pack,
&folder,
&shaders,
&Macros::standard(),
Some(&terrain),
);
println!(
" dimension {id} (folder `{folder}`): {} post programs, {} notes, {:.0} ms",
" dimension {id} (folder `{folder}`): {} post programs, terrain {:?}, {} notes, {:.0} ms",
post.programs.len(),
post.terrain.as_ref().map(|t| &t.name),
post.notes.len() + post.config.notes.len(),
start.elapsed().as_secs_f64() * 1000.0
);
for n in post.notes.iter().chain(&post.config.notes).take(5) {
for n in post.notes.iter().chain(&post.config.notes).take(12) {
println!(" {n}");
}
}