Clean up.

Author: tychedelia

Cargo.toml

@@ -90,8 +90,8 @@ name = "gltf_load"
 path = "examples/gltf_load.rs"
 
 [[example]]
-name = "custom_shader"
-path = "examples/custom_shader.rs"
+name = "custom_material"
+path = "examples/custom_material.rs"
 
 [profile.wasm-release]
 inherits = "release"

…rocessing_pyo3/examples/custom_shader.py …cessing_pyo3/examples/custom_material.pycrates/processing_pyo3/examples/custom_shader.py renamed to crates/processing_pyo3/examples/custom_material.py crates/processing_pyo3/examples/custom_shader.py renamed to crates/processing_pyo3/examples/custom_material.py

@@ -371,7 +371,7 @@ fn push_matrix(module: &Bound<'_, PyModule>) -> PyResult<()> {
 #[pyfunction]
 #[pyo3(pass_module)]
 fn pop_matrix(module: &Bound<'_, PyModule>) -> PyResult<()> {
-    graphics!(module).push_matrix()
+    graphics!(module).pop_matrix()
 }
 
 #[pyfunction]

crates/processing_pyo3/src/lib.rs

@@ -44,7 +44,7 @@ impl Material {
         kwargs: Option<&Bound<'_, PyDict>>,
     ) -> PyResult<Self> {
         let entity = if vertex.is_some() || fragment.is_some() {
-            material_create_from_shaders(
+            material_create_custom(
                 vertex.map(|s| s.entity),
                 fragment.map(|s| s.entity),
             )

crates/processing_pyo3/src/material.rs

@@ -457,8 +457,6 @@ pub fn flush(app: &mut App, entity: Entity) -> Result<()> {
     Ok(())
 }
 
-/// Present the current frame to the surface. Flushes any pending draw commands,
-/// enables camera output for one frame, then disables it again.
 pub fn present(app: &mut App, entity: Entity) -> Result<()> {
     graphics_mut!(app, entity)
         .get_mut::<Camera>()
@@ -473,41 +471,6 @@ pub fn present(app: &mut App, entity: Entity) -> Result<()> {
         .ok_or(ProcessingError::GraphicsNotFound)?
         .output_mode = CameraOutputMode::Skip;
 
-    // // Sync ViewTarget textures: copy main_texture → main_texture_other.
-    // // This ensures both A and B have identical content regardless of whether
-    // // post-processing effects called post_process_write() (which swaps A/B).
-    // app.world_mut()
-    //     .run_system_cached_with(sync_view_target_textures, entity)
-    //     .unwrap()?;
-
-    Ok(())
-}
-
-/// Copy the current main_texture to main_texture_other so both ViewTarget
-/// textures have identical content. This ensures pixel persistence works
-/// regardless of post-processing effects that may swap the A/B texture selector.
-fn sync_view_target_textures(
-    In(entity): In<Entity>,
-    graphics_query: Query<&Graphics>,
-    graphics_targets: Res<GraphicsTargets>,
-    render_device: Res<RenderDevice>,
-    render_queue: Res<RenderQueue>,
-) -> Result<()> {
-    let graphics = graphics_query
-        .get(entity)
-        .map_err(|_| ProcessingError::GraphicsNotFound)?;
-
-    let view_target = graphics_targets
-        .get(&entity)
-        .ok_or(ProcessingError::GraphicsNotFound)?;
-
-    let src = view_target.main_texture();
-    let dst = view_target.main_texture_other();
-
-    let mut encoder = render_device.create_command_encoder(&CommandEncoderDescriptor::default());
-    encoder.copy_texture_to_texture(src.as_image_copy(), dst.as_image_copy(), graphics.size);
-    render_queue.submit(std::iter::once(encoder.finish()));
-
     Ok(())
 }
 
@@ -528,7 +491,6 @@ pub fn record_command(
     Ok(())
 }
 
-/// Raw readback result containing bytes and format metadata.
 pub struct ReadbackData {
     pub bytes: Vec<u8>,
     pub format: TextureFormat,

crates/processing_render/src/graphics.rs

@@ -1327,21 +1327,13 @@ pub fn shader_destroy(entity: Entity) -> error::Result<()> {
     })
 }
 
-pub fn material_create_from_shaders(
+pub fn material_create_custom(
     vertex: Option<Entity>,
     fragment: Option<Entity>,
 ) -> error::Result<Entity> {
     app_mut(|app| {
         app.world_mut()
-            .run_system_cached_with(material::custom::create_from_shaders, (vertex, fragment))
-            .unwrap()
-    })
-}
-
-pub fn material_create_custom(shader_source: &str) -> error::Result<Entity> {
-    app_mut(|app| {
-        app.world_mut()
-            .run_system_cached_with(material::custom::create_custom, shader_source.to_string())
+            .run_system_cached_with(material::custom::create_custom, (vertex, fragment))
             .unwrap()
     })
 }

crates/processing_render/src/lib.rs

@@ -40,22 +40,23 @@ use bevy::{
 
 use bevy_naga_reflect::dynamic_shader::DynamicShader;
 
+use bevy::shader::Shader as ShaderAsset;
+
 use crate::error::{ProcessingError, Result};
 use crate::material::MaterialValue;
 use crate::render::material::UntypedMaterial;
 
 #[derive(Asset, TypePath, Clone)]
 pub struct CustomMaterial {
     pub shader: DynamicShader,
-    pub vertex_shader: Option<Handle<Shader>>,
-    pub fragment_shader: Option<Handle<Shader>>,
+    pub vertex_shader: Option<Handle<ShaderAsset>>,
+    pub fragment_shader: Option<Handle<ShaderAsset>>,
 }
 
-/// A compiled shader program that can be used to create multiple material instances.
 #[derive(Component)]
-pub struct ShaderProgram {
+pub struct Shader {
     pub module: naga::Module,
-    pub shader_handle: Handle<Shader>,
+    pub shader_handle: Handle<ShaderAsset>,
 }
 
 #[derive(Component, Clone)]
@@ -136,71 +137,30 @@ fn detect_stages(module: &naga::Module) -> (bool, bool) {
     (has_vertex, has_fragment)
 }
 
-/// Create a custom material from WGSL/WESL shader source (convenience: compile + create in one step).
-pub fn create_custom(
-    In(source): In<String>,
-    mut commands: Commands,
-    mut shaders: ResMut<Assets<Shader>>,
-    mut custom_materials: ResMut<Assets<CustomMaterial>>,
-) -> Result<Entity> {
-    let (compiled_wgsl, module) = compile_shader(&source)?;
-    let (has_vertex, has_fragment) = detect_stages(&module);
-
-    let mut shader = DynamicShader::new(module)
-        .map_err(|e| ProcessingError::ShaderCompilationError(format!("{e}")))?;
-    shader.init();
-
-    let shader_handle = shaders.add(Shader::from_wgsl(compiled_wgsl, "custom_material"));
-
-    let material = CustomMaterial {
-        shader,
-        vertex_shader: if has_vertex {
-            Some(shader_handle.clone())
-        } else {
-            None
-        },
-        fragment_shader: if has_fragment {
-            Some(shader_handle)
-        } else {
-            None
-        },
-    };
-    let handle = custom_materials.add(material);
-    let entity = commands.spawn(UntypedMaterial(handle.untyped())).id();
-    Ok(entity)
-}
-
-/// Compile WGSL source and spawn an entity with ShaderProgram.
 pub fn create_shader(
     In(source): In<String>,
     mut commands: Commands,
-    mut shaders: ResMut<Assets<Shader>>,
+    mut shaders: ResMut<Assets<ShaderAsset>>,
 ) -> Result<Entity> {
     let (compiled_wgsl, module) = compile_shader(&source)?;
-    let shader_handle = shaders.add(Shader::from_wgsl(compiled_wgsl, "custom_material"));
+    let shader_handle = shaders.add(ShaderAsset::from_wgsl(compiled_wgsl, "custom_material"));
     Ok(commands
-        .spawn(ShaderProgram {
+        .spawn(Shader {
             module,
             shader_handle,
         })
         .id())
 }
 
-/// Destroy a shader program entity.
 pub fn destroy_shader(In(entity): In<Entity>, mut commands: Commands) -> Result<()> {
     commands.entity(entity).despawn();
     Ok(())
 }
 
-/// Create a CustomMaterial from separate vertex and fragment ShaderPrograms.
-///
-/// At least one of `vertex` or `fragment` must be `Some`. The `DynamicShader`
-/// (uniform storage) is built from whichever module contains `@group(4)` bindings
-/// (fragment preferred, falls back to vertex).
-pub fn create_from_shaders(
+pub fn create_custom(
     In((vertex_entity, fragment_entity)): In<(Option<Entity>, Option<Entity>)>,
     mut commands: Commands,
-    shader_programs: Query<&ShaderProgram>,
+    shader_programs: Query<&Shader>,
     mut custom_materials: ResMut<Assets<CustomMaterial>>,
 ) -> Result<Entity> {
     let vertex_program = vertex_entity
@@ -212,15 +172,14 @@ pub fn create_from_shaders(
         .transpose()
         .map_err(|_| ProcessingError::ShaderNotFound)?;
 
-    // Build DynamicShader from the module that provides @group(4) bindings.
-    // Prefer fragment, fall back to vertex.
+    // Prefer fragment module for reflection, fall back to vertex.
     let reflection_module = fragment_program
         .map(|p| &p.module)
         .or(vertex_program.map(|p| &p.module))
         .ok_or(ProcessingError::ShaderNotFound)?;
 
     let mut shader = DynamicShader::new(reflection_module.clone())
-        .map_err(|e| ProcessingError::ShaderCompilationError(format!("{e}")))?;
+        .map_err(|e| ProcessingError::ShaderCompilationError(e.to_string()))?;
     shader.init();
 
     let material = CustomMaterial {
@@ -232,20 +191,14 @@ pub fn create_from_shaders(
     Ok(commands.spawn(UntypedMaterial(handle.untyped())).id())
 }
 
-/// Set a property on a custom material by field name.
-///
-/// Supports top-level parameters (e.g. the uniform var name) and automatic
-/// search into struct fields (e.g. "color" found inside a uniform struct).
 pub fn set_property(material: &mut CustomMaterial, name: &str, value: &MaterialValue) -> Result<()> {
     let reflect_value: Box<dyn PartialReflect> = material_value_to_reflect(value)?;
 
-    // Try top-level parameter first
     if let Some(field) = material.shader.field_mut(name) {
         field.apply(&*reflect_value);
         return Ok(());
     }
 
-    // Search struct parameters for a matching nested field
     let param_name = find_param_containing_field(&material.shader, name);
     if let Some(param_name) = param_name {
         if let Some(param) = material.shader.field_mut(&param_name) {
@@ -281,7 +234,6 @@ fn material_value_to_reflect(value: &MaterialValue) -> Result<Box<dyn PartialRef
     })
 }
 
-/// Find which top-level parameter (struct) contains a field with the given name.
 fn find_param_containing_field(shader: &DynamicShader, field_name: &str) -> Option<String> {
     for i in 0..shader.field_len() {
         if let Some(field) = shader.field_at(i) {
@@ -295,10 +247,6 @@ fn find_param_containing_field(shader: &DynamicShader, field_name: &str) -> Opti
     None
 }
 
-// ---------------------------------------------------------------------------
-// Plugin
-// ---------------------------------------------------------------------------
-
 pub struct CustomMaterialPlugin;
 
 impl Plugin for CustomMaterialPlugin {
@@ -330,16 +278,10 @@ impl Plugin for CustomMaterialPlugin {
     }
 }
 
-// ---------------------------------------------------------------------------
-// Render-world init
-// ---------------------------------------------------------------------------
-
 fn init_custom_material_resources(
     mut bind_group_allocators: ResMut<MaterialBindGroupAllocators>,
     render_device: Res<RenderDevice>,
 ) {
-    // Minimal placeholder layout — actual layouts are provided per-allocation
-    // via allocate_unprepared in non-bindless mode.
     let bind_group_layout = BindGroupLayoutDescriptor::new("custom_material_layout", &[]);
 
     bind_group_allocators.insert(
@@ -354,10 +296,6 @@ fn init_custom_material_resources(
     );
 }
 
-// ---------------------------------------------------------------------------
-// ErasedRenderAsset
-// ---------------------------------------------------------------------------
-
 impl ErasedRenderAsset for CustomMaterial {
     type SourceAsset = CustomMaterial;
     type ErasedAsset = PreparedMaterial;
@@ -384,12 +322,10 @@ impl ErasedRenderAsset for CustomMaterial {
     ) -> std::result::Result<Self::ErasedAsset, PrepareAssetError<Self::SourceAsset>> {
         let reflection = source_asset.shader.reflection();
 
-        // Build bind group layout from shader reflection (group 3 = material bind group index)
         let layout_entries = reflection.bind_group_layout(3);
         let bind_group_layout =
             BindGroupLayoutDescriptor::new("custom_material_bind_group", &layout_entries);
 
-        // Create GPU bindings from the DynamicShader's current parameter values
         let bindings = reflection.create_bindings(3, &source_asset.shader, render_device, gpu_images);
 
         let unprepared = UnpreparedBindGroup {
@@ -400,7 +336,6 @@ impl ErasedRenderAsset for CustomMaterial {
             .get_mut(&TypeId::of::<CustomMaterial>())
             .unwrap();
 
-        // Register binding in RenderMaterialBindings so the draw function can find it
         let binding = match render_material_bindings.entry(asset_id.into()) {
             Entry::Occupied(mut occupied_entry) => {
                 bind_group_allocator.free(*occupied_entry.get());
@@ -413,7 +348,6 @@ impl ErasedRenderAsset for CustomMaterial {
                 .insert(bind_group_allocator.allocate_unprepared(unprepared, &bind_group_layout)),
         };
 
-        // Draw function
         let draw_function = opaque_draw_functions
             .read()
             .id::<DrawMaterial>();
@@ -439,10 +373,6 @@ impl ErasedRenderAsset for CustomMaterial {
     }
 }
 
-// ---------------------------------------------------------------------------
-// Extract systems
-// ---------------------------------------------------------------------------
-
 fn extract_custom_materials(
     mut material_instances: ResMut<RenderMaterialInstances>,
     changed_query: Extract<
@@ -493,10 +423,6 @@ fn extract_custom_materials_that_need_specializations_removed(
     }
 }
 
-// ---------------------------------------------------------------------------
-// Specialization tracking (main world)
-// ---------------------------------------------------------------------------
-
 fn check_entities_needing_specialization(
     needs_specialization: Query<
         Entity,

crates/processing_render/src/material/custom.rs

@@ -3,14 +3,9 @@ use std::ops::Deref;
 
 use crate::material::custom::{CustomMaterial, CustomMaterial3d};
 
-/// A component that holds an untyped handle to a material. This allows the main render loop
-/// to be agnostic of the specific material types being used, and allows for dynamic material
-/// creation based on the `MaterialKey`.
 #[derive(Component, Deref)]
 pub struct UntypedMaterial(pub UntypedHandle);
 
-/// Defines the current material for a batch, which can be used to determine when to flush the
-/// current batch and start a new one.
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub enum MaterialKey {
     Color {
@@ -75,17 +70,11 @@ impl MaterialKey {
                 };
                 materials.add(mat).untyped()
             }
-            MaterialKey::Custom(_) => {
-                unreachable!(
-                    "Custom materials are resolved directly from entity handles, not via to_material"
-                )
-            }
+            MaterialKey::Custom(_) => unreachable!(),
         }
     }
 }
 
-/// A system that adds a `MeshMaterial3d` component to any entity with an `UntypedMaterial` that can
-/// be typed as a `StandardMaterial`.
 pub fn add_standard_materials(mut commands: Commands, meshes: Query<(Entity, &UntypedMaterial)>) {
     for (entity, handle) in meshes.iter() {
         let handle = handle.deref().clone();
@@ -95,8 +84,6 @@ pub fn add_standard_materials(mut commands: Commands, meshes: Query<(Entity, &Un
     }
 }
 
-/// A system that adds a `CustomMaterial3d` component to any entity with an `UntypedMaterial` that
-/// can be typed as a `CustomMaterial`.
 pub fn add_custom_materials(mut commands: Commands, meshes: Query<(Entity, &UntypedMaterial)>) {
     for (entity, handle) in meshes.iter() {
         let handle = handle.deref().clone();