Merge pull request #1697 from ludovic111/feat/shader-packs-terrain
Shader packs, clean room 13: loading the terrain program
This commit is contained in:
@@ -42,7 +42,7 @@ impl Game<'_> {
|
||||
);
|
||||
}
|
||||
let folder = dimension_folder(&pack, dimension);
|
||||
let post = load_post(&pack, &folder, &properties, ¯os);
|
||||
let post = load_post(&pack, &folder, &properties, ¯os, None);
|
||||
if let Some((programs, notes)) = renderer.set_shader_pack(dimension, Some(post))
|
||||
{
|
||||
for note in notes {
|
||||
|
||||
@@ -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, ¯os);
|
||||
let post = load_post(&pack, "world-1", &properties, ¯os, 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, ¯os);
|
||||
let post = load_post(&pack, "", &properties, ¯os, 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(), ¯os);
|
||||
let post = load_post(&pack, &dimension_folder(&pack, 0), &properties, ¯os);
|
||||
let post = load_post(
|
||||
&pack,
|
||||
&dimension_folder(&pack, 0),
|
||||
&properties,
|
||||
¯os,
|
||||
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)
|
||||
|
||||
@@ -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}");
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user