Fixup.

Author: tychedelia

crates/processing_render/shaders/processing/filter.wesl

@@ -5,12 +5,11 @@ struct ProcessingFilter {
     // Pass index (0-based) and total count.
     pass_index: u32,
     pass_count: u32,
-    _pad: vec2<u32>,
 }
 
 @group(0) @binding(0) var screen_texture: texture_2d<f32>;
 @group(0) @binding(1) var texture_sampler: sampler;
-@group(0) @binding(2) var<uniform> filter: ProcessingFilter;
+@group(0) @binding(2) var<uniform> params: ProcessingFilter;
 
 struct FullscreenVertexOutput {
     @builtin(position) position: vec4<f32>,
@@ -21,7 +20,7 @@ fn sample(uv: vec2<f32>) -> vec4<f32> {
     return textureSample(screen_texture, texture_sampler, uv);
 }
 
-fn resolution() -> vec2<f32> { return filter.resolution; }
-fn texel_size() -> vec2<f32> { return filter.texel_size; }
-fn pass_index() -> u32 { return filter.pass_index; }
-fn pass_count() -> u32 { return filter.pass_count; }
+fn resolution() -> vec2<f32> { return params.resolution; }
+fn texel_size() -> vec2<f32> { return params.texel_size; }
+fn pass_index() -> u32 { return params.pass_index; }
+fn pass_count() -> u32 { return params.pass_count; }

crates/processing_render/src/material/custom.rs

@@ -120,12 +120,12 @@ impl wesl::Resolver for ProcessingResolver<'_> {
 
         match &path.origin {
             PathOrigin::Package(pkg) => {
-                // self-referential package imports: within a package, imports to
-                // the same package stack the name (e.g. "lygia/lygia/lygia/...").
-                // collapse to the root package name before resolving.
-                let root = pkg.split('/').next().unwrap();
+                // wesl encodes a cross-package import as a synthetic "parent/child"
+                // origin (e.g. importing processing from the entry module yields
+                // "entry/processing"). The real package is the leaf.
+                let leaf = pkg.rsplit('/').next().unwrap();
                 let mut fixed = path.clone();
-                fixed.origin = PathOrigin::Package(root.to_string());
+                fixed.origin = PathOrigin::Package(leaf.to_string());
                 self.pkg_resolver.resolve_source(&fixed)
             }
             _ => Err(wesl::ResolveError::ModuleNotFound(

crates/processing_render/src/render/filter.rs

@@ -22,13 +22,11 @@ use bevy::{
     },
     shader::Shader as ShaderAsset,
 };
-use bevy_naga_reflect::dynamic_shader::DynamicShader;
+use bevy_naga_reflect::{dynamic_shader::DynamicShader, reflect::ParameterCategory};
 
 use crate::material::custom::{Shader, apply_reflect_field, find_param_containing_field};
 use processing_core::error::{ProcessingError, Result};
 
-const INPUT_TEXTURE: &str = "screen_texture";
-const INPUT_SAMPLER: &str = "texture_sampler";
 const F_RESOLUTION: &str = "resolution";
 const F_TEXEL_SIZE: &str = "texel_size";
 const F_PASS_INDEX: &str = "pass_index";
@@ -343,14 +341,35 @@ fn run_pass(
     fill_system(&mut shader, F_PASS_COUNT, &passes);
     let has_pass_index = find_param_containing_field(&shader, F_PASS_INDEX).is_some();
 
+    // wesl mangles the imported `processing::filter` bindings, so the screen
+    // texture and sampler are bound by their reflected (mangled) names, found by
+    // category in group 0.
+    let (input_texture, input_sampler) = {
+        let reflection = shader.reflection();
+        let mut texture = None;
+        let mut sampler = None;
+        for param in reflection.parameters().filter(|p| p.group() == 0) {
+            match param.category() {
+                ParameterCategory::Texture => texture = param.name().map(String::from),
+                ParameterCategory::Sampler => sampler = param.name().map(String::from),
+                _ => {}
+            }
+        }
+        (texture, sampler)
+    };
+
     for pass in 0..passes {
         if has_pass_index {
             let _ = apply_reflect_field(&mut shader, F_PASS_INDEX, &pass);
         }
 
         let post_process = view_target.post_process_write();
-        shader.insert_texture_view(INPUT_TEXTURE, post_process.source.clone());
-        shader.insert_sampler(INPUT_SAMPLER, filter_sampler.0.clone());
+        if let Some(name) = &input_texture {
+            shader.insert_texture_view(name, post_process.source.clone());
+        }
+        if let Some(name) = &input_sampler {
+            shader.insert_sampler(name, filter_sampler.0.clone());
+        }
 
         let reflection = shader.reflection();
         let mut bind_groups = Vec::new();

examples/filter.rs

@@ -35,12 +35,17 @@ fn sketch() -> error::Result<()> {
     filter_set(threshold, "cutoff", ShaderValue::Float(0.5))?;
     let posterize = filter_posterize()?;
     filter_set(posterize, "levels", ShaderValue::UInt(4))?;
+    let blur = filter_blur()?;
+    filter_set(blur, "radius", ShaderValue::Float(4.0))?;
     let filters = [
         filter_invert()?,
         filter_gray()?,
         threshold,
         posterize,
         filter_opaque()?,
+        filter_erode()?,
+        filter_dilate()?,
+        blur,
     ];
 
     let start = Instant::now();