diff --git a/crates/horizon-shaders/src/lib.rs b/crates/horizon-shaders/src/lib.rs index 9411f506c..4aa481e81 100644 --- a/crates/horizon-shaders/src/lib.rs +++ b/crates/horizon-shaders/src/lib.rs @@ -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, }; diff --git a/crates/horizon-shaders/src/post.rs b/crates/horizon-shaders/src/post.rs index 9beb7f06a..95b8c3663 100644 --- a/crates/horizon-shaders/src/post.rs +++ b/crates/horizon-shaders/src/post.rs @@ -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.` (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, /// What draws the first-person hand and held items. pub hand: Option, + /// 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, + pub shadow_water: Option, + /// `shadowcomp`..`shadowcomp99`, after the shadow pass (2.1). + pub shadow_comp: Vec, /// 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] diff --git a/crates/horizon-shaders/src/translate/mod.rs b/crates/horizon-shaders/src/translate/mod.rs index 2f0163f94..6d2ae46c6 100644 --- a/crates/horizon-shaders/src/translate/mod.rs +++ b/crates/horizon-shaders/src/translate/mod.rs @@ -154,7 +154,7 @@ pub fn translate_composite( fragment: &Preprocessed, target: Target, ) -> Result> { - 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> { - 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> { + 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> { + 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 = 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] diff --git a/crates/horizon-shaders/tests/real_packs.rs b/crates/horizon-shaders/tests/real_packs.rs index 747b732d7..70fcaa55f 100644 --- a/crates/horizon-shaders/tests/real_packs.rs +++ b/crates/horizon-shaders/tests/real_packs.rs @@ -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),