alpha.5 fixes

Author: tychedelia

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "processing"
-version = "0.0.9-alpha.5"
+version = "0.0.9-alpha.6"
 edition = "2024"
 autoexamples = false
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "processing_pyo3"
-version = "0.0.9-alpha.5"
+version = "0.0.9-alpha.6"
 edition = "2024"
 
 [lints]

crates/processing_pyo3/Cargo.toml

@@ -21,6 +21,7 @@ use bevy::{
 };
 
 use bevy_naga_reflect::dynamic_shader::DynamicShader;
+use bevy_naga_reflect::reflect::ParameterCategory;
 
 use crate::geometry::{Attribute, Geometry};
 use crate::material::custom::Shader;
@@ -385,6 +386,15 @@ pub fn dispatch(
         if !ready {
             return Err(ProcessingError::ResourceNotReady(name.to_string()));
         }
+        // wgpu treats an incomplete bind group as fatal, so fail here instead
+        if matches!(param.category(), ParameterCategory::Storage { .. })
+            && shader.buffer_handle(name).is_none()
+            && !mesh_bindings.iter().any(|(n, _)| n == name)
+        {
+            return Err(ProcessingError::InvalidArgument(format!(
+                "nothing is bound to the shader's storage array `{name}`"
+            )));
+        }
     }
 
     let mut bind_groups = Vec::new();

crates/processing_render/src/compute.rs

@@ -1,19 +1,81 @@
+use std::collections::HashSet;
 use std::sync::Mutex;
 
 use bevy::prelude::*;
 
 use processing_core::app_mut;
 use processing_core::error;
 
+use crate::compute::Compute;
 use crate::geometry;
 use crate::particles::grid::grid_build;
 use crate::particles::kernels::KernelRequires;
 use crate::particles::{Particles, particles_ensure_attribute};
 use crate::shader_value::ShaderValue;
 use crate::{buffer_write_element, compute_create, compute_dispatch, compute_set, shader_load};
+use bevy_naga_reflect::reflect::ParameterCategory;
 
 const WORKGROUP_SIZE: u32 = 64;
 
