Files
horizon-airdef/crates/horizon-client/src/java_pack.rs
T
Ludovic Marie 9acc68f09f Merge feat/java-terrain-cull into feat/java-shadow-programs
The shadow samplers bind with main's custom textures (texture.* first,
then the shadow map, then the rest); the shadow layers are drawn from the
shadow list on the flat path too.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 18:00:56 +02:00

473 lines
18 KiB
Rust

//! Java (OptiFine/Iris) shader packs in `shaderpacks/` (docs/shader-packs.md):
//! a folder holding `shaders/`, or a `.zip`. `horizon-shaderpack` translates
//! their full-screen programs (`begin`, `prepare`, `deferred`, `composite`,
//! `final`) to WGSL, and `gfx/java_stages.rs` runs them over Horizon's world
//! as Iris runs them over its own. Of the geometry programs, the terrain's
//! (`gbuffers_terrain`, `gbuffers_water` and their fallbacks) draw Horizon's
//! terrain (`gfx/java_terrain.rs`); the rest of the world is Horizon's.
use horizon_shaderpack::{
JavaPack,
pipeline::{Directives, GeometryProgram, Pass, Program, TargetSettings},
preprocess::Environment,
properties::{Blend, SkyDirectives},
uniforms::CustomUniforms,
};
use std::{
collections::{BTreeMap, BTreeSet},
path::Path,
};
/// The passes of one program folder (`world0`, or `""` for the pack's root).
pub struct JavaFolder {
pub folder: String,
pub targets: Vec<TargetSettings>,
/// `begin*`, `prepare*`, `deferred*`, `composite*`, in order.
pub passes: Vec<Program>,
/// How many of `passes` run before the world (`begin*`, `prepare*`): the
/// world's colour and depth enter `world_target` and `depthtex*` after them.
pub world_at: usize,
/// The colour target the world goes into, where the pack's terrain
/// program draws (MakeUp: colortex1).
pub world_target: u32,
/// The targets whose alternate side the world is written to.
pub flipped_after_prepare: BTreeSet<u32>,
pub final_pass: Option<Program>,
/// The targets whose alternate side holds the frame's last write.
pub flipped_at_end: BTreeSet<u32>,
/// `sunPathRotation`, `eyeBrightnessHalflife`, `wetnessHalflife` and
/// `drynessHalflife`.
pub directives: Directives,
/// The programs Horizon's solid and translucent terrain are drawn with,
/// each translated for instanced and flat draws (`variants[0]`).
pub terrain: Option<GeometryProgram>,
pub water: Option<GeometryProgram>,
/// How many of `passes` run before translucent terrain (`begin*`,
/// `prepare*`, `deferred*`).
pub translucent_at: usize,
pub flipped_after_translucent: BTreeSet<u32>,
/// Each draw buffer's blending in `terrain` and `water`.
pub terrain_blends: Vec<Option<wgpu::BlendState>>,
pub water_blends: Vec<Option<wgpu::BlendState>>,
/// The shadow map's programs over Horizon's solid and translucent
/// terrain (instanced draws only), drawn after `begin*`, into
/// `shadowcolor` targets set by `shadow_targets`.
pub shadow: Option<GeometryProgram>,
pub shadow_water: Option<GeometryProgram>,
pub shadow_targets: Vec<TargetSettings>,
pub shadow_blends: Vec<Option<wgpu::BlendState>>,
pub shadow_water_blends: Vec<Option<wgpu::BlendState>>,
/// How many of `passes` run before the shadow map (`begin*`).
pub shadow_at: usize,
}
/// The key of `texture.noise` (`noisetex`) in [`JavaPasses::custom_textures`].
pub const NOISE_KEY: &str = "noise";
/// The key of `texture.<stage>.<sampler>` in [`JavaPasses::custom_textures`]
/// for a pass of `program` (`world0/composite2`): Iris's texture stages, where
/// `final` reads the `composite` ones.
pub fn texture_key(program: &str, sampler: &str) -> String {
let name = program.rsplit('/').next().unwrap_or(program);
let stage = match name.trim_end_matches(|c: char| c.is_ascii_digit()) {
"final" => "composite",
stage => stage,
};
format!("{stage}.{sampler}")
}
/// A loaded Java pack.
pub struct JavaPasses {
pub folders: Vec<JavaFolder>,
/// `uniform.*` / `variable.*` from `shaders.properties`.
pub uniforms: CustomUniforms,
/// What the pack keeps of the vanilla sky (`clouds`, `sun`, `moon`).
pub sky: SkyDirectives,
/// `block.properties`: block name → `mc_Entity` id.
pub block_ids: BTreeMap<String, i32>,
/// `texture.<stage>.<sampler>` and `texture.noise` images, by
/// `"<stage>.<sampler>"` and [`NOISE_KEY`].
pub custom_textures: BTreeMap<String, crate::shader_pack::Rgba>,
}
impl JavaPasses {
/// The folder Iris uses in `dimension` (0 overworld, -1 the Nether, 1 the
/// End): `world<N>` when the pack has one, else `world0`, else the root.
pub fn folder_for(&self, dimension: i8) -> Option<usize> {
let find = |name: &str| self.folders.iter().position(|f| f.folder == name);
find(&format!("world{dimension}"))
.or_else(|| find("world0"))
.or_else(|| find(""))
}
}
/// A folder holding `shaders/`, or a zip.
pub fn is_java_pack(path: &Path) -> bool {
path.join("shaders").is_dir()
|| path.is_file()
&& path
.extension()
.is_some_and(|e| e.eq_ignore_ascii_case("zip"))
}
/// The `MC_GL_VENDOR_*` name of a wgpu adapter (`AdapterInfo::vendor`, a
/// PCI id; Apple's GPUs report 0).
pub fn vendor_name(vendor: u32, adapter: &str) -> &'static str {
match vendor {
0x10de => "NVIDIA Corporation",
0x1002 | 0x1022 => "AMD",
0x8086 => "Intel",
_ if adapter.starts_with("Apple") => "Apple",
_ => "Unknown",
}
}
/// Open the pack at `path` and translate its full-screen passes with the
/// player's `values`; `vendor` and `renderer` name the GPU to the pack.
pub fn load(
path: &Path,
values: &BTreeMap<String, String>,
vendor: &str,
renderer: &str,
) -> Result<JavaPasses, String> {
let pack = JavaPack::open(path)?;
let values = pack.values(values);
let env = Environment::iris(vendor, renderer, 4);
let properties = pack.properties(&values, &env)?;
let mut names: Vec<&str> = ["world0", "world-1", "world1"]
.into_iter()
.filter(|d| {
pack.programs
.iter()
.any(|p| p.starts_with(&format!("{d}/")))
})
.collect();
if pack.programs.iter().any(|p| !p.contains('/')) {
names.push("");
}
let mut folders = Vec::new();
for name in names {
let plan = pack.passes(name, &values, &env, &properties)?;
let compile = |pass| {
let program = pack.compile(pass, &plan.targets, &values, &env, &properties)?;
if let Some((image, _)) = program.fragment.interface.images.first() {
return Err(format!(
"{}: images ({image}) aren't supported yet",
program.pass.program
));
}
Ok::<_, String>(program)
};
let early = plan.begin.iter().chain(&plan.prepare);
let passes = early
.clone()
.chain(&plan.deferred)
.chain(&plan.composite)
.map(compile)
.collect::<Result<Vec<_>, _>>()?;
let final_pass = plan.final_pass.as_ref().map(compile).transpose()?;
if passes.is_empty() && final_pass.is_none() {
continue;
}
// A geometry program that doesn't translate leaves that terrain to
// Horizon, with a warning.
let geometry_with = |pass: &Option<horizon_shaderpack::pipeline::Pass>,
alpha_test,
flat: &[bool]| {
let pass = pass.as_ref()?;
let glues: Vec<_> = flat
.iter()
.map(|&flat| crate::gfx::java_terrain::glue(flat, alpha_test))
.collect();
match pack.compile_geometry(pass, &plan.targets, &values, &env, &properties, &glues) {
Ok(program) => Some(program),
Err(e) => {
log::warn!("Horizon: shader pack {}: {e}", pass.program);
None
}
}
};
let geometry = |pass: &Option<horizon_shaderpack::pipeline::Pass>, alpha_test| {
geometry_with(pass, alpha_test, &[false, true])
};
// Iris's alpha test of cutout terrain (`AlphaTests.ONE_TENTH_ALPHA`).
let terrain = geometry(&plan.terrain, Some(0.1));
let water = terrain.as_ref().and_then(|_| geometry(&plan.water, None));
// The shadow map draws only with the pack's terrain, and only from
// instanced draws (the flat draws hold what the camera sees).
let shadow = terrain
.as_ref()
.and_then(|_| geometry_with(&plan.shadow, Some(0.1), &[false]));
let shadow_water = shadow
.as_ref()
.and_then(|_| geometry_with(&plan.shadow_water, None, &[false]));
let translucent_at = early.clone().count() + plan.deferred.len();
let blends = |g: &Option<GeometryProgram>, default| {
g.as_ref().map_or_else(Vec::new, |g| {
pass_blends(&g.program.pass, &g.program.draw_buffers, default)
})
};
let terrain_blends = blends(&terrain, None);
// Iris's shadow programs don't blend (`BlendModeOverride.OFF`).
let shadow_blends = blends(&shadow, None);
let shadow_water_blends = blends(&shadow_water, None);
// Vanilla's translucent blending (`BlendFunction.TRANSLUCENT`).
let water_blends = blends(
&water,
Some(wgpu::BlendState {
color: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::SrcAlpha,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
alpha: wgpu::BlendComponent {
src_factor: wgpu::BlendFactor::One,
dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
operation: wgpu::BlendOperation::Add,
},
}),
);
folders.push(JavaFolder {
folder: name.to_owned(),
targets: plan.targets,
world_at: early.count(),
world_target: plan.world_target,
passes,
flipped_after_prepare: plan.flipped_after_prepare,
final_pass,
flipped_at_end: plan.flipped_at_end,
directives: plan.directives,
terrain,
water,
translucent_at,
flipped_after_translucent: plan.flipped_after_translucent,
terrain_blends,
water_blends,
shadow,
shadow_water,
shadow_targets: plan.shadow_targets,
shadow_blends,
shadow_water_blends,
shadow_at: plan.begin.len(),
});
}
if folders.is_empty() {
return Err("no deferred, composite or final programs".into());
}
let mut custom_textures = BTreeMap::new();
for tex in properties.custom_textures() {
let key = match tex.stage {
Some(stage) => format!("{stage}.{}", tex.sampler),
None if tex.sampler == NOISE_KEY => NOISE_KEY.to_owned(),
None => continue,
};
// Only PNGs for now: resource locations and raw `.dat` textures are
// skipped and the sampler reads what it would without them.
let image = pack
.files
.read_bytes(&tex.path)
.ok_or_else(|| "not in the pack".to_owned())
.and_then(|bytes| crate::shader_pack::decode_png(&bytes));
match image {
Ok(image) => {
custom_textures.insert(key, image);
}
Err(e) => log::warn!("Horizon: shader pack texture {}: {e}", tex.path),
}
}
let uniforms = properties.custom_uniforms();
for problem in &uniforms.problems {
log::warn!("Horizon: shader pack custom uniform {problem}");
}
let block_ids = pack.block_ids(&values, &env).unwrap_or_else(|e| {
log::warn!("Horizon: shader pack {e}");
BTreeMap::new()
});
Ok(JavaPasses {
folders,
uniforms,
sky: properties.sky(),
custom_textures,
block_ids,
})
}
/// Each draw buffer's blending, as Iris's `BlendModeOverride`:
/// `blend.<program>.<buffer>`, else `blend.<program>`, else `default`
/// (none for full-screen passes, vanilla's for the geometry programs).
pub(crate) fn pass_blends(
pass: &Pass,
draw_buffers: &[u32],
default: Option<wgpu::BlendState>,
) -> Vec<Option<wgpu::BlendState>> {
let all = pass.blend.as_ref().map_or(default, blend_state);
draw_buffers
.iter()
.map(|i| {
pass.buffer_blends
.iter()
.find(|(b, _)| b == i)
.map_or(all, |(_, b)| blend_state(b))
})
.collect()
}
/// A `blend.*` value as wgpu's blending (`off`: none). The factors are the
/// GL ones `ShaderProperties` accepts.
pub(crate) fn blend_state(blend: &Blend) -> Option<wgpu::BlendState> {
let Blend::Factors(factors) = blend else {
return None;
};
let factor = |name: &str| {
use wgpu::BlendFactor as F;
match name {
"ZERO" => F::Zero,
"SRC_COLOR" => F::Src,
"ONE_MINUS_SRC_COLOR" => F::OneMinusSrc,
"DST_COLOR" => F::Dst,
"ONE_MINUS_DST_COLOR" => F::OneMinusDst,
"SRC_ALPHA" => F::SrcAlpha,
"ONE_MINUS_SRC_ALPHA" => F::OneMinusSrcAlpha,
"DST_ALPHA" => F::DstAlpha,
"ONE_MINUS_DST_ALPHA" => F::OneMinusDstAlpha,
"SRC_ALPHA_SATURATE" => F::SrcAlphaSaturated,
_ => F::One,
}
};
let component = |src: &str, dst: &str| wgpu::BlendComponent {
src_factor: factor(src),
dst_factor: factor(dst),
operation: wgpu::BlendOperation::Add,
};
Some(wgpu::BlendState {
color: component(&factors[0], &factors[1]),
alpha: component(&factors[2], &factors[3]),
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn custom_textures_belong_to_iris_s_stages() {
assert_eq!(texture_key("world0/composite2", "gaux1"), "composite.gaux1");
assert_eq!(texture_key("final", "colortex4"), "composite.colortex4");
assert_eq!(
texture_key("world-1/deferred10", "noisetex"),
"deferred.noisetex"
);
assert_eq!(texture_key("prepare", "depthtex2"), "prepare.depthtex2");
}
#[test]
fn loads_the_full_screen_passes_of_a_java_pack() {
let dir = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../horizon-shaderpack/tests/fixtures/passes");
assert!(is_java_pack(&dir));
let pack = load(&dir, &BTreeMap::new(), "Apple", "Apple M4 Pro").unwrap();
let [folder] = &pack.folders[..] else {
panic!("one folder, the root");
};
assert_eq!(folder.folder, "");
assert_eq!(
folder
.passes
.iter()
.map(|p| p.pass.program.as_str())
.collect::<Vec<_>>(),
["deferred", "composite", "composite1"]
);
assert_eq!(folder.world_at, 0);
assert!(folder.final_pass.is_some());
// The overworld, the Nether and the End all use the root.
assert_eq!([-1, 0, 1].map(|d| pack.folder_for(d)), [Some(0); 3]);
assert_eq!(
vendor_name(0x10de, "NVIDIA GeForce RTX 4080"),
"NVIDIA Corporation"
);
assert_eq!(vendor_name(0, "Apple M4 Pro"), "Apple");
}
/// wgpu is given the WGSL text: it must parse again.
fn reparse_error(pack: &JavaPasses) -> Option<String> {
let passes = pack
.folders
.iter()
.flat_map(|f| f.passes.iter().chain(&f.final_pass));
let geometry = pack.folders.iter().flat_map(|f| {
f.terrain
.iter()
.chain(&f.water)
.chain(&f.shadow)
.chain(&f.shadow_water)
});
passes
.flat_map(|p| [(p, &p.vertex, "vsh"), (p, &p.fragment, "fsh")])
.chain(geometry.flat_map(|g| {
let p = &g.program;
[(p, &p.vertex, "vsh"), (p, &p.fragment, "fsh")]
.into_iter()
.chain(g.variants.iter().map(move |v| (p, v, "vsh (flat)")))
}))
.find_map(|(p, t, ext)| {
let e = naga::front::wgsl::parse_str(&t.wgsl).err()?;
Some(format!(
"{}.{ext}: {}",
p.pass.program,
e.emit_to_string(&t.wgsl)
))
})
}
/// The packs in `HORIZON_TEST_SHADERPACKS` (folders or zips) load as the
/// game loads them, with their default options: the compatibility table
/// of docs/shader-packs.md. Skipped when the variable isn't set.
#[test]
fn real_packs_load() {
let Some(dir) = std::env::var_os("HORIZON_TEST_SHADERPACKS") else {
return;
};
let mut entries: Vec<_> = std::fs::read_dir(dir)
.unwrap()
.flatten()
.map(|e| e.path())
.filter(|p| is_java_pack(p))
.collect();
entries.sort();
let mut failures = Vec::new();
for path in entries {
let name = path.file_name().unwrap().to_string_lossy().into_owned();
match load(&path, &BTreeMap::new(), "Apple", "Apple M4 Pro") {
Ok(pack) if let Some(e) = reparse_error(&pack) => {
println!("{name}: {e}");
failures.push(name);
}
Ok(pack) => {
let folders: Vec<String> = pack
.folders
.iter()
.map(|f| {
let n = f.passes.len() + usize::from(f.final_pass.is_some());
let geometry: Vec<&str> = f
.terrain
.iter()
.chain(&f.water)
.chain(&f.shadow)
.chain(&f.shadow_water)
.map(|g| g.program.pass.program.as_str())
.collect();
format!("{} {n} passes, terrain {geometry:?}", f.folder)
})
.collect();
println!("{name}: loads ({})", folders.join(", "));
}
Err(e) => {
println!("{name}: {e}");
failures.push(name);
}
}
}
assert!(failures.is_empty(), "{failures:?}");
}
}