.

Author: tychedelia

crates/processing_render/src/compute.rs

@@ -38,13 +38,7 @@ pub struct Buffer {
     pub handle: Handle<ShaderBuffer>,
     pub readback_buffer: WgpuBuffer,
     pub size: u64,
-    /// True when `ShaderBuffer.data` reflects current GPU contents. Cleared
-    /// when a pipeline that may write to the buffer runs; the next read or
-    /// write must readback first.
     pub synced: bool,
-    /// Set permanently once the buffer is bound to any pipeline as read_write
-    /// storage. When true, any frame tick could have mutated GPU contents via
-    /// a render pass, so `synced` must be cleared after each `app.update()`.
     pub bound_rw: bool,
 }
 
@@ -97,9 +91,6 @@ pub fn create_buffer_with_data(
         .id()
 }
 
-/// Mutate the CPU-side data of a `ShaderBuffer` in place. Fires
-/// `AssetEvent::Modified` so Bevy's render-asset extract uploads the new
-/// contents to the GPU at the next sync point.
 pub fn write_buffer_cpu(
     In((handle, offset, data)): In<(Handle<ShaderBuffer>, u64, Vec<u8>)>,
     mut buffers: ResMut<Assets<ShaderBuffer>>,
@@ -117,10 +108,8 @@ pub fn write_buffer_cpu(
     Ok(())
 }
 
-/// Copy the GPU buffer back to CPU and return its full contents. Runs in the
-/// render world; the caller is responsible for writing the bytes back into
-/// `ShaderBuffer.data` via `Assets::get_mut_untracked` (avoiding spurious
-/// `AssetEvent::Modified`s, since this is a readback, not a stage-for-upload).
+/// Caller must write bytes back via `get_mut_untracked` to avoid triggering
+/// a re-upload.
 pub fn read_buffer_gpu(
     In((handle, readback_buffer, size)): In<(Handle<ShaderBuffer>, WgpuBuffer, u64)>,
     gpu_buffers: Res<RenderAssets<GpuShaderBuffer>>,
@@ -172,10 +161,6 @@ pub struct Compute {
     pub entry_point: String,
     pub pipeline_id: CachedComputePipelineId,
     pub bind_group_layout_descriptors: Vec<(u32, BindGroupLayoutDescriptor)>,
-    /// Buffer entities bound to this compute on a `read_write` storage param.
-    /// Their CPU view of GPU data is invalidated after each dispatch so the
-    /// next read/write does a readback. Read-only bindings don't need this
-    /// since the dispatch can't mutate them.
     pub rw_buffers: HashMap<String, Entity>,
 }
 

crates/processing_render/src/graphics.rs

@@ -453,36 +453,6 @@ pub fn flush(app: &mut App, entity: Entity) -> Result<()> {
     Ok(())
 }
 
-/// Flush all graphics with pending commands and run a frame so any other
-/// pending GPU state (asset writes, etc.) is extracted and uploaded. Used as
-/// a sync boundary before operations like compute dispatch that may bind
-/// graphics targets or recently-mutated assets.
-pub fn flush_all(app: &mut App) {
-    let mut to_flush = Vec::new();
-    let world = app.world_mut();
-    let mut q = world.query::<(Entity, &CommandBuffer, &Graphics)>();
-    for (e, cb, _) in q.iter(world) {
-        if !cb.commands.is_empty() {
-            to_flush.push(e);
-        }
-    }
-
-    for e in &to_flush {
-        if let Ok(mut em) = world.get_entity_mut(*e) {
-            em.insert(Flush);
-        }
-    }
-
-    app.update();
-
-    let world = app.world_mut();
-    for e in &to_flush {
-        if let Ok(mut em) = world.get_entity_mut(*e) {
-            em.remove::<Flush>();
-        }
-    }
-}
-
 pub fn present(app: &mut App, entity: Entity) -> Result<()> {
     graphics_mut!(app, entity)
         .get_mut::<Camera>()

crates/processing_render/src/lib.rs

@@ -1677,9 +1677,6 @@ pub fn buffer_write_element(entity: Entity, offset: u64, data: Vec<u8>) -> error
     buffer_write_range(entity, offset, data, false)
 }
 
-/// Ensure `ShaderBuffer.data` reflects current GPU contents by reading the
-/// buffer back into the asset if it was invalidated by a prior dispatch.
-/// Subsequent reads/writes can then operate on the in-asset bytes directly.
 fn ensure_buffer_synced(app: &mut App, entity: Entity) -> error::Result<()> {
     let (handle, readback_buffer, size, synced) = {
         let buf = app
@@ -1825,41 +1822,26 @@ pub fn compute_set(
 
 pub fn compute_dispatch(entity: Entity, x: u32, y: u32, z: u32) -> error::Result<()> {
     app_mut(|app| {
-        // Flush any pending graphics work and let Bevy's render-asset extract
-        // upload any CPU-side buffer mutations to the GPU before the dispatch
-        // runs. This is the sync boundary for compute inputs.
-        crate::graphics::flush_all(app);
+        app.update();
 
-        let (args, rw_entities) = {
+        let args = {
             let c = app
                 .world()
                 .get::<compute::Compute>(entity)
                 .ok_or(error::ProcessingError::ComputeNotFound)?;
-            let args = (
+            (
                 c.pipeline_id,
                 c.bind_group_layout_descriptors.clone(),
                 c.shader.clone(),
                 x,
                 y,
                 z,
-            );
-            let rw_entities: Vec<Entity> = c.rw_buffers.values().copied().collect();
-            (args, rw_entities)
+            )
         };
         app.sub_app_mut(bevy::render::RenderApp)
             .world_mut()
             .run_system_cached_with(compute::dispatch, args)
-            .unwrap()?;
-
-        // Invalidate the CPU view of any buffer the dispatch could have
-        // written. The next read or write on those buffers will readback first.
-        let world = app.world_mut();
-        for e in rw_entities {
-            if let Some(mut buf) = world.get_mut::<compute::Buffer>(e) {
-                buf.synced = false;
-            }
-        }
-        Ok(())
+            .unwrap()
     })
 }
 

crates/processing_render/src/material/custom.rs

@@ -305,14 +305,10 @@ pub(crate) fn shader_value_to_reflect(value: &ShaderValue) -> Result<Box<dyn Par
         ShaderValue::Int4(v) => Box::new(IVec4::from_array(*v)),
         ShaderValue::UInt(v) => Box::new(*v),
         ShaderValue::Mat4(v) => Box::new(Mat4::from_cols_array(v)),
-        ShaderValue::Texture(_) => {
-            return Err(ProcessingError::UnknownShaderProperty(
-                "Texture properties not yet supported for custom materials".to_string(),
-            ));
-        }
-        ShaderValue::Buffer(_) => {
-            return Err(ProcessingError::UnknownShaderProperty(
-                "Buffer properties not supported for custom materials".to_string(),
+        ShaderValue::Texture(_) | ShaderValue::Buffer(_) => {
+            return Err(ProcessingError::InvalidArgument(
+                "Texture/Buffer must be bound via set_property, not as a uniform value"
+                    .to_string(),
             ));
         }
     })