use crate::content::shader::ShaderError;
use naga::{Block, Expression, Function, Handle, Module, Statement};
use std::collections::HashMap;
pub(super) fn check(module: &Module, game: impl Fn(&str) -> bool) -> Result<(), ShaderError> {
let mut derives = HashMap::new();
for (_, function) in module.functions.iter() {
let name = function.name.clone().unwrap_or_default();
if game(&name) && !top_level(module, function, &mut derives) {
return Err(ShaderError::NonUniformDerivative { function: name });
}
}
Ok(())
}
fn top_level(
module: &Module,
function: &Function,
derives: &mut HashMap<Handle<Function>, bool>,
) -> bool {
let mut returned = false;
let mut statements = function.body.iter().collect::<Vec<_>>();
while let Some(index) = statements
.iter()
.position(|statement| matches!(statement, Statement::Block(_)))
{
let Statement::Block(inner) = statements[index] else {
unreachable!()
};
statements.splice(index..=index, inner.iter());
}
for statement in statements {
match statement {
Statement::If { accept, reject, .. } => {
if deriving(module, function, accept, derives)
|| deriving(module, function, reject, derives)
{
return false;
}
returned |= returns(accept) || returns(reject);
}
Statement::Switch { cases, .. } => {
if cases
.iter()
.any(|case| deriving(module, function, &case.body, derives))
{
return false;
}
returned |= cases.iter().any(|case| returns(&case.body));
}
Statement::Loop {
body, continuing, ..
} => {
if deriving(module, function, body, derives)
|| deriving(module, function, continuing, derives)
{
return false;
}
returned |= returns(body) || returns(continuing);
}
statement => {
if returned && derives_at(module, function, statement, derives) {
return false;
}
}
}
}
true
}
fn deriving(
module: &Module,
function: &Function,
block: &Block,
derives: &mut HashMap<Handle<Function>, bool>,
) -> bool {
block.iter().any(|statement| match statement {
Statement::Block(inner) => deriving(module, function, inner, derives),
Statement::If { accept, reject, .. } => {
deriving(module, function, accept, derives)
|| deriving(module, function, reject, derives)
}
Statement::Switch { cases, .. } => cases
.iter()
.any(|case| deriving(module, function, &case.body, derives)),
Statement::Loop {
body, continuing, ..
} => {
deriving(module, function, body, derives)
|| deriving(module, function, continuing, derives)
}
statement => derives_at(module, function, statement, derives),
})
}
fn derives_at(
module: &Module,
function: &Function,
statement: &Statement,
derives: &mut HashMap<Handle<Function>, bool>,
) -> bool {
match statement {
Statement::Emit(range) => range.clone().any(|expression| {
matches!(
function.expressions[expression],
Expression::Derivative { .. }
)
}),
Statement::Call {
function: callee, ..
} => derives_in(module, *callee, derives),
_ => false,
}
}
fn derives_in(
module: &Module,
handle: Handle<Function>,
derives: &mut HashMap<Handle<Function>, bool>,
) -> bool {
if let Some(&known) = derives.get(&handle) {
return known;
}
let function = &module.functions[handle];
let found = deriving(module, function, &function.body, derives);
derives.insert(handle, found);
found
}
fn returns(block: &Block) -> bool {
block.iter().any(|statement| match statement {
Statement::Return { .. } => true,
Statement::Block(inner) => returns(inner),
Statement::If { accept, reject, .. } => returns(accept) || returns(reject),
Statement::Switch { cases, .. } => cases.iter().any(|case| returns(&case.body)),
Statement::Loop {
body, continuing, ..
} => returns(body) || returns(continuing),
_ => false,
})
}