Merge pull request #1756 from ludovic111/feat/shader-packs-sildurs
🤖 Agent: shader packs clean room: main merged into the stack (merge commits), verify passed on this head, parity skipped by parity-scope.
This commit is contained in:
@@ -233,12 +233,18 @@ impl FrameUniforms {
|
||||
for (smoothed, target) in self.eye_smooth.iter_mut().zip(eye) {
|
||||
*smoothed = smooth(*smoothed, target, 10.0 / 20.0, dt);
|
||||
}
|
||||
// Vanilla fades by the stronger of two linear fogs; a pack gets one: the pair (start
|
||||
// and end together) of the one that is complete nearer (OQ-36). Mixing the nearer start
|
||||
// of one with the nearer end of the other made fog begin at the camera on clear days.
|
||||
let (fog_color, fog_start, fog_end) = match &frame.fog {
|
||||
Some(f) => (
|
||||
[f.color[0], f.color[1], f.color[2]],
|
||||
f.environmental_start.min(f.render_distance_start),
|
||||
f.environmental_end.min(f.render_distance_end),
|
||||
),
|
||||
Some(f) => {
|
||||
let (start, end) = if f.environmental_end < f.render_distance_end {
|
||||
(f.environmental_start, f.environmental_end)
|
||||
} else {
|
||||
(f.render_distance_start, f.render_distance_end)
|
||||
};
|
||||
([f.color[0], f.color[1], f.color[2]], start, end)
|
||||
}
|
||||
None => (frame.sky.fog_color, frame.distance * 0.9, frame.distance),
|
||||
};
|
||||
// The shadow camera (OQ-6, impl-plan.md): orthographic, `shadowDistance` (160) blocks
|
||||
|
||||
@@ -1,8 +1,9 @@
|
||||
//! Switch options (spec 8.1), as far as program-enable expressions (3.3) need them: which are on
|
||||
//! by default. A switch is `#define NAME` (on) or `//#define NAME` (off) with nothing after the
|
||||
//! name but a comment, in any stage or included file of the pack. Packs keep their options in
|
||||
//! included `.glsl` files and test them elsewhere (OQ-13), so the test the spec asks for
|
||||
//! (`#ifdef NAME` / `#ifndef NAME`) may be in any file of the pack.
|
||||
//! included `.glsl` files (or files of any name a source includes) and test them elsewhere
|
||||
//! (OQ-13), so the test the spec asks for (`#ifdef NAME` / `#ifndef NAME`) may be in any file
|
||||
//! of the pack.
|
||||
|
||||
use std::collections::BTreeSet;
|
||||
|
||||
@@ -13,14 +14,27 @@ const SOURCES: [&str; 8] = ["vsh", "fsh", "gsh", "csh", "tcs", "tes", "glsl", "i
|
||||
/// The switch options that are on by default.
|
||||
pub fn switches_on(pack: &Pack) -> BTreeSet<String> {
|
||||
let (mut on, mut off, mut tested) = (BTreeSet::new(), BTreeSet::new(), BTreeSet::new());
|
||||
for path in pack.all_files() {
|
||||
let ext = path.rsplit_once('.').map_or("", |(_, e)| e);
|
||||
if !SOURCES.contains(&ext) {
|
||||
continue;
|
||||
}
|
||||
let Some(text) = pack.read_text(&path) else {
|
||||
continue;
|
||||
};
|
||||
let files = pack.all_files();
|
||||
let source = |path: &str| SOURCES.contains(&path.rsplit_once('.').map_or("", |(_, e)| e));
|
||||
let texts: Vec<(&String, String)> = files
|
||||
.iter()
|
||||
.filter(|p| source(p))
|
||||
.filter_map(|p| Some((p, pack.read_text(p)?)))
|
||||
.collect();
|
||||
// Files of other names count when a source includes them (`#include "shaders.settings"`).
|
||||
let included: BTreeSet<&str> = texts
|
||||
.iter()
|
||||
.flat_map(|(_, t)| t.lines())
|
||||
.filter_map(|l| l.trim().strip_prefix("#include"))
|
||||
.map(|r| r.trim().trim_matches(|c| c == '"' || c == '<' || c == '>'))
|
||||
.map(|r| r.rsplit('/').next().unwrap_or(r))
|
||||
.collect();
|
||||
let extra: Vec<(&String, String)> = files
|
||||
.iter()
|
||||
.filter(|p| !source(p) && included.contains(p.rsplit('/').next().unwrap_or(p)))
|
||||
.filter_map(|p| Some((p, pack.read_text(p)?)))
|
||||
.collect();
|
||||
for (_, text) in texts.iter().chain(&extra) {
|
||||
for line in text.lines() {
|
||||
let line = line.trim();
|
||||
let (commented, rest) = match line.strip_prefix("//") {
|
||||
@@ -71,10 +85,19 @@ mod tests {
|
||||
"#ifdef AO\n#endif\n#ifndef BLOOM\n#endif\n#ifdef SPLIT\n#endif\n#ifdef LEVEL\n#endif\n",
|
||||
),
|
||||
("shaders/world-1/deferred.fsh", "//#define SPLIT\n"),
|
||||
(
|
||||
"shaders/final.fsh",
|
||||
"#include \"shaders.settings\"\n#ifdef GODRAYS\n#endif\n",
|
||||
),
|
||||
("shaders/shaders.settings", " #define GODRAYS //Toggle\n"),
|
||||
("shaders/notes.settings", "#define NOT_INCLUDED\n#ifdef NOT_INCLUDED\n"),
|
||||
("shaders/shaders.properties", "#define NOT_SOURCE\n#ifdef NOT_SOURCE\n"),
|
||||
]),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(switches_on(&pack), BTreeSet::from(["AO".to_owned()]));
|
||||
assert_eq!(
|
||||
switches_on(&pack),
|
||||
BTreeSet::from(["AO".to_owned(), "GODRAYS".to_owned()])
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -204,13 +204,30 @@ fn translate(
|
||||
})
|
||||
.collect();
|
||||
|
||||
// Varyings by name: the vertex outputs, then fragment inputs the vertex stage lacks.
|
||||
// Varyings by name: the vertex outputs, then fragment inputs the vertex stage lacks. A
|
||||
// matrix or array travels as one varying per column or element (`varying_parts`).
|
||||
let mut locations: BTreeMap<String, (u32, String)> = BTreeMap::new();
|
||||
let mut split: BTreeMap<String, (String, Vec<(String, String)>)> = BTreeMap::new();
|
||||
for var in v.outs.iter().chain(&f.ins) {
|
||||
let next = locations.len() as u32;
|
||||
locations
|
||||
.entry(var.name.clone())
|
||||
.or_insert((next, var.decl.clone()));
|
||||
if locations.contains_key(&var.name) || split.contains_key(&var.name) {
|
||||
continue;
|
||||
}
|
||||
match varying_parts(&var.decl) {
|
||||
Some((global, parts)) => {
|
||||
let mut copies = Vec::new();
|
||||
for (k, (decl, access)) in parts.into_iter().enumerate() {
|
||||
let part = format!("hz_v_{}_{k}", var.name);
|
||||
let next = locations.len() as u32;
|
||||
locations.insert(part.clone(), (next, decl));
|
||||
copies.push((part, access));
|
||||
}
|
||||
split.insert(var.name.clone(), (global, copies));
|
||||
}
|
||||
None => {
|
||||
let next = locations.len() as u32;
|
||||
locations.insert(var.name.clone(), (next, var.decl.clone()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let header = |stage: &Stage| {
|
||||
@@ -255,6 +272,9 @@ fn translate(
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
for (name, (global, _)) in &split {
|
||||
writeln!(h, "{}", global.replace("@", name)).unwrap();
|
||||
}
|
||||
if let (Some(inputs), ShaderStage::Vertex) = (gbuffers, stage.kind) {
|
||||
h.push_str(&inputs.declarations);
|
||||
h.push('\n');
|
||||
@@ -292,9 +312,15 @@ fn translate(
|
||||
for name in &v.inits {
|
||||
writeln!(vertex_main, " {name} = hz_init_{name}();").unwrap();
|
||||
}
|
||||
vertex_main.push_str(" hz_main();\n");
|
||||
for (name, (_, copies)) in &split {
|
||||
for (part, access) in copies {
|
||||
writeln!(vertex_main, " {part} = {name}{access};").unwrap();
|
||||
}
|
||||
}
|
||||
write!(
|
||||
vertex_main,
|
||||
" hz_main();\n gl_Position = vec4(gl_Position.x, {flip}gl_Position.y, (gl_Position.z + gl_Position.w) * 0.5, gl_Position.w);\n{}}}\n",
|
||||
" gl_Position = vec4(gl_Position.x, {flip}gl_Position.y, (gl_Position.z + gl_Position.w) * 0.5, gl_Position.w);\n{}}}\n",
|
||||
gbuffers.map_or("", |g| &g.after)
|
||||
)
|
||||
.unwrap();
|
||||
@@ -309,6 +335,11 @@ fn translate(
|
||||
Target::Buffers => " hz_FragCoord = gl_FragCoord;\n",
|
||||
});
|
||||
}
|
||||
for (name, (_, copies)) in &split {
|
||||
for (part, access) in copies {
|
||||
writeln!(fragment_main, " {name}{access} = {part};").unwrap();
|
||||
}
|
||||
}
|
||||
for name in &f.inits {
|
||||
writeln!(fragment_main, " {name} = hz_init_{name}();").unwrap();
|
||||
}
|
||||
@@ -363,6 +394,52 @@ fn translate(
|
||||
})
|
||||
}
|
||||
|
||||
/// A matrix or array varying (`flat mat3 @[2];`): wgpu's stage interfaces take only scalars
|
||||
/// and vectors (WGSL), so it becomes a private global (`mat3 @[2];`) and one varying per
|
||||
/// column or element, each with the qualifiers and how to reach it (`[1][2]`). `None` for
|
||||
/// scalars and vectors, and for sizes that are not plain numbers.
|
||||
fn varying_parts(decl: &str) -> Option<(String, Vec<(String, String)>)> {
|
||||
let (before, after) = decl.split_once('@')?;
|
||||
let mut words: Vec<&str> = before.split_whitespace().collect();
|
||||
let ty = words.pop()?;
|
||||
let qualifiers: String = words.iter().map(|w| format!("{w} ")).collect();
|
||||
let array = after.trim().trim_end_matches(';').trim();
|
||||
let mut sizes = Vec::new();
|
||||
let mut rest = array;
|
||||
while let Some(r) = rest.strip_prefix('[') {
|
||||
let (n, r) = r.split_once(']')?;
|
||||
sizes.push(n.trim().parse::<usize>().ok()?);
|
||||
rest = r.trim_start();
|
||||
}
|
||||
if !rest.is_empty() {
|
||||
return None;
|
||||
}
|
||||
// matC or matCxR: C columns of R rows.
|
||||
let column = ty.strip_prefix("mat").and_then(|d| {
|
||||
let (c, r) = d.split_once('x').unwrap_or((d, d));
|
||||
Some((c.parse::<usize>().ok()?, r.parse::<usize>().ok()?))
|
||||
});
|
||||
if sizes.is_empty() && column.is_none() {
|
||||
return None;
|
||||
}
|
||||
let part_ty = column.map_or(ty.to_owned(), |(_, r)| format!("vec{r}"));
|
||||
if let Some((c, _)) = column {
|
||||
sizes.push(c);
|
||||
}
|
||||
let count: usize = sizes.iter().product();
|
||||
let parts = (0..count)
|
||||
.map(|mut k| {
|
||||
let mut access = String::new();
|
||||
for &size in sizes.iter().rev() {
|
||||
access.insert_str(0, &format!("[{}]", k % size));
|
||||
k /= size;
|
||||
}
|
||||
(format!("{qualifiers}{part_ty} @;"), access)
|
||||
})
|
||||
.collect();
|
||||
Some((format!("{ty} @{array};"), parts))
|
||||
}
|
||||
|
||||
/// `sampler2DShadow` → (`texture2D`, `samplerShadow`); `isampler3D` → (`itexture3D`, `sampler`).
|
||||
pub(super) fn split_sampler(ty: &str) -> (String, &'static str) {
|
||||
let shadow = ty.ends_with("Shadow");
|
||||
@@ -643,6 +720,33 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn matrix_and_array_varyings_travel_in_parts() {
|
||||
let vsh = "#version 120\nvarying mat3 tbn;\nflat varying ivec2 ids[2];\nvarying mat2x3 m[2];\n\
|
||||
void main() {\n gl_Position = ftransform();\n tbn = mat3(2.0);\n \
|
||||
ids[1] = ivec2(3);\n m[1][0] = vec3(4.0);\n}\n";
|
||||
let fsh = "#version 120\nvarying mat3 tbn;\nflat varying ivec2 ids[2];\nvarying mat2x3 m[2];\n\
|
||||
void main() { gl_FragColor = vec4(tbn[2] + m[1][0], float(ids[1].x)); }\n";
|
||||
let p = program(
|
||||
&[("composite.vsh", vsh), ("composite.fsh", fsh)],
|
||||
Target::Buffers,
|
||||
)
|
||||
.unwrap_or_else(|e| panic!("{e:?}"));
|
||||
let inputs = p.fragment.entry_points[0].function.arguments.len();
|
||||
// 3 columns + 2 elements + 2 x 2 columns, and the fragment position.
|
||||
assert!(inputs >= 9, "{inputs} inputs");
|
||||
assert_eq!(
|
||||
varying_parts("flat ivec2 @[2];").unwrap().1,
|
||||
[
|
||||
("flat ivec2 @;".to_owned(), "[0]".to_owned()),
|
||||
("flat ivec2 @;".to_owned(), "[1]".to_owned())
|
||||
]
|
||||
);
|
||||
assert_eq!(varying_parts("mat2x3 @[2];").unwrap().1[3].1, "[1][1]");
|
||||
assert!(varying_parts("vec4 @;").is_none());
|
||||
assert!(varying_parts("vec4 @[N];").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn locals_may_hide_a_sampler() {
|
||||
let fsh = "#version 120\nuniform sampler2D specular;\nstruct M { float specular; };\n\
|
||||
|
||||
Reference in New Issue
Block a user