.

Author: tychedelia

Cargo.lock

@@ -24,7 +24,7 @@ too_many_arguments = "allow"
 
 [workspace.dependencies]
 bevy = { git = "https://github.com/processing/bevy", branch = "main", features = ["file_watcher", "shader_format_wesl", "free_camera", "pan_camera"] }
-bevy_naga_reflect = { git = "https://github.com/tychedelia/bevy_naga_reflect" }
+bevy_naga_reflect = { path = "../../tychedelia/bevy_naga_reflect" }
 bevy_cuda = { git = "https://github.com/tychedelia/bevy_cuda" }
 naga = { version = "29", features = ["wgsl-in"] }
 wesl = { version = "0.3", default-features = false }
@@ -165,6 +165,38 @@ path = "examples/camera_controllers.rs"
 name = "compute_readback"
 path = "examples/compute_readback.rs"
 
+[[example]]
+name = "field_basic"
+path = "examples/field_basic.rs"
+
+[[example]]
+name = "field_animated"
+path = "examples/field_animated.rs"
+
+[[example]]
+name = "field_oriented"
+path = "examples/field_oriented.rs"
+
+[[example]]
+name = "field_colored"
+path = "examples/field_colored.rs"
+
+[[example]]
+name = "field_colored_pbr"
+path = "examples/field_colored_pbr.rs"
+
+[[example]]
+name = "field_emit"
+path = "examples/field_emit.rs"
+
+[[example]]
+name = "field_lifecycle"
+path = "examples/field_lifecycle.rs"
+
+[[example]]
+name = "field_from_mesh"
+path = "examples/field_from_mesh.rs"
+
 [profile.wasm-release]
 inherits = "release"
 opt-level = "z"

Cargo.toml

@@ -56,4 +56,6 @@ pub enum ProcessingError {
     PipelineCompileError(String),
     #[error("Pipeline not ready after {0} frames")]
     PipelineNotReady(u32),
+    #[error("Field not found")]
+    FieldNotFound,
 }

crates/processing_core/src/error.rs

