Skip to content

Minecraft: Java Edition 26.3 rewritten from scratch in Rust, checked against vanilla with 281 differential harnesses. Get it with the Horizon launcher.

Shader translator: preserve storage-image formats through qualified helper parameters

gigamans442bd02c92df224
diff --git a/crates/horizon-shaders/src/translate/image_parameters.rs b/crates/horizon-shaders/src/translate/image_parameters.rs
new file mode 100644
index 000000000..f20871ba4
--- /dev/null
+++ b/crates/horizon-shaders/src/translate/image_parameters.rs
@@ -0,0 +1,331 @@
+//! Specialize opaque image parameters to their bound resources. GLSL image parameters do not
+//! carry a storage format, while Naga's image types do. This preserves the actual global image
+//! type/access and writes no pack files. Unsupported dynamic handles remain compiler errors.
+use crate::macros::lex;
+use std::collections::{BTreeMap, BTreeSet};
+
+#[derive(Clone)]
+struct Function {
+ name: String,
+ result: String,
+ params: Vec<String>,
+ images: Vec<(usize, String)>,
+ body: String,
+}
+struct Site {
+ start: usize,
+ end: usize,
+ function: usize,
+ prototype: bool,
+}
+struct Instance {
+ name: String,
+ signature: String,
+ body: String,
+}
+struct Rewriter {
+ functions: Vec<Function>,
+ resources: BTreeSet<String>,
+ instances: BTreeMap<(usize, Vec<String>), Instance>,
+}
+fn word(s: &str) -> bool {
+ !s.is_empty() && s.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_')
+}
+fn image(s: &str) -> bool {
+ s.strip_prefix("uimage")
+ .or_else(|| s.strip_prefix("iimage"))
+ .or_else(|| s.strip_prefix("image"))
+ .is_some_and(|s| {
+ matches!(
+ s,
+ "1D" | "2D"
+ | "3D"
+ | "Cube"
+ | "Buffer"
+ | "1DArray"
+ | "2DArray"
+ | "CubeArray"
+ | "2DMS"
+ | "2DMSArray"
+ )
+ })
+}
+fn next(tokens: &[&str], i: usize) -> Option<usize> {
+ (i + 1..tokens.len()).find(|&j| !tokens[j].trim().is_empty())
+}
+fn close(tokens: &[&str], open: usize, left: &str, right: &str) -> Option<usize> {
+ let mut depth = 0;
+ for (i, t) in tokens.iter().enumerate().skip(open) {
+ if *t == left {
+ depth += 1;
+ } else if *t == right {
+ depth -= 1;
+ if depth == 0 {
+ return Some(i);
+ }
+ }
+ }
+ None
+}
+fn args(tokens: &[&str], open: usize, end: usize) -> Vec<String> {
+ let (mut depth, mut first) = (0, open + 1);
+ let mut result = Vec::new();
+ for i in open + 1..end {
+ match tokens[i] {
+ "(" | "[" => depth += 1,
+ ")" | "]" => depth -= 1,
+ "," if depth == 0 => {
+ result.push(tokens[first..i].concat());
+ first = i + 1;
+ }
+ _ => {}
+ }
+ }
+ let last = tokens[first..end].concat();
+ if !last.trim().is_empty() {
+ result.push(last);
+ }
+ result
+}
+impl Rewriter {
+ fn calls(&mut self, text: &str) -> Result<String, String> {
+ let tokens = lex(text);
+ let mut out = String::new();
+ let mut i = 0;
+ while i < tokens.len() {
+ let Some(open) = next(&tokens, i).filter(|&o| tokens[o] == "(") else {
+ out.push_str(tokens[i]);
+ i += 1;
+ continue;
+ };
+ let Some(end) = close(&tokens, open, "(", ")") else {
+ out.push_str(tokens[i]);
+ i += 1;
+ continue;
+ };
+ let params = args(&tokens, open, end);
+ let candidates: Vec<_> = self
+ .functions
+ .iter()
+ .enumerate()
+ .filter(|(_, f)| f.name == tokens[i] && f.params.len() == params.len())
+ .map(|(i, _)| i)
+ .collect();
+ if candidates.is_empty() {
+ out.push_str(tokens[i]);
+ i += 1;
+ continue;
+ }
+ if candidates.len() != 1 {
+ return Err(format!(
+ "image-parameter overload of {} is ambiguous",
+ tokens[i]
+ ));
+ }
+ let id = candidates[0];
+ let function = self.functions[id].clone();
+ let mut bindings = Vec::new();
+ for (k, _) in &function.images {
+ let value = lex(&params[*k])
+ .into_iter()
+ .filter(|t| !t.trim().is_empty())
+ .collect::<String>();
+ if !word(&value) || !self.resources.contains(&value) {
+ return Err(format!(
+ "image parameter of {} must resolve to a bound image",
+ function.name
+ ));
+ }
+ bindings.push(value);
+ }
+ let key = (id, bindings.clone());
+ if !self.instances.contains_key(&key) {
+ if self.instances.len() >= 256 {
+ return Err("image parameter specialization exceeds 256 variants".into());
+ }
+ let name = format!("hz_image_call_{}", self.instances.len());
+ let params = function
+ .params
+ .iter()
+ .enumerate()
+ .filter(|(k, _)| !function.images.iter().any(|(i, _)| i == k))
+ .map(|(_, p)| p.clone())
+ .collect::<Vec<_>>()
+ .join(",");
+ let signature = format!("{} {name}({params})", function.result);
+ self.instances.insert(
+ key.clone(),
+ Instance {
+ name,
+ signature,
+ body: String::new(),
+ },
+ );
+ let substitutions: BTreeMap<_, _> = function
+ .images
+ .iter()
+ .zip(&bindings)
+ .map(|((_, p), b)| (p.as_str(), b.as_str()))
+ .collect();
+ let body = lex(&function.body)
+ .iter()
+ .map(|t| substitutions.get(t).copied().unwrap_or(t))
+ .collect::<String>();
+ let body = self.calls(&body)?;
+ self.instances.get_mut(&key).unwrap().body = body;
+ }
+ let name = self.instances[&key].name.clone();
+ let mut kept = Vec::new();
+ for (k, param) in params.iter().enumerate() {
+ if !function.images.iter().any(|(i, _)| *i == k) {
+ kept.push(self.calls(param)?);
+ }
+ }
+ let call = format!("{name}({})", kept.join(","));
+ out.push_str(&call.replace('\n', " "));
+ out.extend(
+ tokens[i..=end]
+ .iter()
+ .flat_map(|t| t.chars().filter(|c| *c == '\n')),
+ );
+ i = end + 1;
+ }
+ Ok(out)
+ }
+}
+
+pub(super) fn rewrite(text: &str) -> Result<String, String> {
+ let tokens = lex(text);
+ let words: Vec<_> = tokens
+ .iter()
+ .enumerate()
+ .filter(|(_, t)| !t.trim().is_empty())
+ .map(|(i, _)| i)
+ .collect();
+ let resources = words
+ .windows(2)
+ .filter(|p| image(tokens[p[0]]) && word(tokens[p[1]]))
+ .map(|p| tokens[p[1]].to_owned())
+ .collect();
+ let mut functions: Vec<Function> = Vec::new();
+ let mut sites = Vec::new();
+ let mut depth = 0;
+ let mut i = 0;
+ while i < tokens.len() {
+ match tokens[i] {
+ "{" => depth += 1,
+ "}" => depth -= 1,
+ _ => {}
+ }
+ if depth != 0 || !word(tokens[i]) {
+ i += 1;
+ continue;
+ }
+ let Some(open) = next(&tokens, i).filter(|&o| tokens[o] == "(") else {
+ i += 1;
+ continue;
+ };
+ let Some(end) = close(&tokens, open, "(", ")") else {
+ i += 1;
+ continue;
+ };
+ let Some(after) = next(&tokens, end).filter(|&j| matches!(tokens[j], "{" | ";")) else {
+ i += 1;
+ continue;
+ };
+ let params = args(&tokens, open, end);
+ let mut images = Vec::new();
+ for (k, p) in params.iter().enumerate() {
+ let w: Vec<_> = lex(p)
+ .into_iter()
+ .filter(|t| !t.trim().is_empty())
+ .collect();
+ if let Some(at) = w.iter().position(|t| image(t))
+ && let Some(name) = w.get(at + 1)
+ {
+ images.push((k, (*name).to_owned()));
+ }
+ }
+ if images.is_empty() {
+ i += 1;
+ continue;
+ }
+ let Some(start) = (0..i).rev().find(|&j| !tokens[j].trim().is_empty()) else {
+ i += 1;
+ continue;
+ };
+ if !word(tokens[start]) {
+ i += 1;
+ continue;
+ }
+ let prototype = tokens[after] == ";";
+ let stop = if prototype {
+ after
+ } else {
+ close(&tokens, after, "{", "}").ok_or("unterminated image function")?
+ };
+ let function = Function {
+ name: tokens[i].into(),
+ result: tokens[start].into(),
+ params,
+ images,
+ body: if prototype {
+ String::new()
+ } else {
+ tokens[after + 1..stop].concat()
+ },
+ };
+ let id = functions
+ .iter()
+ .position(|f| f.name == function.name && f.params == function.params)
+ .unwrap_or(functions.len());
+ if id == functions.len() {
+ functions.push(function);
+ } else if !prototype {
+ functions[id] = function;
+ }
+ sites.push(Site {
+ start,
+ end: stop + 1,
+ function: id,
+ prototype,
+ });
+ i = stop + 1;
+ }
+ if sites.is_empty() {
+ return Ok(text.into());
+ }
+ let mut r = Rewriter {
+ functions,
+ resources,
+ instances: BTreeMap::new(),
+ };
+ let mut chunks = Vec::new();
+ let mut first = 0;
+ for site in &sites {
+ chunks.push(r.calls(&tokens[first..site.start].concat())?);
+ first = site.end;
+ }
+ chunks.push(r.calls(&tokens[first..].concat())?);
+ let mut out = String::new();
+ for (k, site) in sites.iter().enumerate() {
+ out.push_str(&chunks[k]);
+ for ((id, _), instance) in &r.instances {
+ if *id == site.function {
+ let code = if site.prototype {
+ format!("{};", instance.signature)
+ } else {
+ format!("{}{{{}}}", instance.signature, instance.body)
+ };
+ out.push_str(&code.replace('\n', " "));
+ }
+ }
+ out.extend(
+ tokens[site.start..site.end]
+ .iter()
+ .flat_map(|t| t.chars().filter(|c| *c == '\n')),
+ );
+ }
+ out.push_str(chunks.last().unwrap());
+ Ok(out)
+}
diff --git a/crates/horizon-shaders/src/translate/mod.rs b/crates/horizon-shaders/src/translate/mod.rs
index e45815a33..fed92b69a 100644
--- a/crates/horizon-shaders/src/translate/mod.rs
+++ b/crates/horizon-shaders/src/translate/mod.rs
@@ -29,6 +29,7 @@ use crate::Preprocessed;
mod atomic_vectors;
mod geometry;
+mod image_parameters;
mod ordering;
mod rewrite;
mod scan;
@@ -980,7 +981,14 @@ pub(super) fn split_sampler(ty: &str) -> (String, &'static str) {
/// Parses and validates one stage; errors at the pack's files and lines.
fn compile(stage: &Stage, text: &str, header_lines: usize) -> Result<naga::Module, Vec<Error>> {
- // `text` is the source the span is in: the rewrites below keep its lines.
+ let specialized = image_parameters::rewrite(text).map_err(|message| {
+ vec![Error {
+ file: stage.pp.files.first().cloned().unwrap_or_default(),
+ line: 1,
+ message,
+ }]
+ })?;
+ let text = specialized.as_str();
let at = |text: &str, span: naga::Span, message: String| {
let start = span.to_range().map_or(0, |r| r.start);
let line = text[..start.min(text.len())].matches('\n').count();
@@ -2363,3 +2371,19 @@ mod tests {
);
}
}
+
+#[cfg(test)]
+mod image_parameter_tests {
+ use crate::{Macros, Pack, preprocess, translate_compute};
+ #[test]
+ fn nested_image_helpers_specialize_multiple_storage_formats() {
+ let src = "#version 430\nlayout(local_size_x=1)in;layout(rgba16f) uniform image3D imageA;layout(r32f) uniform image3D imageB;void write_value(writeonly image3D img,ivec3 p){imageStore(img,p,vec4(0.5));}\nvoid nested(image3D img,ivec3 p){write_value(img,p);}\nvoid main(){nested(imageA,ivec3(0));nested(imageB,ivec3(0));}";
+ let pack = Pack::from_zip_bytes(
+ "formats.zip",
+ crate::pack::tests::zip(&[("shaders/setup.csh", src)]),
+ )
+ .unwrap();
+ let result = translate_compute(&preprocess(&pack, "setup.csh", &Macros::standard()));
+ assert!(result.is_ok(), "{:?}", result.err());
+ }
+}