Merge pull request #1886 from ludovic111/feat/shader-packs-shadow-programs

🤖 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:
Ludovic Marie
2026-10-26 04:08:13 +01:00
committed by GitHub
4 changed files with 223 additions and 12 deletions
+2 -2
View File
@@ -7,7 +7,7 @@
//! - [`Properties`]: `shaders.properties` and the id files, with their conditional directives (3.1, 1.5).
//! - [`Lang`]: the pack's translated names (8.4).
//! - [`preprocess`]: a stage file through `#include` and the GLSL preprocessor, lines mapped back (1.4, 1.5).
//! - [`translate_composite`], [`translate_gbuffers`]: a program into naga modules and its interface (1.6, 2.2).
//! - [`translate_composite`], [`translate_gbuffers`], [`translate_shadow`]: a program into naga modules and its interface (1.6, 2.2).
//! - [`Config`] and [`draw_buffers`]: the buffer settings and output lists stage files carry (1.7, 6.1).
//! - [`load_post`]: a dimension's `prepare`, `deferred`, `composite` and `final` programs, in order (2.1).
//! - [`Macros`] and [`eval_condition`]: the macros packs test, and the `#if` arithmetic (1.5).
@@ -45,5 +45,5 @@ pub use preprocess::{Diagnostic, Origin, Preprocessed, preprocess};
pub use properties::{Entry, Note, Properties};
pub use translate::{
AlphaTest, DRAW_UNIFORMS, Error, GbuffersInputs, Interface, Program, Sampler, Target, Uniform,
translate_composite, translate_gbuffers,
translate_composite, translate_gbuffers, translate_shadow,
};
+177 -3
View File
@@ -15,7 +15,9 @@ use std::collections::BTreeSet;
use crate::config::{self, Config};
use crate::custom::Custom;
use crate::{GbuffersInputs, Macros, Pack, Preprocessed, Program, Properties, Target};
use crate::{eval_condition, preprocess, translate_composite, translate_gbuffers};
use crate::{
eval_condition, preprocess, translate_composite, translate_gbuffers, translate_shadow,
};
/// Which group of 2.1 a program belongs to.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -28,8 +30,32 @@ pub enum Group {
Gbuffers,
/// A gbuffers program drawing translucent geometry, after deferred (2.1).
Translucent,
/// A shadow program: the game's geometry from the shadow light, into the shadow buffers.
Shadow,
/// `shadowcomp`..`shadowcomp99`: composite-style programs over the shadow buffers.
ShadowComp,
}
impl Group {
/// Whether the group writes the shadow buffers, where buffer n is shadowcolor n.
pub fn shadow(self) -> bool {
matches!(self, Group::Shadow | Group::ShadowComp)
}
}
/// The samplers whose use turns the shadow pass on (2.5, 6.3).
const SHADOW_SAMPLERS: [&str; 9] = [
"shadow",
"watershadow",
"shadowtex0",
"shadowtex1",
"shadowtex0HW",
"shadowtex1HW",
"shadowcolor",
"shadowcolor0",
"shadowcolor1",
];
/// A blend factor of `blend.<program>` (3.2), as GL names it.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Factor {
@@ -216,6 +242,14 @@ pub struct Post {
pub weather: Option<PostProgram>,
/// What draws the first-person hand and held items.
pub hand: Option<PostProgram>,
/// Some program reads a shadow buffer, or `shadow.enabled=true`: the shadow pass runs (2.5).
pub shadow_pass: bool,
/// When it runs: what draws solid and cutout terrain from the light (`shadow`), and
/// translucent terrain (`shadow_water` or `shadow`), into the shadow buffers (2.4).
pub shadow: Option<PostProgram>,
pub shadow_water: Option<PostProgram>,
/// `shadowcomp`..`shadowcomp99`, after the shadow pass (2.1).
pub shadow_comp: Vec<PostProgram>,
/// Translucent entities draw after deferred (`separateEntityDraws`, 3.2).
pub translucent_late: bool,
/// Particles draw after deferred (`particles.ordering`, `particles.before.deferred`, 3.2).
@@ -280,6 +314,10 @@ pub fn load_post(
clouds: None,
weather: None,
hand: None,
shadow_pass: false,
shadow: None,
shadow_water: None,
shadow_comp: Vec::new(),
translucent_late: false,
particles_late: false,
custom: Custom::parse(properties),
@@ -434,10 +472,77 @@ pub fn load_post(
Some(_) => true,
None => !flag("particles.before.deferred").unwrap_or(false),
};
load_shadow(&mut loader, inputs.terrain.as_ref());
post.config = std::mem::take(&mut post.config).finish();
post
}
/// Whether the shadow pass runs (2.5) and, when it does, its programs: `shadow_solid` and
/// `shadow_cutout` are not used (2.4, Legacy); the game's solid and cutout terrain is one draw.
fn load_shadow(loader: &mut Loader<'_>, terrain: Option<&GbuffersInputs>) {
let post = &*loader.post;
let gbuffers = [
&post.terrain,
&post.water,
&post.sky,
&post.sky_textured,
&post.entities,
&post.block,
&post.entities_translucent,
&post.particles,
&post.clouds,
&post.weather,
&post.hand,
];
let reads = (post.programs.iter())
.chain(gbuffers.into_iter().flatten())
.flat_map(|p| &p.program.interface.samplers)
.any(|s| SHADOW_SAMPLERS.contains(&s.name.as_str()));
let forced = match loader.properties.get("shadow.enabled").map(str::trim) {
Some("true") => Some(true),
Some("false") => Some(false),
_ => None,
};
let on = forced.unwrap_or(reads);
loader.post.shadow_pass = on;
if !on {
return;
}
let names =
std::iter::once("shadowcomp".to_owned()).chain((1..=99).map(|n| format!("shadowcomp{n}")));
for name in names {
let program = loader.load(name, Group::ShadowComp, |v, f| {
translate_composite(v, f, Target::Buffers)
});
loader.post.shadow_comp.extend(program);
}
let Some(inputs) = terrain else {
return;
};
let properties = loader.properties;
let mut load = |names: &[&str]| {
names.iter().find_map(|name| {
let p = loader.load(name.to_string(), Group::Shadow, |v, f| {
translate_shadow(v, f, inputs)
});
p.map(|mut p| {
p.blend = blend(properties, &p.name).flatten();
p
})
})
};
let shadow = load(&["shadow"]);
let water = load(&["shadow_water", "shadow"]);
if shadow.is_none() {
loader
.post
.notes
.push("shadow: no program; the shadow map stays clear".to_owned());
}
loader.post.shadow = shadow;
loader.post.shadow_water = water;
}
struct Loader<'a> {
pack: &'a Pack,
folder: &'a str,
@@ -505,9 +610,17 @@ impl Loader<'_> {
};
self.post.config.read(&vertex);
self.post.config.read(&fragment);
let buffers = config::draw_buffers(&fragment).unwrap_or_else(|| (0..8).collect());
let mut buffers = config::draw_buffers(&fragment).unwrap_or_else(|| (0..8).collect());
if group.shadow() {
// Output n writes shadowcolor n (6.3); there are two.
let kept = buffers
.iter()
.position(|&b| b >= 2)
.unwrap_or(buffers.len());
buffers.truncate(kept);
}
let mipmaps = match group {
Group::Gbuffers | Group::Translucent => 0,
Group::Gbuffers | Group::Translucent | Group::Shadow | Group::ShadowComp => 0,
_ => {
let mut own = Config::default();
own.read(&fragment);
@@ -696,6 +809,67 @@ mod tests {
assert!(post.programs.iter().any(|p| p.name == "composite3"));
}
/// The shadow pass runs when a program reads a shadow buffer or `shadow.enabled` says so;
/// then `shadow`, `shadow_water` and the `shadowcomp` series load, writing shadowcolor0/1.
#[test]
fn shadow_programs_load_when_a_shadow_buffer_is_read() {
let reads = "#version 120\nuniform sampler2D shadowtex0;\nvarying vec2 uv;\n\
void main() { gl_FragColor = texture2D(shadowtex0, uv); }\n";
let shadow = "#version 120\nvarying vec2 uv;\nvoid main() {\n/* RENDERTARGETS: 1,0,4 */\n\
gl_FragData[0] = vec4(1.0); gl_FragData[1] = vec4(0.5); gl_FragData[2] = vec4(0.0);\n}\n";
let files = [
("shaders/composite.vsh", VSH),
("shaders/composite.fsh", reads),
("shaders/shadow.vsh", VSH),
("shaders/shadow.fsh", shadow),
("shaders/shadowcomp1.vsh", VSH),
("shaders/shadowcomp1.fsh", FSH),
];
let pack = Pack::from_zip_bytes("t", zip(&files)).unwrap();
let inputs = GameInputs {
terrain: Some(crate::GbuffersInputs {
declarations: "layout(location = 0) in vec3 hz_v_pos;".into(),
body: " hz_Vertex = vec4(hz_v_pos, 1.0);\n".into(),
..Default::default()
}),
..Default::default()
};
let load = |properties: &str| {
let properties = Properties::parse(properties, &Macros::default());
load_post(&pack, "", &properties, &Macros::standard(), &inputs)
};
let post = load("");
assert!(post.shadow_pass);
let shadow = post.shadow.as_ref().expect("shadow");
assert_eq!(
(shadow.group, &shadow.buffers[..]),
(Group::Shadow, &[1, 0][..])
);
// shadow_water falls back to shadow.
assert_eq!(
post.shadow_water.as_ref().map(|p| p.name.as_str()),
Some("shadow")
);
let comp: Vec<_> = post
.shadow_comp
.iter()
.map(|p| (p.name.as_str(), p.group))
.collect();
assert_eq!(comp, [("shadowcomp1", Group::ShadowComp)]);
// DRAWBUFFERS:3 names no shadowcolor buffer.
assert!(post.shadow_comp[0].buffers.is_empty());
let post = load("shadow.enabled = false");
assert!(!post.shadow_pass && post.shadow.is_none() && post.shadow_comp.is_empty());
// Nothing reads a shadow buffer.
let pack = Pack::from_zip_bytes("t", zip(&files[2..])).unwrap();
let none = |properties: &str| {
let properties = Properties::parse(properties, &Macros::default());
load_post(&pack, "", &properties, &Macros::standard(), &inputs)
};
assert!(!none("").shadow_pass);
assert!(none("shadow.enabled=true").shadow.is_some());
}
/// Water falls back to the terrain chain and blends by default, as the sky does; entities
/// and block entities fall back along theirs; `blend.*` overrides.
#[test]
+39 -6
View File
@@ -154,7 +154,7 @@ pub fn translate_composite(
fragment: &Preprocessed,
target: Target,
) -> Result<Program, Vec<Error>> {
translate(vertex, fragment, target, None)
translate(vertex, fragment, target, None, false)
}
/// Translates a gbuffers-style program (`gbuffers_terrain`...) drawing the game's geometry
@@ -165,7 +165,18 @@ pub fn translate_gbuffers(
target: Target,
inputs: &GbuffersInputs,
) -> Result<Program, Vec<Error>> {
translate(vertex, fragment, target, Some(inputs))
translate(vertex, fragment, target, Some(inputs), false)
}
/// Translates a shadow program (`shadow`, `shadow_water`...) drawing the game's geometry
/// described by `inputs` from the shadow light: its model-view and projection matrices are the
/// shadow camera's (5.2).
pub fn translate_shadow(
vertex: &Preprocessed,
fragment: &Preprocessed,
inputs: &GbuffersInputs,
) -> Result<Program, Vec<Error>> {
translate(vertex, fragment, Target::Buffers, Some(inputs), true)
}
/// The matrices of the compatibility profile in a gbuffers-style program, from the frame's.
@@ -183,7 +194,13 @@ fn translate(
fragment: &Preprocessed,
target: Target,
gbuffers: Option<&GbuffersInputs>,
shadow: bool,
) -> Result<Program, Vec<Error>> {
let matrices = if shadow {
GBUFFERS_MATRICES.replace("gbuffer", "shadow")
} else {
GBUFFERS_MATRICES.to_owned()
};
let mut v = Stage::scan(vertex, ShaderStage::Vertex);
let mut f = Stage::scan(fragment, ShaderStage::Fragment);
v.gbuffers = gbuffers.is_some();
@@ -200,6 +217,9 @@ fn translate(
"gbufferProjectionInverse",
] {
uniforms.insert(name.to_owned(), "mat4".to_owned());
if shadow {
uniforms.insert(name.replace("gbuffer", "shadow"), "mat4".to_owned());
}
}
}
let mut samplers: BTreeMap<String, String> = BTreeMap::new();
@@ -327,7 +347,7 @@ fn translate(
hz_MultiTexCoord0 = hz_Vertex;\n hz_Color = vec4(1.0);\n hz_Normal = vec3(0.0, 0.0, 1.0);\n",
),
Some(inputs) => {
vertex_main.push_str(GBUFFERS_MATRICES);
vertex_main.push_str(&matrices);
vertex_main.push_str(&inputs.body);
}
}
@@ -361,7 +381,7 @@ fn translate(
.unwrap();
let mut fragment_main = String::from("\nvoid main() {\n");
if gbuffers.is_some() {
fragment_main.push_str(GBUFFERS_MATRICES);
fragment_main.push_str(&matrices);
}
fragment_main.push_str(fog);
if f.frag_coord {
@@ -795,7 +815,7 @@ mod tests {
let files: Vec<(&str, &str)> = files.iter().map(|(p, t)| (p.as_str(), *t)).collect();
let pack = Pack::from_zip_bytes("P.zip", zip(&files)).unwrap();
let m = Macros::standard();
let inputs = GbuffersInputs {
let game = GbuffersInputs {
declarations: "layout(location = 0) in vec3 game_pos;\nlayout(location = 1) in uvec2 game_uv;".into(),
body: " hz_Vertex = vec4(game_pos, 1.0);\n hz_MultiTexCoord0 = vec4(vec2(game_uv) / 32768.0, 0.0, 1.0);\n \
hz_MultiTexCoord1 = vec4(240.0, 240.0, 0.0, 1.0);\n hz_Color = vec4(1.0);\n hz_Normal = vec3(0.0, 1.0, 0.0);\n"
@@ -807,7 +827,7 @@ mod tests {
&preprocess(&pack, "gbuffers_terrain.vsh", &m),
&preprocess(&pack, "gbuffers_terrain.fsh", &m),
Target::Buffers,
&inputs,
&game,
)
.unwrap_or_else(|e| panic!("{e:?}"));
let names: Vec<&str> = p
@@ -842,6 +862,19 @@ mod tests {
inputs.contains(&"game_pos") && inputs.contains(&"game_uv"),
"{inputs:?}"
);
// From the light, the compatibility matrices are the shadow camera's.
let shadow = translate_shadow(
&preprocess(&pack, "gbuffers_terrain.vsh", &m),
&preprocess(&pack, "gbuffers_terrain.fsh", &m),
&game,
)
.unwrap_or_else(|e| panic!("{e:?}"));
let names: Vec<&str> = (shadow.interface.uniforms.iter())
.map(|u| u.name.as_str())
.collect();
for name in ["shadowModelView", "shadowProjection", "gbufferModelView"] {
assert!(names.contains(&name), "{name} missing from {names:?}");
}
}
#[test]
+5 -1
View File
@@ -180,8 +180,12 @@ fn real_packs_read() {
};
let post = load_post(&pack, &folder, &shaders, &Macros::standard(), &inputs);
println!(
" dimension {id} (folder `{folder}`): {} post programs, terrain {:?}, water {:?}, sky {:?} {:?}, entities {:?} {:?}, {} notes, {:.0} ms",
" dimension {id} (folder `{folder}`): {} post programs, shadow pass {} ({:?}, {:?}, {} shadowcomp), terrain {:?}, water {:?}, sky {:?} {:?}, entities {:?} {:?}, {} notes, {:.0} ms",
post.programs.len(),
post.shadow_pass,
post.shadow.as_ref().map(|t| &t.name),
post.shadow_water.as_ref().map(|t| &t.name),
post.shadow_comp.len(),
post.terrain.as_ref().map(|t| &t.name),
post.water.as_ref().map(|t| &t.name),
post.sky.as_ref().map(|t| &t.name),