use super::super::bind::BindingTier;
use super::super::compose;
use super::super::programs::{
GAME_MODULE_HEADER, GeometryForm, ProgramShader, caster_program, geometry_program,
};
use super::{
CONTRACT_NAMES, SHADER_CONTRACT, SHADER_DEFAULT, SHADER_SCENE_DEPTH_NONE, derivatives, loops,
};
use crate::content::shader::{
ForbiddenItem, SHADER_PARAMS_MAX_BYTES, ShaderError, ShaderParamField, ShaderParamsLayout,
};
use std::collections::HashSet;
use std::sync::OnceLock;
#[derive(Clone, Debug)]
pub(crate) struct ValidatedShader {
pub layout: ShaderParamsLayout,
pub reads_volume_path: bool,
pub reads_time: bool,
}
const CONTRACT_FUNCTIONS: [&str; 4] = [
"scene_depth_available",
"scene_depth",
"scene_depth_behind",
VOLUME_PATH,
];
const PREDECLARED_TYPES: [&str; 34] = [
"i16",
"u16",
"vec2i",
"vec3i",
"vec4i",
"vec2u",
"vec3u",
"vec4u",
"vec2f",
"vec3f",
"vec4f",
"vec2h",
"vec3h",
"vec4h",
"mat2x2f",
"mat2x3f",
"mat2x4f",
"mat3x2f",
"mat3x3f",
"mat3x4f",
"mat4x2f",
"mat4x3f",
"mat4x4f",
"mat2x2h",
"mat2x3h",
"mat2x4h",
"mat3x2h",
"mat3x3h",
"mat3x4h",
"mat4x2h",
"mat4x3h",
"mat4x4h",
"RayDesc",
"RayIntersection",
];
const VOLUME_PATH: &str = "scene_volume_path";
pub(crate) fn validator() -> naga::valid::Validator {
naga::valid::Validator::new(
naga::valid::ValidationFlags::all(),
naga::valid::Capabilities::CUBE_ARRAY_TEXTURES,
)
}
pub(crate) fn validate(source: &str, tier: BindingTier) -> Result<ValidatedShader, ShaderError> {
let tokens = tokens(source);
if let Some(directive) = leading_directive(&tokens) {
return Err(ShaderError::Forbidden {
item: ForbiddenItem::Directive,
name: directive,
});
}
let reserved = reserved_names();
let declared = declared_names(&tokens);
let builtin = |name: &String| {
naga::keywords::wgsl::BUILTIN_IDENTIFIERS.contains(&name.as_str())
|| PREDECLARED_TYPES.contains(&name.as_str())
};
if let Some(name) = declared
.iter()
.find(|name| reserved.contains(*name) || builtin(name))
{
return Err(ShaderError::NameTaken { name: name.clone() });
}
if let Some(&name) = CONTRACT_NAMES
.iter()
.find(|&&name| !declared.iter().any(|declared| declared == name))
{
return Err(ShaderError::MissingFunction { name });
}
let module = parse_against_contract(source)?;
let info = validator()
.validate(&module)
.map_err(|error| validation(&error))?;
forbidden(&module)?;
let params = signatures(&module)?;
for (_, function) in module.functions.iter() {
let name = function.name.clone().unwrap_or_default();
if CONTRACT_FUNCTIONS.contains(&name.as_str()) {
continue;
}
if discards(&function.body) {
return Err(ShaderError::Discard { function: name });
}
}
loops::check(&module, |name| !CONTRACT_FUNCTIONS.contains(&name))?;
derivatives::check(&module, |name| !CONTRACT_FUNCTIONS.contains(&name))?;
if let Some(function) = reaches(&module, "material_vertex", &CONTRACT_FUNCTIONS) {
return Err(ShaderError::SceneDepthInVertex { function });
}
let reads_volume_path = reaches(&module, "material_surface", &[VOLUME_PATH]).is_some();
let reads_time = reads_time(&module, &info);
let layout = params_layout(&module, params)?;
for (label, program) in programs(tier, ProgramShader::Game(source)) {
let module =
naga::front::wgsl::parse_str(&program).map_err(|error| ShaderError::Validate {
message: format!("{label}: {}", error.message()),
})?;
validator()
.validate(&module)
.map_err(|error| validation(&error))?;
}
Ok(ValidatedShader {
layout,
reads_volume_path,
reads_time,
})
}
fn reads_time(module: &naga::Module, info: &naga::valid::ModuleInfo) -> bool {
let timed = |ty: naga::Handle<naga::Type>, index: u32| {
let ty = match module.types[ty].inner {
naga::TypeInner::Pointer { base, .. } => base,
_ => ty,
};
let naga::TypeInner::Struct { members, .. } = &module.types[ty].inner else {
return false;
};
matches!(
module.types[ty].name.as_deref(),
Some("VertexContext" | "SurfaceContext")
) && members
.get(index as usize)
.is_some_and(|member| matches!(member.name.as_deref(), Some("time" | "phase")))
};
module.functions.iter().any(|(handle, function)| {
let info = &info[handle];
function.expressions.iter().any(|(_, expression)| {
let naga::Expression::AccessIndex { base, index } = *expression else {
return false;
};
match &info[base].ty {
naga::proc::TypeResolution::Handle(ty) => timed(*ty, index),
naga::proc::TypeResolution::Value(naga::TypeInner::Pointer { base, .. }) => {
timed(*base, index)
}
naga::proc::TypeResolution::Value(_) => false,
}
})
})
}
pub(crate) fn programs(
tier: BindingTier,
shader: ProgramShader<'_>,
) -> Vec<(&'static str, String)> {
let mut programs = vec![
(
"geometry",
geometry_program(GeometryForm::Plain, tier, shader),
),
(
"geometry with the shadow mask",
geometry_program(GeometryForm::ShadowMask, tier, shader),
),
];
if GeometryForm::Blended.distinct(tier, shader) {
programs.push((
"blended geometry",
geometry_program(GeometryForm::Blended, tier, shader),
));
}
programs.push(("casters", caster_program(shader)));
programs
}
fn validation(error: &dyn std::error::Error) -> ShaderError {
let mut message = error.to_string();
let mut source = error.source();
while let Some(inner) = source {
message.push_str(": ");
message.push_str(&inner.to_string());
source = inner.source();
}
ShaderError::Validate { message }
}
fn parse_against_contract(source: &str) -> Result<naga::Module, ShaderError> {
let mut program = compose(&[&SHADER_CONTRACT, &SHADER_SCENE_DEPTH_NONE]);
program.push_str(GAME_MODULE_HEADER);
let before = program.matches('\n').count() as u32;
program.push_str(source);
program.push('\n');
naga::front::wgsl::parse_str(&program).map_err(|error| {
let (line, column) = error
.location(&program)
.filter(|location| location.line_number > before)
.map_or((0, 0), |location| {
(location.line_number - before, location.line_position)
});
ShaderError::Parse {
message: error.message().to_owned(),
line,
column,
}
})
}
fn forbidden(module: &naga::Module) -> Result<(), ShaderError> {
let named = |name: &Option<String>| name.clone().unwrap_or_default();
if let Some(entry) = module.entry_points.first() {
return Err(ShaderError::Forbidden {
item: ForbiddenItem::EntryPoint,
name: entry.name.clone(),
});
}
if let Some((_, variable)) = module.global_variables.iter().next() {
let item = if variable.binding.is_some() {
ForbiddenItem::Binding
} else {
ForbiddenItem::Variable
};
return Err(ShaderError::Forbidden {
item,
name: named(&variable.name),
});
}
if let Some((_, constant)) = module.overrides.iter().next() {
return Err(ShaderError::Forbidden {
item: ForbiddenItem::Override,
name: named(&constant.name),
});
}
Ok(())
}
fn named_type(module: &naga::Module, name: &str) -> Option<naga::Handle<naga::Type>> {
module
.types
.iter()
.find(|(_, ty)| ty.name.as_deref() == Some(name))
.map(|(handle, _)| handle)
}
const PARAMS_EXPECTED: &str = "struct ShaderParams { ... }";
const VERTEX_EXPECTED: &str = "fn material_vertex(v: MaterialVertex, ctx: VertexContext, params: ShaderParams) -> MaterialVertex";
const SURFACE_EXPECTED: &str = "fn material_surface(s: MaterialSurface, ctx: SurfaceContext, params: ShaderParams) -> MaterialSurface";
fn signatures(module: &naga::Module) -> Result<naga::Handle<naga::Type>, ShaderError> {
let params = named_type(module, "ShaderParams").ok_or(ShaderError::MissingFunction {
name: "ShaderParams",
})?;
if !matches!(module.types[params].inner, naga::TypeInner::Struct { .. }) {
return Err(ShaderError::Signature {
name: "ShaderParams",
expected: PARAMS_EXPECTED,
});
}
let contract = |name| named_type(module, name).expect("the contract declares its structs");
for (name, value, context, expected) in [
(
"material_vertex",
contract("MaterialVertex"),
contract("VertexContext"),
VERTEX_EXPECTED,
),
(
"material_surface",
contract("MaterialSurface"),
contract("SurfaceContext"),
SURFACE_EXPECTED,
),
] {
let (_, function) = module
.functions
.iter()
.find(|(_, function)| function.name.as_deref() == Some(name))
.ok_or(ShaderError::MissingFunction { name })?;
let arguments: Vec<_> = function
.arguments
.iter()
.map(|argument| argument.ty)
.collect();
let result = function.result.as_ref().map(|result| result.ty);
if arguments != [value, context, params] || result != Some(value) {
return Err(ShaderError::Signature { name, expected });
}
}
Ok(params)
}
fn discards(block: &naga::Block) -> bool {
block.iter().any(|statement| match statement {
naga::Statement::Kill => true,
naga::Statement::Block(inner) => discards(inner),
naga::Statement::If { accept, reject, .. } => discards(accept) || discards(reject),
naga::Statement::Switch { cases, .. } => cases.iter().any(|case| discards(&case.body)),
naga::Statement::Loop {
body, continuing, ..
} => discards(body) || discards(continuing),
_ => false,
})
}
fn params_layout(
module: &naga::Module,
params: naga::Handle<naga::Type>,
) -> Result<ShaderParamsLayout, ShaderError> {
let mut layouter = naga::proc::Layouter::default();
layouter
.update(module.to_ctx())
.map_err(|error| validation(&error))?;
let naga::TypeInner::Struct { members, span } = &module.types[params].inner else {
unreachable!("ShaderParams was found a struct");
};
if *span > SHADER_PARAMS_MAX_BYTES {
return Err(ShaderError::ParamsTooLarge {
size: *span,
max: SHADER_PARAMS_MAX_BYTES,
});
}
Ok(ShaderParamsLayout {
size: *span,
fields: members
.iter()
.map(|member| ShaderParamField {
name: member.name.clone().unwrap_or_default(),
offset: member.offset,
size: layouter[member.ty].size,
})
.collect(),
})
}
fn reaches(module: &naga::Module, root: &str, targets: &[&str]) -> Option<String> {
let named = |handle: naga::Handle<naga::Function>| {
module.functions[handle].name.clone().unwrap_or_default()
};
let mut pending: Vec<_> = module
.functions
.iter()
.filter(|&(handle, _)| named(handle) == root)
.map(|(handle, _)| handle)
.collect();
let mut seen = HashSet::new();
while let Some(handle) = pending.pop() {
if !seen.insert(handle) {
continue;
}
let mut callees = Vec::new();
calls(&module.functions[handle].body, &mut callees);
for callee in callees {
if targets.contains(&named(callee).as_str()) {
return Some(named(handle));
}
pending.push(callee);
}
}
None
}
fn calls(block: &naga::Block, callees: &mut Vec<naga::Handle<naga::Function>>) {
for statement in block.iter() {
match statement {
naga::Statement::Call { function, .. } => callees.push(*function),
naga::Statement::Block(inner) => calls(inner, callees),
naga::Statement::If { accept, reject, .. } => {
calls(accept, callees);
calls(reject, callees);
}
naga::Statement::Switch { cases, .. } => {
for case in cases {
calls(&case.body, callees);
}
}
naga::Statement::Loop {
body, continuing, ..
} => {
calls(body, callees);
calls(continuing, callees);
}
_ => {}
}
}
}
fn reserved_names() -> &'static HashSet<String> {
static NAMES: OnceLock<HashSet<String>> = OnceLock::new();
NAMES.get_or_init(|| {
let mut names = HashSet::new();
let tiers = [BindingTier::Basic, BindingTier::Extended];
let shader = ProgramShader::Game(SHADER_DEFAULT.source);
for (label, program) in tiers.into_iter().flat_map(|tier| programs(tier, shader)) {
let module = naga::front::wgsl::parse_str(&program)
.unwrap_or_else(|error| panic!("{label}: {}", error.message()));
let name = |name: &Option<String>| name.clone();
names.extend(module.types.iter().filter_map(|(_, ty)| name(&ty.name)));
names.extend(module.constants.iter().filter_map(|(_, c)| name(&c.name)));
names.extend(module.overrides.iter().filter_map(|(_, o)| name(&o.name)));
names.extend(
module
.global_variables
.iter()
.filter_map(|(_, variable)| name(&variable.name)),
);
names.extend(module.functions.iter().filter_map(|(_, f)| name(&f.name)));
names.extend(module.entry_points.iter().map(|entry| entry.name.clone()));
}
for name in CONTRACT_NAMES {
names.remove(name);
}
names
})
}
#[derive(Clone, Debug, PartialEq, Eq)]
enum Token {
Word(String),
Mark(char),
}
fn tokens(source: &str) -> Vec<Token> {
let mut tokens = Vec::new();
let mut chars = source.chars().peekable();
while let Some(c) = chars.next() {
match c {
'/' if chars.peek() == Some(&'/') => {
for next in chars.by_ref() {
if is_comment_end(next) {
break;
}
}
}
'/' if chars.peek() == Some(&'*') => {
chars.next();
let mut depth = 1;
let mut previous = ' ';
for next in chars.by_ref() {
match (previous, next) {
('/', '*') => {
depth += 1;
previous = ' ';
continue;
}
('*', '/') => {
depth -= 1;
if depth == 0 {
break;
}
previous = ' ';
continue;
}
_ => {}
}
previous = next;
}
}
c if c.is_alphanumeric() || c == '_' => {
let mut word = String::from(c);
while let Some(&next) = chars.peek() {
if !(next.is_alphanumeric() || next == '_') {
break;
}
word.push(next);
chars.next();
}
tokens.push(Token::Word(word));
}
c if is_blankspace(c) => {}
c => tokens.push(Token::Mark(c)),
}
}
tokens
}
const fn is_comment_end(c: char) -> bool {
matches!(
c,
'\u{000a}'..='\u{000d}' | '\u{0085}' | '\u{2028}' | '\u{2029}'
)
}
const fn is_blankspace(c: char) -> bool {
matches!(
c,
'\t'..='\r' | ' ' | '\u{0085}' | '\u{200e}' | '\u{200f}' | '\u{2028}' | '\u{2029}'
)
}
fn leading_directive(tokens: &[Token]) -> Option<String> {
let Some(Token::Word(word)) = tokens.first() else {
return None;
};
if !matches!(word.as_str(), "enable" | "requires" | "diagnostic") {
return None;
}
let mut directive = String::new();
for token in tokens
.iter()
.take_while(|token| **token != Token::Mark(';'))
{
if !directive.is_empty() {
directive.push(' ');
}
match token {
Token::Word(word) => directive.push_str(word),
Token::Mark(mark) => directive.push(*mark),
}
}
Some(directive)
}
fn declared_names(tokens: &[Token]) -> Vec<String> {
let mut names = Vec::new();
let mut depth = 0usize;
let mut at = 0;
while at < tokens.len() {
match &tokens[at] {
Token::Mark('{') => depth += 1,
Token::Mark('}') => depth = depth.saturating_sub(1),
Token::Word(word)
if depth == 0
&& matches!(
word.as_str(),
"fn" | "struct" | "const" | "override" | "alias" | "var"
) =>
{
let mut next = at + 1;
if word == "var" && tokens.get(next) == Some(&Token::Mark('<')) {
let mut angles = 0usize;
while let Some(token) = tokens.get(next) {
match token {
Token::Mark('<') => angles += 1,
Token::Mark('>') => {
angles -= 1;
if angles == 0 {
next += 1;
break;
}
}
_ => {}
}
next += 1;
}
}
if let Some(Token::Word(name)) = tokens.get(next) {
names.push(name.clone());
}
at = next;
}
_ => {}
}
at += 1;
}
names
}