+/// Creates every column `compute_entity` reads or writes that the system doesn't
+/// have yet: the kernel's declared requirements, plus any storage array the shader
+/// names after a known attribute. A storage array left unbound would make the
+/// bind group incomplete, which wgpu treats as fatal, so an unknown name is an error.
+fn ensure_columns(particles_entity: Entity, compute_entity: Entity) -> error::Result<()> {
+    let (required, missing) = app_mut(|app| {
+        let world = app.world();
+        let required = world
+            .get::<KernelRequires>(compute_entity)
+            .map(|r| r.0.clone())
+            .unwrap_or_default();
+        let compute = world
+            .get::<Compute>(compute_entity)
+            .ok_or(error::ProcessingError::ComputeNotFound)?;
+        let particles = world
+            .get::<Particles>(particles_entity)
+            .ok_or(error::ProcessingError::ParticlesNotFound)?;
+        let have: HashSet<&str> = particles
+            .buffers
+            .keys()
+            .filter_map(|&e| world.get::<geometry::Attribute>(e).map(|a| a.name))
+            .chain(
+                particles
+                    .neighbor_lists
+                    .map(|_| ["neighbors", "neighbor_count"])
+                    .into_iter()
+                    .flatten(),
+            )
+            .collect();
+        let missing: Vec<String> = compute
+            .shader
+            .reflection()
+            .parameters()
+            .filter(|p| matches!(p.category(), ParameterCategory::Storage { .. }))
+            .filter_map(|p| p.name().map(str::to_string))
+            .filter(|name| {
+                !have.contains(name.as_str())
+                    && compute.shader.buffer_handle(name).is_none()
+                    && !compute.mesh_bindings.contains_key(name)
+            })
+            .collect();
+        Ok((required, missing))
+    })?;
+
+    for attr_entity in required {
+        particles_ensure_attribute(particles_entity, attr_entity)?;
+    }
+    for name in missing {
+        let attr = crate::geometry_attribute_find(name.as_str())?.ok_or_else(|| {
+            error::ProcessingError::InvalidArgument(format!(
+                "the shader uses a column named `{name}` that these particles don't have. \
+                 Create the column before applying it"
+            ))
+        })?;
+        particles_ensure_attribute(particles_entity, attr)?;
+    }
+    Ok(())
+}
+
 pub fn particles_emit_gpu(
     particles_entity: Entity,
     count: u32,
@@ -23,16 +85,7 @@ pub fn particles_emit_gpu(
         return Ok(());
     }
 
-    let required: Vec<Entity> = app_mut(|app| {
-        Ok(app
-            .world()
-            .get::<KernelRequires>(compute_entity)
-            .map(|r| r.0.clone())
-            .unwrap_or_default())
-    })?;
-    for attr_entity in required {
-        particles_ensure_attribute(particles_entity, attr_entity)?;
-    }
+    ensure_columns(particles_entity, compute_entity)?;
 
     let (capacity, head, buffers) = app_mut(|app| {
         let world = app.world();
@@ -219,16 +272,7 @@ pub fn particles_gather(
 }
 
 pub fn particles_apply(particles_entity: Entity, compute_entity: Entity) -> error::Result<()> {
-    let required: Vec<Entity> = app_mut(|app| {
-        Ok(app
-            .world()
-            .get::<KernelRequires>(compute_entity)
-            .map(|r| r.0.clone())
-            .unwrap_or_default())
-    })?;
-    for attr_entity in required {
-        particles_ensure_attribute(particles_entity, attr_entity)?;
-    }
+    ensure_columns(particles_entity, compute_entity)?;
 
     let (capacity, buffers) = app_mut(|app| {
         let world = app.world();

crates/processing_render/src/particles/emit.rs

@@ -8,21 +8,26 @@ use bevy::prelude::*;
 use processing_core::app_mut;
 use processing_core::error::{self, ProcessingError};
 
-use crate::geometry::{BuiltinAttributes, Geometry};
+use crate::geometry::Geometry;
 use crate::shader_value::ShaderValue;
 use crate::{compute_create, compute_set, shader_load};
 
 #[derive(Component, Default, Clone)]
 pub struct KernelRequires(pub Vec<Entity>);
 
 pub(crate) fn set_requires(compute: Entity, names: &[&str]) -> error::Result<()> {
+    let attrs = names
+        .iter()
+        .map(|name| {
+            crate::geometry_attribute_find(*name)?.ok_or_else(|| {
+                ProcessingError::InvalidArgument(format!("no attribute named `{name}`"))
+            })
+        })
+        .collect::<error::Result<Vec<Entity>>>()?;
     app_mut(|app| {
-        let world = app.world_mut();
-        let attrs: Vec<Entity> = {
-            let builtins = world.resource::<BuiltinAttributes>();
-            names.iter().filter_map(|n| builtins.by_name(n)).collect()
-        };
-        world.entity_mut(compute).insert(KernelRequires(attrs));
+        app.world_mut()
+            .entity_mut(compute)
+            .insert(KernelRequires(attrs));
         Ok(())
     })
 }
@@ -266,7 +271,8 @@ pub fn particles_kernel_orient() -> error::Result<Entity> {
 pub fn particles_kernel_field() -> error::Result<Entity> {
     let shader = shader_load("embedded://processing_render/particles/kernels/field.wgsl")?;
     let entity = compute_create(shader)?;
-    set_requires(entity, &["position"])?;
+    crate::geometry_attribute_create("weight", crate::geometry::AttributeFormat::Float)?;
+    set_requires(entity, &["position", "weight"])?;
     compute_set(entity, "center", ShaderValue::Float3([0.0; 3]))?;
     compute_set(entity, "radius", ShaderValue::Float(1.0))?;
     compute_set(