horizon-shaderpack: plan a Java pack's full-screen passes like Iris

The begin, prepare, deferred, composite and final passes of a program
folder: what each writes (the later of DRAWBUFFERS and RENDERTARGETS),
which side of every ping-ponged colour target it reads (Iris's
BufferFlipper, with flip.* overrides), mipmapped targets, scale.*, and
the targets' formats, clearing and sizes from the consts of every pass
in Iris's order. The preprocessor now keeps the directive comments of
active code, as Iris's does, so a DRAWBUFFERS in an #if'd out branch
doesn't count.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-15 22:34:29 +02:00
parent 38a9f6543f
commit e1d9ae1dd7
16 changed files with 897 additions and 2 deletions
+1
View File
@@ -7,6 +7,7 @@
pub mod include;
pub mod options;
pub mod pipeline;
pub mod preprocess;
pub mod properties;
pub mod source;
+640
View File
@@ -0,0 +1,640 @@
//! Iris's full-screen passes and the colour targets they draw to: which
//! programs run (`begin*`, `prepare*`, `deferred*`, `composite*`, `final`),
//! the targets each one writes (`/* DRAWBUFFERS:01 */`, `/* RENDERTARGETS:
//! 0,1 */`), the targets' formats and clearing (`const int colortex0Format
//! = RGBA16F;` and friends), and which side of each ping-ponged target a
//! pass reads (`BufferFlipper`). Read from the preprocessed sources with
//! their comments, as Iris's `ProgramDirectives`, `PackRenderTargetDirectives`
//! and `CompositeRenderer` do.
use crate::{
JavaPack, options::OptionValues, preprocess::Environment, properties::LEGACY_TARGETS,
properties::ShaderProperties,
};
use std::collections::{BTreeMap, BTreeSet};
/// Colour targets Iris supports (`IrisLimits.MAX_COLOR_BUFFERS`).
pub const MAX_COLOR_BUFFERS: u32 = 32;
/// The formats `const int colortexNFormat` may name (`InternalTextureFormat`).
pub const TEXTURE_FORMATS: &[&str] = &[
"RGBA",
"R8",
"RG8",
"RGB8",
"RGBA8",
"R8_SNORM",
"RG8_SNORM",
"RGB8_SNORM",
"RGBA8_SNORM",
"R16",
"RG16",
"RGB16",
"RGBA16",
"R16_SNORM",
"RG16_SNORM",
"RGB16_SNORM",
"RGBA16_SNORM",
"R16F",
"RG16F",
"RGB16F",
"RGBA16F",
"R32F",
"RG32F",
"RGB32F",
"RGBA32F",
"R8I",
"RG8I",
"RGB8I",
"RGBA8I",
"R8UI",
"RG8UI",
"RGB8UI",
"RGBA8UI",
"R16I",
"RG16I",
"RGB16I",
"RGBA16I",
"R16UI",
"RG16UI",
"RGB16UI",
"RGBA16UI",
"R32I",
"RG32I",
"RGB32I",
"RGBA32I",
"R32UI",
"RG32UI",
"RGB32UI",
"RGBA32UI",
"RGBA2",
"RGBA4",
"R3_G3_B2",
"RGB5_A1",
"RGB565",
"RGB10_A2",
"RGB10_A2UI",
"R11F_G11F_B10F",
"RGB9_E5",
];
/// The value of the last `/* NAME:value */` in `text` and where it starts
/// (`CommentDirectiveParser.findDirective`).
pub fn comment_directive(text: &str, name: &str) -> Option<(usize, String)> {
let prefix = format!("{name}:");
let at = text.rfind(&prefix)?;
if !text[..at].trim_end().ends_with("/*") {
return None;
}
let rest = &text[at + prefix.len()..];
let end = rest.find("*/")?;
Some((at, rest[..end].trim().to_owned()))
}
/// A `const <type> <key> = <value>;` line (`ConstDirectiveParser`).
#[derive(Clone, Debug, PartialEq)]
pub struct ConstDirective {
/// `int`, `float`, `vec2`, `ivec3`, `vec4` or `bool`.
pub ty: &'static str,
pub key: String,
pub value: String,
}
/// Every line of `text` that starts with a `const` Iris reads, in order.
pub fn const_directives(text: &str) -> Vec<ConstDirective> {
text.lines().filter_map(const_directive).collect()
}
fn const_directive(line: &str) -> Option<ConstDirective> {
if !line.contains("const") || !line.contains('=') || !line.contains(';') {
return None;
}
let rest = line.trim().strip_prefix("const")?;
if !rest.starts_with(char::is_whitespace) {
return None;
}
let rest = rest.trim_start();
// In Iris's order: `ivec3` before `vec4` doesn't matter, but `int` must
// not take `ivec3`'s place, and it can't (`ivec3` starts with `i`, `v`).
let ty = ["int", "float", "vec2", "ivec3", "vec4", "bool"]
.into_iter()
.find(|t| rest.starts_with(t))?;
let rest = &rest[ty.len()..];
if !rest.starts_with(char::is_whitespace) {
return None;
}
let (key, value) = rest.split_once('=')?;
let key = key.trim();
if key.is_empty() || !key.chars().all(|c| c.is_alphanumeric() || c == '_') {
return None;
}
let value = value.split_once(';')?.0.trim();
Some(ConstDirective {
ty,
key: key.to_owned(),
value: value.to_owned(),
})
}
/// The targets a fragment program writes, by output location: the later of
/// its `DRAWBUFFERS` and `RENDERTARGETS` directives, or `None` without one
/// (Iris then takes the `gl_FragData` indices it writes).
pub fn draw_buffers(fragment: &str) -> Result<Option<Vec<u32>>, String> {
let draw = comment_directive(fragment, "DRAWBUFFERS");
let render = comment_directive(fragment, "RENDERTARGETS");
let (digits, value) = match (draw, render) {
(Some(d), Some(r)) if d.0 > r.0 => (true, d.1),
(_, Some(r)) => (false, r.1),
(Some(d), None) => (true, d.1),
(None, None) => return Ok(None),
};
let bad = || format!("invalid render targets `{value}`");
let targets: Vec<u32> = if digits {
value
.chars()
.map(|c| c.to_digit(10).ok_or_else(bad))
.collect::<Result<_, _>>()?
} else {
value
.split(',')
.map(|t| t.trim().parse().map_err(|_| bad()))
.collect::<Result<_, _>>()?
};
match targets.iter().find(|&&t| t >= MAX_COLOR_BUFFERS) {
Some(t) => Err(format!(
"render target {t} is not supported, only {MAX_COLOR_BUFFERS} are"
)),
None => Ok(Some(targets)),
}
}
/// The index of a target name, `colortex<N>` or a legacy one (`gaux1`).
pub fn target_index(name: &str) -> Option<u32> {
match LEGACY_TARGETS.iter().position(|t| *t == name) {
Some(i) => Some(i as u32),
None => name
.strip_prefix("colortex")?
.parse()
.ok()
.filter(|&i| i < MAX_COLOR_BUFFERS),
}
}
/// A key naming a target and a suffix (`colortex4Format`, `gaux1Clear`).
fn target_key(key: &str, suffix: &str) -> Option<u32> {
target_index(key.strip_suffix(suffix)?)
}
/// A colour target's settings (`RenderTargetSettings`, `size.buffer.*`).
#[derive(Clone, Debug, PartialEq)]
pub struct TargetSettings {
/// One of [`TEXTURE_FORMATS`]; `RGBA` (8 bits per channel) by default.
pub format: String,
/// Cleared every frame (the default), or kept for the next frame.
pub clear: bool,
/// Iris clears to black, or `colortex0` to the fog colour, without one.
pub clear_color: Option<[f32; 4]>,
/// `size.buffer.<name>`: a fraction of the screen or a size in pixels.
pub size: Option<TargetSize>,
}
impl Default for TargetSettings {
fn default() -> Self {
Self {
format: "RGBA".into(),
clear: true,
clear_color: None,
size: None,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TargetSize {
Relative(f32, f32),
Pixels(u32, u32),
}
/// Every target's settings from the consts of `fragments`, read in order so
/// the last one wins, then `size.buffer.*` from the properties.
pub fn target_settings<'a>(
fragments: impl IntoIterator<Item = &'a str>,
properties: &ShaderProperties,
) -> Vec<TargetSettings> {
let mut targets = vec![TargetSettings::default(); MAX_COLOR_BUFFERS as usize];
for fragment in fragments {
for c in const_directives(fragment) {
match c.ty {
"int" => {
if let Some(i) = target_key(&c.key, "Format") {
let format = c.value.to_uppercase();
if TEXTURE_FORMATS.contains(&format.as_str()) {
targets[i as usize].format = format;
}
}
}
"bool" => {
if let (Some(i), Ok(clear)) = (target_key(&c.key, "Clear"), c.value.parse()) {
targets[i as usize].clear = clear;
}
}
"vec4" => {
if let (Some(i), Some(color)) =
(target_key(&c.key, "ClearColor"), parse_vec4(&c.value))
{
targets[i as usize].clear_color = Some(color);
}
}
_ => {}
}
}
}
for (key, value) in properties.preprocessed.iter() {
let Some(i) = key.strip_prefix("size.buffer.").and_then(target_index) else {
continue;
};
let parts: Vec<&str> = value.split_whitespace().collect();
if let [w, h] = parts[..] {
targets[i as usize].size = if w.contains('.') || h.contains('.') {
w.parse()
.ok()
.zip(h.parse().ok())
.map(|(w, h)| TargetSize::Relative(w, h))
} else {
w.parse()
.ok()
.zip(h.parse().ok())
.map(|(w, h)| TargetSize::Pixels(w, h))
};
}
}
targets
}
fn parse_vec4(value: &str) -> Option<[f32; 4]> {
let args = value.strip_prefix("vec4")?.trim();
let args = args.strip_prefix('(')?.strip_suffix(')')?;
let parts: Vec<f32> = args
.split(',')
.map(|p| p.trim().parse().ok())
.collect::<Option<_>>()?;
parts.try_into().ok()
}
/// One full-screen pass.
#[derive(Clone, Debug, PartialEq)]
pub struct Pass {
/// The program's path without extension (`world0/composite1`).
pub program: String,
/// What it writes, by output location; `None`: the outputs it writes.
pub draw_buffers: Option<Vec<u32>>,
/// Targets it reads from their alternate side (it writes the other side).
pub reads_alt: BTreeSet<u32>,
/// Targets whose mipmaps it wants generated before it runs.
pub mipmapped: BTreeSet<u32>,
/// `scale.<name>`: the fraction of the screen it draws.
pub scale: f32,
}
/// The full-screen passes of one program folder, in order, and the
/// flipping state between them.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Passes {
pub targets: Vec<TargetSettings>,
pub begin: Vec<Pass>,
pub prepare: Vec<Pass>,
/// The targets gbuffers programs (and Horizon's world) write on their
/// alternate side, before and after translucent geometry.
pub flipped_after_prepare: BTreeSet<u32>,
pub deferred: Vec<Pass>,
pub flipped_after_translucent: BTreeSet<u32>,
pub composite: Vec<Pass>,
/// `final`, which writes the screen; `None` without one (Iris then
/// copies `colortex0` to the screen).
pub final_pass: Option<Pass>,
/// After `final`, these targets' alternate side is copied back so the
/// next frame starts unflipped.
pub flipped_at_end: BTreeSet<u32>,
}
/// Iris's single programs (`ProgramId`), in order.
const SINGLE_PROGRAMS: &[&str] = &[
"shadow",
"shadow_solid",
"shadow_cutout",
"shadow_water",
"shadow_entities",
"shadow_lightning",
"shadow_block",
"gbuffers_basic",
"gbuffers_line",
"gbuffers_textured",
"gbuffers_textured_lit",
"gbuffers_skybasic",
"gbuffers_skytextured",
"gbuffers_clouds",
"gbuffers_terrain",
"gbuffers_terrain_solid",
"gbuffers_terrain_cutout",
"gbuffers_damagedblock",
"gbuffers_block",
"gbuffers_block_translucent",
"gbuffers_beaconbeam",
"gbuffers_item",
"gbuffers_entities",
"gbuffers_entities_translucent",
"gbuffers_lightning",
"gbuffers_particles",
"gbuffers_particles_translucent",
"gbuffers_entities_glowing",
"gbuffers_armor_glint",
"gbuffers_spidereyes",
"gbuffers_hand",
"gbuffers_weather",
"gbuffers_water",
"gbuffers_hand_water",
"dh_terrain",
"dh_water",
"dh_generic",
"dh_shadow",
"final",
];
/// The program groups that run as full-screen passes, in Iris's order.
const GROUPS: &[&str] = &["begin", "prepare", "deferred", "composite"];
impl JavaPack {
/// The full-screen passes of the programs in `dir` (`world0`, or `""`
/// for the pack's root), with the player's `values`.
pub fn passes(
&self,
dir: &str,
values: &OptionValues,
env: &Environment,
properties: &ShaderProperties,
) -> Result<Passes, String> {
let path = |name: &str| {
if dir.is_empty() {
name.to_owned()
} else {
format!("{dir}/{name}")
}
};
// A pass needs both halves, and its `program.*.enabled` to hold.
let exists = |name: &str| {
let p = path(name);
self.programs.contains(&format!("{p}.vsh"))
&& self.programs.contains(&format!("{p}.fsh"))
&& properties.program_enabled(&p, &self.options, values)
};
let fragment = |name: &str| -> Result<String, String> {
let file = format!("{}.fsh", path(name));
Ok(self.preprocess(&file, values, env)?.with_comments())
};
let group = |base: &str| -> Vec<String> {
(0..100)
.map(|i| {
if i == 0 {
base.to_owned()
} else {
format!("{base}{i}")
}
})
.filter(|name| exists(name))
.collect()
};
let groups: Vec<Vec<String>> = GROUPS.iter().map(|g| group(g)).collect();
// Target settings come from the fragments of every pass, in Iris's
// order (`ProgramSet.locateDirectives`): some packs declare them in
// `final` only.
let mut sources: Vec<String> = Vec::new();
for name in group("shadowcomp")
.iter()
.chain(&groups[0])
.chain(&groups[1])
{
sources.push(fragment(name)?);
}
for name in SINGLE_PROGRAMS {
if exists(name) {
sources.push(fragment(name)?);
}
}
let mut fragments: BTreeMap<String, String> = BTreeMap::new();
for name in groups[2].iter().chain(&groups[3]) {
let text = fragment(name)?;
sources.push(text.clone());
fragments.insert(name.clone(), text);
}
for name in &groups[0..2].concat() {
fragments.insert(name.clone(), fragment(name)?);
}
let mut out = Passes {
targets: target_settings(sources.iter().map(String::as_str), properties),
..Passes::default()
};
let flips = explicit_flips(properties);
let run = |group: &[String], pre: &str, flipped: &mut BTreeSet<u32>| {
*flipped = flips_pre(&flips, pre, flipped);
let mut passes = Vec::new();
for name in group {
let text = &fragments[name];
let pass = Pass {
program: path(name),
draw_buffers: draw_buffers(text).map_err(|e| format!("{}: {e}", path(name)))?,
reads_alt: flipped.clone(),
mipmapped: mipmapped(text),
scale: properties
.preprocessed
.get(&format!("scale.{name}"))
.and_then(|v| v.split_whitespace().next()?.parse().ok())
.unwrap_or(1.0),
};
*flipped = flip_set(&pass, &flips);
passes.push(pass);
}
Ok::<_, String>(passes)
};
let mut flipped = BTreeSet::new();
out.begin = run(&groups[0], "begin_pre", &mut flipped)?;
out.prepare = run(&groups[1], "prepare_pre", &mut flipped)?;
out.flipped_after_prepare = flipped.clone();
out.deferred = run(&groups[2], "deferred_pre", &mut flipped)?;
out.flipped_after_translucent = flipped.clone();
out.composite = run(&groups[3], "composite_pre", &mut flipped)?;
out.flipped_at_end = flipped;
if exists("final") {
out.final_pass = Some(Pass {
program: path("final"),
draw_buffers: None,
reads_alt: out.flipped_at_end.clone(),
mipmapped: mipmapped(&fragment("final")?),
scale: 1.0,
});
}
Ok(out)
}
}
fn toggle(set: &mut BTreeSet<u32>, buffer: u32) {
if !set.remove(&buffer) {
set.insert(buffer);
}
}
/// `flip.<pass>.<buffer> = true|false`, by pass and target index.
fn explicit_flips(properties: &ShaderProperties) -> BTreeMap<&str, BTreeMap<u32, bool>> {
let mut out: BTreeMap<&str, BTreeMap<u32, bool>> = BTreeMap::new();
for (key, value) in properties.preprocessed.iter() {
let Some((pass, buffer)) = key.strip_prefix("flip.").and_then(|k| k.split_once('.')) else {
continue;
};
if let (Some(i), Ok(flip)) = (target_index(buffer), value.trim().parse()) {
out.entry(pass).or_default().insert(i, flip);
}
}
out
}
/// The flipped set after `pass` ran: what it read, flipped by its writes
/// and its explicit flips.
fn flip_set(pass: &Pass, flips: &BTreeMap<&str, BTreeMap<u32, bool>>) -> BTreeSet<u32> {
let name = pass.program.rsplit('/').next().unwrap_or(&pass.program);
let explicit = flips.get(name);
let mut set = pass.reads_alt.clone();
for &buffer in pass.draw_buffers.as_deref().unwrap_or(&[0]) {
if explicit.and_then(|f| f.get(&buffer)) != Some(&false) {
toggle(&mut set, buffer);
}
}
for (&buffer, &flip) in explicit.into_iter().flatten() {
if flip {
toggle(&mut set, buffer);
}
}
set
}
fn flips_pre(
flips: &BTreeMap<&str, BTreeMap<u32, bool>>,
pre: &str,
before: &BTreeSet<u32>,
) -> BTreeSet<u32> {
let mut set = before.clone();
for (&buffer, &flip) in flips.get(pre).into_iter().flatten() {
if flip {
toggle(&mut set, buffer);
}
}
set
}
/// `const bool colortexNMipmapEnabled = true;` in a program's fragment.
fn mipmapped(fragment: &str) -> BTreeSet<u32> {
let mut out = BTreeSet::new();
for c in const_directives(fragment) {
if c.ty != "bool" {
continue;
}
if let Some(i) = target_key(&c.key, "MipmapEnabled") {
match c.value.as_str() {
"true" => out.insert(i),
"false" => out.remove(&i),
_ => false,
};
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn comment_directives_as_iris_finds_them() {
// Iris's own cases (`CommentDirectiveParser.Tests`).
let find = |text: &str, name: &str| comment_directive(text, name).map(|d| d.1);
let draw = |text: &str| find(text, "DRAWBUFFERS");
assert_eq!(
draw("Some normal text that doesn't contain a DRAWBUFFERS directive"),
None
);
assert_eq!(
draw("doesn't contain a /* DRAWBUFFERS: directive of any sort"),
None
);
assert_eq!(
draw("/*DRAWBUFFERS:321*/ OptiFine will detect this").as_deref(),
Some("321")
);
assert_eq!(
draw("a directive: /* DRAWBUFFERS:321 */").as_deref(),
Some("321")
);
assert_eq!(
draw("This is a line /* DRAWBUFFERS:31 */ containing").as_deref(),
Some("31")
);
assert_eq!(
draw("/* DRAWBUFFERS: */ invalid but matching").as_deref(),
Some("")
);
assert_eq!(draw(" /*DRAWBUFFERS:12*/").as_deref(), Some("12"));
let lines = "/* RENDERTARGETS:Duplicate handling? */\nuniform sampler2D test;\n\
/* RENDERTARGETS:Within a line? */ Let's see /* RENDERTARGETS:It works */\n";
assert_eq!(find(lines, "RENDERTARGETS").as_deref(), Some("It works"));
// The later directive wins, whichever kind it is.
assert_eq!(
draw_buffers("/* RENDERTARGETS: 4,10 */ /* DRAWBUFFERS:02 */"),
Ok(Some(vec![0, 2]))
);
assert_eq!(
draw_buffers("/* DRAWBUFFERS:02 */ /* RENDERTARGETS: 4,10 */"),
Ok(Some(vec![4, 10]))
);
assert_eq!(draw_buffers("void main() {}"), Ok(None));
assert!(draw_buffers("/* RENDERTARGETS: 40 */").is_err());
assert!(draw_buffers("/* DRAWBUFFERS:0a */").is_err());
}
#[test]
fn const_directives_and_target_settings() {
let text = "\
const int colortex4Format = rgba16f;
const bool gaux2Clear = false; // kept between frames
const vec4 colortex0ClearColor = vec4(0.5, 0.25, 0.0, 1.0);
const int colortex5Format = NOT_A_FORMAT;
uniform const int x = 1;
const int colortex6Format=RGBA8;
const intx colortex7Format = RGBA8;
const ivec3 workGroups = ivec3(16, 8, 16);
";
let consts = const_directives(text);
assert_eq!(
consts
.iter()
.map(|c| (c.ty, c.key.as_str(), c.value.as_str()))
.collect::<Vec<_>>(),
[
("int", "colortex4Format", "rgba16f"),
("bool", "gaux2Clear", "false"),
("vec4", "colortex0ClearColor", "vec4(0.5, 0.25, 0.0, 1.0)"),
("int", "colortex5Format", "NOT_A_FORMAT"),
("int", "colortex6Format", "RGBA8"),
("ivec3", "workGroups", "ivec3(16, 8, 16)"),
],
"a type needs a space after it, the name doesn't"
);
let targets = target_settings([text], &ShaderProperties::default());
assert_eq!(targets.len(), MAX_COLOR_BUFFERS as usize);
assert_eq!(targets[4].format, "RGBA16F");
assert_eq!(targets[5].format, "RGBA", "unknown formats are ignored");
assert!(!targets[5].clear, "gaux2 is colortex5");
assert_eq!(targets[0].clear_color, Some([0.5, 0.25, 0.0, 1.0]));
assert_eq!(targets[1], TargetSettings::default());
}
}
+93 -1
View File
@@ -204,11 +204,92 @@ pub struct Preprocessed {
pub version: Vec<String>,
/// `#extension` lines' words (`["GL_ARB_gpu_shader5", ":", "enable"]`).
pub extensions: Vec<Vec<String>>,
/// The comments Iris reads directives from (`/* DRAWBUFFERS:01 */`,
/// `const int colortex0Format = RGBA16F;`) that are outside `#if`'d out
/// blocks, with their output line. Iris keeps comments through its
/// preprocessor; pp-rs drops them.
pub comments: Vec<(u32, String)>,
}
impl Preprocessed {
/// The text with its kept comments put back at the start of their
/// lines: what Iris's directive parsers read.
pub fn with_comments(&self) -> String {
let mut comments = self.comments.iter().peekable();
let mut out = String::new();
for (i, line) in self.text.lines().enumerate() {
while let Some((_, comment)) = comments.next_if(|(at, _)| *at as usize <= i + 1) {
out.push_str(comment);
out.push(' ');
}
out.push_str(line);
out.push('\n');
}
out
}
}
/// What a comment must hold for Iris to read a directive from it.
const DIRECTIVE_WORDS: &[&str] = &["DRAWBUFFERS:", "RENDERTARGETS:", "const"];
/// The identifier a kept comment is replaced by while pp-rs runs.
const COMMENT_MARK: &str = "iris_comment_";
/// Replace the comments holding [`DIRECTIVE_WORDS`] with an identifier
/// (and their line breaks), so the ones in `#if`'d out blocks disappear with
/// them. Comments on directive lines are left alone: there the identifier
/// would end up in a macro or an `#if`.
fn mark_comments(text: &str) -> (String, Vec<String>) {
let mut out = String::with_capacity(text.len());
let mut comments = Vec::new();
let (mut directive, mut line_start, mut continued) = (false, true, false);
let mut rest = text;
while let Some(c) = rest.chars().next() {
let comment_len = if rest.starts_with("//") {
rest.find('\n').unwrap_or(rest.len())
} else if let Some(body) = rest.strip_prefix("/*") {
body.find("*/").map_or(rest.len(), |i| i + 4)
} else {
0
};
if comment_len > 0 {
let comment = &rest[..comment_len];
if !directive && DIRECTIVE_WORDS.iter().any(|w| comment.contains(w)) {
out.push_str(&format!(" {COMMENT_MARK}{} ", comments.len()));
out.extend(std::iter::repeat_n('\n', comment.matches('\n').count()));
comments.push(comment.to_owned());
} else {
out.push_str(comment);
}
if comment.contains('\n') {
// A comment spanning lines ends a directive like a line break.
directive = false;
}
line_start = false;
rest = &rest[comment_len..];
continue;
}
match c {
'\n' => {
directive = directive && continued;
line_start = !directive;
}
'#' if line_start => directive = true,
c if c.is_whitespace() => {}
_ => line_start = false,
}
if c != '\r' && !c.is_whitespace() || c == '\n' {
continued = c == '\\';
}
out.push(c);
rest = &rest[c.len_utf8()..];
}
(out, comments)
}
/// Expand `source` with `env`'s macros. Errors name the file and line.
pub fn preprocess(source: &Inlined, env: &Environment) -> Result<Preprocessed, String> {
let text = &source.text;
let (marked, comments) = mark_comments(&source.text);
let text = &marked;
let line_starts: Vec<usize> = std::iter::once(0)
.chain(text.match_indices('\n').map(|(i, _)| i + 1))
.collect();
@@ -222,6 +303,7 @@ pub fn preprocess(source: &Inlined, env: &Environment) -> Result<Preprocessed, S
text: String::new(),
version: Vec::new(),
extensions: Vec::new(),
comments: Vec::new(),
};
let mut line = 1;
for item in pp {
@@ -239,6 +321,16 @@ pub fn preprocess(source: &Inlined, env: &Environment) -> Result<Preprocessed, S
continue;
}
TokenValue::Pragma(_) => continue,
TokenValue::Ident(ref name) if name.starts_with(COMMENT_MARK) => {
if let Some(comment) = name[COMMENT_MARK.len()..]
.parse::<usize>()
.ok()
.and_then(|i| comments.get(i))
{
out.comments.push((at, comment.clone()));
}
continue;
}
value => spelling(value),
};
if at > line {
@@ -0,0 +1,17 @@
#version 120
uniform sampler2D colortex3;
varying vec2 texcoord;
#ifdef BLOOM
/*
const int colortex1Format = R8;
*/
#endif
const bool colortex3MipmapEnabled = true; // read with mipmaps
void main() {
#if 0
/* DRAWBUFFERS:12 */
#endif
/* RENDERTARGETS: 0,1 */
gl_FragData[0] = texture2D(colortex3, texcoord);
gl_FragData[1] = vec4(1.0);
}
@@ -0,0 +1,3 @@
#version 120
varying vec2 texcoord;
void main() { gl_Position = ftransform(); texcoord = gl_MultiTexCoord0.xy; }
@@ -0,0 +1,7 @@
#version 120
uniform sampler2D colortex0;
varying vec2 texcoord;
void main() {
/* DRAWBUFFERS:0 */
gl_FragData[0] = texture2D(colortex0, texcoord);
}
@@ -0,0 +1,3 @@
#version 120
varying vec2 texcoord;
void main() { gl_Position = ftransform(); texcoord = gl_MultiTexCoord0.xy; }
@@ -0,0 +1,5 @@
#version 120
void main() {
/* DRAWBUFFERS:7 */
gl_FragData[0] = vec4(1.0);
}
@@ -0,0 +1,3 @@
#version 120
varying vec2 texcoord;
void main() { gl_Position = ftransform(); texcoord = gl_MultiTexCoord0.xy; }
@@ -0,0 +1,11 @@
#version 120
varying vec2 texcoord;
/*
const int colortex1Format = RGBA16F;
const bool colortex2Clear = false;
const vec4 colortex3ClearColor = vec4(1.0, 0.0, 0.0, 1.0);
*/
void main() {
/* DRAWBUFFERS:3 */
gl_FragData[0] = vec4(texcoord, 0.0, 1.0);
}
@@ -0,0 +1,3 @@
#version 120
varying vec2 texcoord;
void main() { gl_Position = ftransform(); texcoord = gl_MultiTexCoord0.xy; }
@@ -0,0 +1,6 @@
#version 120
uniform sampler2D colortex0;
varying vec2 texcoord;
void main() {
gl_FragColor = texture2D(colortex0, texcoord);
}
@@ -0,0 +1,3 @@
#version 120
varying vec2 texcoord;
void main() { gl_Position = ftransform(); texcoord = gl_MultiTexCoord0.xy; }
@@ -0,0 +1,6 @@
# Full-screen passes: a smaller composite1 that also flips colortex2,
# composite2 off, colortex3 at half size.
scale.composite1 = 0.5
flip.composite1.colortex2 = true
program.composite2.enabled = false
size.buffer.colortex3 = 0.5 0.5
+95 -1
View File
@@ -3,7 +3,11 @@
//! `HORIZON_TEST_SHADERPACKS` names a folder of them (development only:
//! third-party packs are never committed).
use horizon_shaderpack::{JavaPack, Stage, preprocess::Environment};
use horizon_shaderpack::{
JavaPack, Stage,
pipeline::{TargetSettings, TargetSize},
preprocess::Environment,
};
use std::{
collections::BTreeMap,
io::Write,
@@ -187,6 +191,54 @@ fn opens_zips_with_shaders_in_a_subfolder() {
std::fs::remove_dir_all(dir).unwrap();
}
#[test]
fn plans_the_full_screen_passes() {
let pack = JavaPack::open(&Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/passes"))
.unwrap();
let values = pack.values(&BTreeMap::new());
let properties = pack.properties(&values, &env()).unwrap();
let passes = pack.passes("", &values, &env(), &properties).unwrap();
// Settings from the active comments only: colortex1's R8 is #ifdef'd out.
assert_eq!(passes.targets[1].format, "RGBA16F");
assert!(!passes.targets[2].clear);
assert_eq!(passes.targets[3].clear_color, Some([1.0, 0.0, 0.0, 1.0]));
assert_eq!(passes.targets[3].size, Some(TargetSize::Relative(0.5, 0.5)));
assert_eq!(passes.targets[4], TargetSettings::default());
let summary = |p: &horizon_shaderpack::pipeline::Pass| {
(
p.program.clone(),
p.draw_buffers.clone(),
p.reads_alt.iter().copied().collect::<Vec<_>>(),
)
};
assert_eq!(
passes.deferred.iter().map(summary).collect::<Vec<_>>(),
[("deferred".into(), Some(vec![3]), vec![])]
);
// composite2 is off; RENDERTARGETS in `#if 0` doesn't count; each pass
// reads the side its predecessors wrote, and composite1 flips colortex2.
assert_eq!(
passes.composite.iter().map(summary).collect::<Vec<_>>(),
[
("composite".into(), Some(vec![0, 1]), vec![3]),
("composite1".into(), Some(vec![0]), vec![0, 1, 3]),
]
);
assert_eq!(passes.composite[0].mipmapped, [3].into());
assert_eq!(passes.composite[1].scale, 0.5);
assert_eq!(passes.flipped_after_prepare, [].into());
assert_eq!(passes.flipped_after_translucent, [3].into());
assert_eq!(passes.flipped_at_end, [1, 2, 3].into());
let final_pass = passes.final_pass.unwrap();
assert_eq!(
(final_pass.program.as_str(), final_pass.draw_buffers),
("final", None)
);
assert_eq!(final_pass.reads_alt, [1, 2, 3].into());
}
fn scratch(name: &str) -> PathBuf {
std::env::temp_dir().join(format!("horizon-shaderpack-{name}-{}", std::process::id()))
}
@@ -276,3 +328,45 @@ fn real_packs_properties() {
assert!(unknown.len() <= 2, "{unknown:?}");
}
}
/// The overworld's full-screen passes for the packs in
/// `HORIZON_TEST_SHADERPACKS`. Skipped when the variable isn't set.
#[test]
fn real_packs_passes() {
let Some(dir) = std::env::var_os("HORIZON_TEST_SHADERPACKS") else {
return;
};
for entry in std::fs::read_dir(dir).unwrap().flatten() {
let Ok(pack) = JavaPack::open(&entry.path()) else {
continue;
};
let values = pack.values(&BTreeMap::new());
let properties = pack.properties(&values, &env()).unwrap();
let folder = if pack.programs.iter().any(|p| p.starts_with("world0/")) {
"world0"
} else {
""
};
let passes = pack.passes(folder, &values, &env(), &properties).unwrap();
println!("{}:", entry.file_name().to_string_lossy());
for (i, t) in passes.targets.iter().enumerate() {
if *t != TargetSettings::default() {
println!(" colortex{i}: {t:?}");
}
}
for p in passes
.begin
.iter()
.chain(&passes.prepare)
.chain(&passes.deferred)
.chain(&passes.composite)
.chain(&passes.final_pass)
{
println!(
" {} writes {:?} reads alt {:?} mipmaps {:?} scale {}",
p.program, p.draw_buffers, p.reads_alt, p.mipmapped, p.scale
);
}
assert!(passes.final_pass.is_some() || !passes.composite.is_empty());
}
}
+1
View File
@@ -19,6 +19,7 @@ Both are off by default. With no pack selected the renderer draws exactly what i
| Java shader packs: preprocessor (`crates/horizon-shaderpack`: includes, options, Iris's macros) | done: every program of the three test packs preprocesses |
| Java shader packs: GLSL → WGSL (`horizon_shaderpack::translate`: syntax-tree legaliser, naga) | done: the 464 programs the three test packs enable by default translate (below) |
| Java shader packs: `shaders.properties` (`horizon_shaderpack::properties`: screens, sliders, profiles, `program.*.enabled`, image formats, blend modes) | done, no screen yet: read like Iris for the three test packs |
| Java shader packs: full-screen pass plan (`horizon_shaderpack::pipeline`: `DRAWBUFFERS`/`RENDERTARGETS`, `colortexN` formats and clearing, buffer flips) | done, not drawn yet: planned for the three test packs |
| Java shader packs: Iris pipeline emulation | planned |
## How the renderer draws a frame today