@@ -277,44 +277,57 @@ pub fn set_compute_property(
         .get_mut(entity)
         .map_err(|_| ProcessingError::ComputeNotFound)?;
 
-    let category = compute
-        .shader
-        .reflection()
-        .parameter(&name)
-        .map(|p| p.category())
-        .ok_or_else(|| ProcessingError::UnknownShaderProperty(name.clone()))?;
-
-    match (&value, category) {
-        (ShaderValue::Buffer(buf_entity), ParameterCategory::Storage { read_only }) => {
+    // Resource values (buffers / textures) bind directly to top-level parameters
+    // and need a category check. Scalar / vector / matrix values may target
+    // either a top-level uniform or a nested struct field (e.g. `params.dt`),
+    // so we let `apply_reflect_field` handle the path resolution itself.
+    match value {
+        ShaderValue::Buffer(buf_entity) => {
+            let category = compute
+                .shader
+                .reflection()
+                .parameter(&name)
+                .map(|p| p.category())
+                .ok_or_else(|| ProcessingError::UnknownShaderProperty(name.clone()))?;
+            let ParameterCategory::Storage { read_only } = category else {
+                return Err(ProcessingError::InvalidArgument(format!(
+                    "property `{name}` expects {category:?}, got Buffer",
+                )));
+            };
             let mut buffer = p_buffers
-                .get_mut(*buf_entity)
+                .get_mut(buf_entity)
                 .map_err(|_| ProcessingError::BufferNotFound)?;
             compute.shader.insert(&name, buffer.handle.clone());
             if !read_only {
                 buffer.bound_rw = true;
             }
             Ok(())
         }
-        (ShaderValue::Texture(img_entity), ParameterCategory::Texture)
-        | (ShaderValue::Texture(img_entity), ParameterCategory::StorageTexture) => {
+        ShaderValue::Texture(img_entity) => {
+            let category = compute
+                .shader
+                .reflection()
+                .parameter(&name)
+                .map(|p| p.category())
+                .ok_or_else(|| ProcessingError::UnknownShaderProperty(name.clone()))?;
+            if !matches!(
+                category,
+                ParameterCategory::Texture | ParameterCategory::StorageTexture
+            ) {
+                return Err(ProcessingError::InvalidArgument(format!(
+                    "property `{name}` expects {category:?}, got Texture",
+                )));
+            }
             let image = p_images
-                .get(*img_entity)
+                .get(img_entity)
                 .map_err(|_| ProcessingError::ImageNotFound)?;
             compute.shader.insert(&name, image.handle.clone());
             Ok(())
         }
-        (ShaderValue::Buffer(_), cat) | (ShaderValue::Texture(_), cat) => {
-            Err(ProcessingError::InvalidArgument(format!(
-                "property `{name}` expects {cat:?}, got {value:?}",
-            )))
-        }
-        (_, ParameterCategory::Uniform) => {
-            let reflect_value: Box<dyn PartialReflect> = shader_value_to_reflect(&value)?;
+        v => {
+            let reflect_value: Box<dyn PartialReflect> = shader_value_to_reflect(&v)?;
             apply_reflect_field(&mut compute.shader, &name, &*reflect_value)
         }
-        (_, cat) => Err(ProcessingError::InvalidArgument(format!(
-            "property `{name}` expects {cat:?}, got non-resource value"
-        ))),
     }
 }
 

crates/processing_render/src/compute.rs

@@ -0,0 +1,42 @@
+// Per-particle color material for [`Field`] rasterization.
+//
+// Reads `mesh.tag` (written by the pack pass as the per-particle slot index)
+// and looks up a per-particle color from a storage buffer. Unlit — outputs the
+// looked-up color directly.
+
+#import bevy_pbr::{
+    mesh_functions,
+    view_transformations::position_world_to_clip
+}
+
+@group(#{MATERIAL_BIND_GROUP}) @binding(0)
+var<storage, read> particle_colors: array<vec4<f32>>;
+
+struct Vertex {
+    @builtin(instance_index) instance_index: u32,
+    @location(0) position: vec3<f32>,
+};
+
+struct VertexOutput {
+    @builtin(position) clip_position: vec4<f32>,
+    @location(0) color: vec4<f32>,
+};
+
+@vertex
+fn vertex(vertex: Vertex) -> VertexOutput {
+    var out: VertexOutput;
+    let tag = mesh_functions::get_tag(vertex.instance_index);
+    let world_from_local = mesh_functions::get_world_from_local(vertex.instance_index);
+    let world_position = mesh_functions::mesh_position_local_to_world(
+        world_from_local,
+        vec4<f32>(vertex.position, 1.0),
+    );
+    out.clip_position = position_world_to_clip(world_position.xyz);
+    out.color = particle_colors[tag];
+    return out;
+}
+
+@fragment
+fn fragment(in: VertexOutput) -> @location(0) vec4<f32> {
+    return in.color;
+}

crates/processing_render/src/field/field_color.wgsl

@@ -0,0 +1,51 @@
+// PBR per-particle color material for [`Field`] rasterization.
+//
+// Composes with `StandardMaterial` via `ExtendedMaterial`. The base material
+// supplies all PBR properties (roughness, metallic, etc.); we modulate the
+// resulting `base_color` by the per-particle color looked up from a storage
+// buffer indexed by `mesh.tag` (the per-instance slot index written by the
+// pack pass).
+
+#import bevy_pbr::{
+    pbr_fragment::pbr_input_from_standard_material,
+    pbr_functions::alpha_discard,
+    mesh_functions,
+}
+
+#ifdef PREPASS_PIPELINE
+#import bevy_pbr::{
+    prepass_io::{VertexOutput, FragmentOutput},
+    pbr_deferred_functions::deferred_output,
+}
+#else
+#import bevy_pbr::{
+    forward_io::{VertexOutput, FragmentOutput},
+    pbr_functions::{apply_pbr_lighting, main_pass_post_lighting_processing},
+}
+#endif
+
+@group(#{MATERIAL_BIND_GROUP}) @binding(100)
+var<storage, read> particle_colors: array<vec4<f32>>;
+
+@fragment
+fn fragment(
+    in: VertexOutput,
+    @builtin(front_facing) is_front: bool,
+) -> FragmentOutput {
+    var pbr_input = pbr_input_from_standard_material(in, is_front);
+
+    let tag = mesh_functions::get_tag(in.instance_index);
+    pbr_input.material.base_color = pbr_input.material.base_color * particle_colors[tag];
+
+    pbr_input.material.base_color = alpha_discard(pbr_input.material, pbr_input.material.base_color);
+
+#ifdef PREPASS_PIPELINE
+    let out = deferred_output(in, pbr_input);
+#else
+    var out: FragmentOutput;
+    out.color = apply_pbr_lighting(pbr_input);
+    out.color = main_pass_post_lighting_processing(pbr_input, out.color);
+#endif
+
+    return out;
+}

crates/processing_render/src/field/field_pbr.wgsl

@@ -0,0 +1,102 @@
+//! `FieldColorMaterial` — unlit material that reads a per-particle color from a
+//! storage buffer indexed by the per-instance tag (set to slot index by the pack pass).
+
+use std::ops::Deref;
+
+use bevy::asset::embedded_asset;
+use bevy::pbr::{ExtendedMaterial, MaterialExtension, MaterialPlugin};
+use bevy::prelude::*;
+use bevy::render::{render_resource::AsBindGroup, storage::ShaderBuffer};
+use bevy::shader::ShaderRef;
+
+use crate::render::material::UntypedMaterial;
+
+pub struct FieldColorMaterialPlugin;
+
+impl Plugin for FieldColorMaterialPlugin {
+    fn build(&self, app: &mut App) {
+        embedded_asset!(app, "field_color.wgsl");
+        embedded_asset!(app, "field_pbr.wgsl");
+        app.add_plugins(MaterialPlugin::<FieldColorMaterial>::default());
+        app.add_plugins(MaterialPlugin::<FieldPbrMaterial>::default());
+    }
+}
+
+#[derive(Asset, AsBindGroup, Reflect, Debug, Clone)]
+pub struct FieldColorMaterial {
+    #[storage(0, read_only)]
+    pub colors: Handle<ShaderBuffer>,
+}
+
+impl Material for FieldColorMaterial {
+    fn vertex_shader() -> ShaderRef {
+        "embedded://processing_render/field/field_color.wgsl".into()
+    }
+
+    fn fragment_shader() -> ShaderRef {
+        "embedded://processing_render/field/field_color.wgsl".into()
+    }
+}
+
+#[derive(Component, Clone)]
+pub struct FieldColorMaterial3d(pub Handle<FieldColorMaterial>);
+
+impl bevy::asset::AsAssetId for FieldColorMaterial3d {
+    type Asset = FieldColorMaterial;
+    fn as_asset_id(&self) -> AssetId<Self::Asset> {
+        self.0.id()
+    }
+}
+
+/// Sibling to `add_processing_materials` / `add_custom_materials`. Promotes
+/// `UntypedMaterial(handle)` entities whose handle is a [`FieldColorMaterial`]
+/// to having the typed `MeshMaterial3d<FieldColorMaterial>` component required
+/// by the render pipeline.
+pub fn add_field_color_materials(
+    mut commands: Commands,
+    meshes: Query<(Entity, &UntypedMaterial)>,
+) {
+    for (entity, handle) in meshes.iter() {
+        let handle = handle.deref().clone();
+        if let Ok(handle) = handle.try_typed::<FieldColorMaterial>() {
+            commands
+                .entity(entity)
+                .insert(MeshMaterial3d::<FieldColorMaterial>(handle));
+        }
+    }
+}
+
+/// PBR-lit per-particle color material. Wraps `StandardMaterial` via
+/// `ExtendedMaterial` so the user gets standard PBR lighting behavior on top
+/// of per-particle albedo from a storage buffer.
+pub type FieldPbrMaterial = ExtendedMaterial<StandardMaterial, FieldPbrExtension>;
+
+#[derive(Asset, AsBindGroup, Reflect, Debug, Clone)]
+pub struct FieldPbrExtension {
+    #[storage(100, read_only)]
+    pub colors: Handle<ShaderBuffer>,
+}
+
+impl MaterialExtension for FieldPbrExtension {
+    fn fragment_shader() -> ShaderRef {
+        "embedded://processing_render/field/field_pbr.wgsl".into()
+    }
+
+    fn deferred_fragment_shader() -> ShaderRef {
+        "embedded://processing_render/field/field_pbr.wgsl".into()
+    }
+}
+
+pub fn add_field_pbr_materials(
+    mut commands: Commands,
+    meshes: Query<(Entity, &UntypedMaterial)>,
+) {
+    for (entity, handle) in meshes.iter() {
+        let handle = handle.deref().clone();
+        if let Ok(handle) = handle.try_typed::<FieldPbrMaterial>() {
+            commands
+                .entity(entity)
+                .insert(MeshMaterial3d::<FieldPbrMaterial>(handle));
+        }
+    }
+}