use std::collections::{BTreeMap, BTreeSet};
use crate::{Error, Result};
pub const GRID_WGSL: &str = include_str!("shaders/grid.wgsl");
pub const MARCHING_CUBES_WGSL: &str = include_str!("shaders/marching_cubes.wgsl");
pub const MESH_RENDER_WGSL: &str = include_str!("shaders/mesh_render.wgsl");
pub const SCAN_WGSL: &str = include_str!("shaders/scan.wgsl");
pub const JUMP_FLOOD_WGSL: &str = include_str!("shaders/jump_flood.wgsl");
pub const FIELD_WGSL: &str = include_str!("shaders/field.wgsl");
pub const FEATURES: &[&str] = &[];
#[derive(Clone, Debug, Default)]
pub struct Composer {
modules: BTreeMap<String, &'static str>,
}
struct Region {
outer: bool,
taken: bool,
closed: bool,
}
impl Composer {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn with_builtins() -> Self {
let mut composer = Self::new();
composer.insert("grid", GRID_WGSL);
composer.insert("marching_cubes", MARCHING_CUBES_WGSL);
composer.insert("mesh_render", MESH_RENDER_WGSL);
composer.insert("scan", SCAN_WGSL);
composer.insert("jump_flood", JUMP_FLOOD_WGSL);
composer.insert("field", FIELD_WGSL);
composer
}
pub fn insert(&mut self, name: &str, source: &'static str) {
self.modules.insert(String::from(name), source);
}
#[must_use]
pub fn module_names(&self) -> Vec<&str> {
self.modules.keys().map(String::as_str).collect()
}
#[must_use]
pub fn variants<'a>(&'a self, features: &[&'a str]) -> Vec<(&'a str, Vec<&'a str>)> {
let mut out = Vec::new();
for name in self.module_names() {
for mask in 0..(1u32 << features.len()) {
let defines = features
.iter()
.enumerate()
.filter(|(bit, _)| mask & (1 << bit) != 0)
.map(|(_, f)| *f)
.collect();
out.push((name, defines));
}
}
out
}
pub fn compose(&self, name: &str, defines: &[&str]) -> Result<String> {
let defines: BTreeSet<&str> = defines.iter().copied().collect();
let mut out = String::new();
let mut included = BTreeSet::new();
let mut in_progress = Vec::new();
self.expand(name, &defines, &mut out, &mut included, &mut in_progress)?;
Ok(out)
}
fn expand(
&self,
name: &str,
defines: &BTreeSet<&str>,
out: &mut String,
included: &mut BTreeSet<String>,
in_progress: &mut Vec<String>,
) -> Result<()> {
let Some(source) = self.modules.get(name) else {
return Err(Error::ShaderModuleMissing {
name: String::from(name),
});
};
in_progress.push(String::from(name));
included.insert(String::from(name));
let mut regions: Vec<Region> = Vec::new();
let mut emitting = true;
for (number, line) in source.lines().enumerate() {
let trimmed = line.trim_start();
let here = || Error::ShaderDirective {
module: String::from(name),
line: number + 1,
};
let mut handled = false;
if let Some(rest) = trimmed.strip_prefix('#') {
let split = rest.find(char::is_whitespace).unwrap_or(rest.len());
let (keyword, argument) = rest.split_at(split);
let argument = argument.trim();
handled = true;
match keyword {
"ifdef" | "ifndef" => {
if argument.is_empty() || argument.split_whitespace().count() != 1 {
return Err(here());
}
let hit = defines.contains(argument) == (keyword == "ifdef");
regions.push(Region {
outer: emitting,
taken: emitting && hit,
closed: false,
});
emitting = emitting && hit;
}
"else" => {
if !argument.is_empty() {
return Err(here());
}
let Some(region) = regions.last_mut() else {
return Err(here());
};
if region.closed {
return Err(here());
}
region.closed = true;
emitting = region.outer && !region.taken;
region.taken |= emitting;
}
"endif" => {
if !argument.is_empty() {
return Err(here());
}
let Some(region) = regions.pop() else {
return Err(here());
};
emitting = region.outer;
}
"include" => {
let target = argument
.strip_prefix('<')
.and_then(|r| r.strip_suffix('>'))
.ok_or_else(here)?
.trim();
if target.is_empty() {
return Err(here());
}
if emitting {
if in_progress.iter().any(|n| n == target) {
return Err(Error::ShaderCircularInclude {
name: String::from(target),
});
}
if !included.contains(target) {
self.expand(target, defines, out, included, in_progress)?;
}
}
}
_ => handled = false,
}
}
if !handled && emitting {
out.push_str(line);
out.push('\n');
}
}
if !regions.is_empty() {
return Err(Error::ShaderDirective {
module: String::from(name),
line: source.lines().count() + 1,
});
}
in_progress.pop();
Ok(())
}
}
#[cfg(test)]
mod tests;