Blend modes.

Author: tychedelia

crates/processing_pyo3/src/graphics.rs

@@ -21,10 +21,6 @@ use pyo3::{
 use crate::glfw::GlfwContext;
 use crate::math::{extract_vec2, extract_vec3, extract_vec4};
 
-// ---------------------------------------------------------------------------
-// BlendMode
-// ---------------------------------------------------------------------------
-
 #[pyclass(name = "BlendMode")]
 #[derive(Clone)]
 pub struct PyBlendMode {

crates/processing_render/src/graphics.rs

@@ -132,8 +132,7 @@ impl ProcessingProjection {
 
 impl CameraProjection for ProcessingProjection {
     fn get_clip_from_view(&self) -> Mat4 {
-        // NOTE: near and far are swapped to invert the depth range from [0,1] to [1,0]
-        // This is for interoperability with Bevy's reverse-Z depth pipeline.
+        // near/far swapped for Bevy's reverse-Z depth
         Mat4::orthographic_rh(
             0.0,
             self.width,

crates/processing_render/src/material/custom.rs

@@ -1,4 +1,4 @@
-use std::any::TypeId;
+use std::any::{Any, TypeId};
 use std::borrow::Cow;
 use std::sync::Arc;
 
@@ -11,7 +11,7 @@ wesl::wesl_pkg!(lygia);
 
 use bevy::{
     asset::{AsAssetId, AssetEventSystems},
-    core_pipeline::core_3d::{Opaque3d, Transparent3d},
+    core_pipeline::core_3d::Opaque3d,
     ecs::system::{
         SystemParamItem,
         lifetimeless::{SRes, SResMut},
@@ -50,8 +50,6 @@ use bevy_naga_reflect::dynamic_shader::DynamicShader;
 
 use bevy::shader::Shader as ShaderAsset;
 
-use std::any::Any;
-
 use crate::material::MaterialValue;
 use crate::render::material::UntypedMaterial;
 use processing_core::config::{Config, ConfigKey};
@@ -86,7 +84,7 @@ pub struct CustomMaterial {
     pub shader_handle: Handle<ShaderAsset>,
     pub has_vertex: bool,
     pub has_fragment: bool,
-    pub blend_state: Option<bevy::render::render_resource::BlendState>,
+    pub blend_state: Option<BlendState>,
 }
 
 #[derive(Component)]

crates/processing_render/src/render/command.rs

@@ -75,7 +75,6 @@ impl From<u8> for BlendMode {
     }
 }
 
-/// Convert a u8 to a WebGPU BlendFactor.
 pub fn blend_factor_from_u8(v: u8) -> BlendFactor {
     match v {
         0 => BlendFactor::Zero,
@@ -93,7 +92,6 @@ pub fn blend_factor_from_u8(v: u8) -> BlendFactor {
     }
 }
 
-/// Convert a u8 to a WebGPU BlendOperation.
 pub fn blend_op_from_u8(v: u8) -> BlendOperation {
     match v {
         0 => BlendOperation::Add,
@@ -105,7 +103,6 @@ pub fn blend_op_from_u8(v: u8) -> BlendOperation {
     }
 }
 
-/// Build a BlendState from individual component parameters.
 pub fn custom_blend_state(
     color_src: u8,
     color_dst: u8,
@@ -150,8 +147,7 @@ impl BlendMode {
         }
     }
 
-    /// Convert to a WebGPU BlendState, matching Processing's OpenGL blend configurations.
-    /// Returns None for the default Blend mode (standard alpha blending handled by AlphaMode).
+    /// Returns None for the default Blend mode, letting AlphaMode handle blending.
     pub fn to_blend_state(self) -> Option<BlendState> {
         use BlendFactor::*;
         use BlendOperation::*;

crates/processing_render/src/render/mod.rs

@@ -358,12 +358,16 @@ pub fn flush_draw_commands(
 
                     let material_key = material_key_with_fill(&state);
                     let material_handle = match &material_key {
-                        MaterialKey::Custom { entity: mat_entity, .. } => {
-                            let Some(handle) = p_material_handles.get(*mat_entity).ok() else {
+                        MaterialKey::Custom { entity: mat_entity, blend_state } => {
+                            let Some(untyped) = p_material_handles.get(*mat_entity).ok() else {
                                 warn!("Could not find material for entity {:?}", mat_entity);
                                 continue;
                             };
-                            handle.0.clone()
+                            clone_custom_material_with_blend(
+                                &mut res.custom_materials,
+                                &untyped.0,
+                                *blend_state,
+                            )
                         }
                         _ => material_key.to_material(&mut res.materials),
                     };
@@ -478,24 +482,11 @@ fn spawn_mesh(
                 warn!("Custom material entity {:?} not found", entity);
                 return;
             };
-            match *blend_state {
-                // No blend override — use the original handle
-                None => untyped.0.clone(),
-                // Blend override — clone the custom material with the blend state
-                Some(bs) => {
-                    if let Ok(handle) = untyped.0.clone().try_typed::<CustomMaterial>() {
-                        if let Some(original) = res.custom_materials.get(&handle) {
-                            let mut variant = original.clone();
-                            variant.blend_state = Some(bs);
-                            res.custom_materials.add(variant).untyped()
-                        } else {
-                            untyped.0.clone()
-                        }
-                    } else {
-                        untyped.0.clone()
-                    }
-                }
-            }
+            clone_custom_material_with_blend(
+                &mut res.custom_materials,
+                &untyped.0,
+                *blend_state,
+            )
         }
         _ => key.to_material(&mut res.materials),
     };
@@ -512,8 +503,6 @@ fn spawn_mesh(
 fn needs_batch(batch: &BatchState, state: &RenderState, material_key: &MaterialKey) -> bool {
     let material_changed = batch.material_key.as_ref() != Some(material_key);
     let transform_changed = batch.transform != state.transform.current();
-    // When a custom blend mode is active, each shape needs its own draw call
-    // so that shapes composite against each other in draw order.
     let requires_separate_draws = state.blend_state.is_some();
     material_changed || transform_changed || requires_separate_draws
 }
@@ -531,6 +520,27 @@ fn start_batch(
     batch.current_mesh = Some(empty_mesh());
 }
 
+fn clone_custom_material_with_blend(
+    custom_materials: &mut Assets<CustomMaterial>,
+    original: &UntypedHandle,
+    blend_state: Option<BlendState>,
+) -> UntypedHandle {
+    match blend_state {
+        None => original.clone(),
+        Some(bs) => {
+            let Ok(handle) = original.clone().try_typed::<CustomMaterial>() else {
+                return original.clone();
+            };
+            let Some(original_mat) = custom_materials.get(&handle) else {
+                return original.clone();
+            };
+            let mut variant = original_mat.clone();
+            variant.blend_state = Some(bs);
+            custom_materials.add(variant).untyped()
+        }
+    }
+}
+
 fn material_key_with_color(
     key: &MaterialKey,
     color: Color,
@@ -641,13 +651,17 @@ fn add_shape3d(
     let mesh_handle = res.meshes.add(mesh);
     let fill_color = state.fill_color.unwrap_or(Color::WHITE);
     let material_handle = match &state.material_key {
-        MaterialKey::Custom { entity, .. } => match material_handles.get(*entity) {
-            Ok(handle) => handle.0.clone(),
-            Err(_) => {
+        MaterialKey::Custom { entity, .. } => {
+            let Some(untyped) = material_handles.get(*entity).ok() else {
                 warn!("Custom material entity {:?} not found", entity);
                 return;
-            }
-        },
+            };
+            clone_custom_material_with_blend(
+                &mut res.custom_materials,
+                &untyped.0,
+                state.blend_state,
+            )
+        }
         // TODO: in 2d, we use vertex colors. `to_material` becomes complicated if we also encode
         // a base color in the material, so for simplicity we just create a new material here
         // that is unlit and uses the fill color as the base color