Blend mode support.

Author: tychedelia

Cargo.toml

@@ -128,6 +128,10 @@ path = "examples/custom_material.rs"
 name = "input"
 path = "examples/input.rs"
 
+[[example]]
+name = "blend_modes"
+path = "examples/blend_modes.rs"
+
 [profile.wasm-release]
 inherits = "release"
 opt-level = "z"

crates/processing_ffi/src/lib.rs

@@ -466,6 +466,44 @@ pub extern "C" fn processing_shear_y(graphics_id: u64, angle: f32) {
     error::check(|| graphics_record_command(graphics_entity, DrawCommand::ShearY { angle }));
 }
 
+/// Set the blend mode.
+///
+/// Mode values: 0=BLEND, 1=ADD, 2=SUBTRACT, 3=DARKEST, 4=LIGHTEST,
+/// 5=DIFFERENCE, 6=EXCLUSION, 7=MULTIPLY, 8=SCREEN, 9=REPLACE
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_set_blend_mode(graphics_id: u64, mode: u8) {
+    error::clear_error();
+    let graphics_entity = Entity::from_bits(graphics_id);
+    let blend_state = processing::prelude::BlendMode::from(mode).to_blend_state();
+    error::check(|| graphics_record_command(graphics_entity, DrawCommand::BlendMode(blend_state)));
+}
+
+/// Set a custom blend mode by specifying individual blend components.
+///
+/// Each factor/operation is a u8 mapping to the WebGPU BlendFactor/BlendOperation enums.
+/// BlendFactor: 0=Zero, 1=One, 2=Src, 3=OneMinusSrc, 4=SrcAlpha, 5=OneMinusSrcAlpha,
+///              6=Dst, 7=OneMinusDst, 8=DstAlpha, 9=OneMinusDstAlpha, 10=SrcAlphaSaturated
+/// BlendOperation: 0=Add, 1=Subtract, 2=ReverseSubtract, 3=Min, 4=Max
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_set_custom_blend_mode(
+    graphics_id: u64,
+    color_src: u8,
+    color_dst: u8,
+    color_op: u8,
+    alpha_src: u8,
+    alpha_dst: u8,
+    alpha_op: u8,
+) {
+    error::clear_error();
+    let graphics_entity = Entity::from_bits(graphics_id);
+    let blend_state = custom_blend_state(
+        color_src, color_dst, color_op, alpha_src, alpha_dst, alpha_op,
+    );
+    error::check(|| {
+        graphics_record_command(graphics_entity, DrawCommand::BlendMode(Some(blend_state)))
+    });
+}
+
 /// Draw a rectangle.
 ///
 /// SAFETY:

crates/processing_pyo3/src/graphics.rs

@@ -18,6 +18,63 @@ use pyo3::{
     types::{PyDict, PyTuple},
 };
 
+use crate::glfw::GlfwContext;
+use crate::math::{extract_vec2, extract_vec3, extract_vec4};
+
+// ---------------------------------------------------------------------------
+// BlendMode
+// ---------------------------------------------------------------------------
+
+#[pyclass(name = "BlendMode")]
+#[derive(Clone)]
+pub struct PyBlendMode {
+    pub(crate) blend_state: Option<bevy::render::render_resource::BlendState>,
+    name: Option<&'static str>,
+}
+
+impl PyBlendMode {
+    pub(crate) fn from_preset(mode: BlendMode) -> Self {
+        Self {
+            blend_state: mode.to_blend_state(),
+            name: Some(mode.name()),
+        }
+    }
+}
+
+#[pymethods]
+impl PyBlendMode {
+    /// Create a custom blend mode by specifying individual blend components.
+    ///
+    /// All arguments are keyword-only. Use the blend factor constants (ZERO, ONE,
+    /// SRC_COLOR, SRC_ALPHA, DST_COLOR, etc.) and blend operation constants
+    /// (OP_ADD, OP_SUBTRACT, OP_REVERSE_SUBTRACT, OP_MIN, OP_MAX).
+    #[new]
+    #[pyo3(signature = (*, color_src, color_dst, color_op, alpha_src, alpha_dst, alpha_op))]
+    fn new(
+        color_src: u8,
+        color_dst: u8,
+        color_op: u8,
+        alpha_src: u8,
+        alpha_dst: u8,
+        alpha_op: u8,
+    ) -> Self {
+        Self {
+            blend_state: Some(custom_blend_state(
+                color_src, color_dst, color_op, alpha_src, alpha_dst, alpha_op,
+            )),
+            name: None,
+        }
+    }
+
+    fn __repr__(&self) -> String {
+        match self.name {
+            Some(name) => format!("BlendMode.{name}"),
+            None => "BlendMode(custom)".to_string(),
+        }
+    }
+}
+
+
 #[pyclass(unsendable)]
 pub struct Surface {
     pub(crate) entity: Entity,
@@ -517,6 +574,11 @@ impl Graphics {
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
+    pub fn blend_mode(&self, mode: &PyBlendMode) -> PyResult<()> {
+        graphics_record_command(self.entity, DrawCommand::BlendMode(mode.blend_state))
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
     pub fn set_material(&self, material: &crate::material::Material) -> PyResult<()> {
         graphics_record_command(self.entity, DrawCommand::Material(material.entity))
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))

crates/processing_pyo3/src/lib.rs

@@ -20,7 +20,9 @@ pub(crate) mod shader;
 #[cfg(feature = "webcam")]
 mod webcam;
 
-use graphics::{Geometry, Graphics, Image, Light, Topology, get_graphics, get_graphics_mut};
+use graphics::{
+    Geometry, Graphics, Image, Light, PyBlendMode, Topology, get_graphics, get_graphics_mut,
+};
 use material::Material;
 
 use pyo3::{
@@ -127,6 +129,8 @@ mod mewnala {
     #[pymodule_export]
     use super::Material;
     #[pymodule_export]
+    use super::PyBlendMode;
+    #[pymodule_export]
     use super::Shader;
     #[pymodule_export]
     use super::Topology;
@@ -341,6 +345,62 @@ mod mewnala {
     #[pymodule_export]
     const XYZ: u8 = 9;
 
+    // Blend factor constants (for BlendMode custom constructor)
+    #[pymodule_export]
+    const ZERO: u8 = 0;
+    #[pymodule_export]
+    const ONE: u8 = 1;
+    #[pymodule_export]
+    const SRC_COLOR: u8 = 2;
+    #[pymodule_export]
+    const ONE_MINUS_SRC_COLOR: u8 = 3;
+    #[pymodule_export]
+    const SRC_ALPHA: u8 = 4;
+    #[pymodule_export]
+    const ONE_MINUS_SRC_ALPHA: u8 = 5;
+    #[pymodule_export]
+    const DST_COLOR: u8 = 6;
+    #[pymodule_export]
+    const ONE_MINUS_DST_COLOR: u8 = 7;
+    #[pymodule_export]
+    const DST_ALPHA: u8 = 8;
+    #[pymodule_export]
+    const ONE_MINUS_DST_ALPHA: u8 = 9;
+    #[pymodule_export]
+    const SRC_ALPHA_SATURATED: u8 = 10;
+
+    // Blend operation constants (for BlendMode custom constructor)
+    #[pymodule_export]
+    const OP_ADD: u8 = 0;
+    #[pymodule_export]
+    const OP_SUBTRACT: u8 = 1;
+    #[pymodule_export]
+    const OP_REVERSE_SUBTRACT: u8 = 2;
+    #[pymodule_export]
+    const OP_MIN: u8 = 3;
+    #[pymodule_export]
+    const OP_MAX: u8 = 4;
+
+    // Blend mode preset constants (added in pymodule_init)
+    #[pymodule_init]
+    fn init(module: &Bound<'_, PyModule>) -> PyResult<()> {
+        use processing::prelude::BlendMode;
+        module.add("BLEND", PyBlendMode::from_preset(BlendMode::Blend))?;
+        module.add("ADD", PyBlendMode::from_preset(BlendMode::Add))?;
+        module.add("SUBTRACT", PyBlendMode::from_preset(BlendMode::Subtract))?;
+        module.add("DARKEST", PyBlendMode::from_preset(BlendMode::Darkest))?;
+        module.add("LIGHTEST", PyBlendMode::from_preset(BlendMode::Lightest))?;
+        module.add(
+            "DIFFERENCE",
+            PyBlendMode::from_preset(BlendMode::Difference),
+        )?;
+        module.add("EXCLUSION", PyBlendMode::from_preset(BlendMode::Exclusion))?;
+        module.add("MULTIPLY", PyBlendMode::from_preset(BlendMode::Multiply))?;
+        module.add("SCREEN", PyBlendMode::from_preset(BlendMode::Screen))?;
+        module.add("REPLACE", PyBlendMode::from_preset(BlendMode::Replace))?;
+        Ok(())
+    }
+
     #[pymodule]
     mod math {
         use super::*;
@@ -804,6 +864,12 @@ mod mewnala {
         graphics!(module).stroke_join(join)
     }
 
+    #[pyfunction]
+    #[pyo3(pass_module, signature = (mode))]
+    fn blend_mode(module: &Bound<'_, PyModule>, mode: &Bound<'_, PyBlendMode>) -> PyResult<()> {
+        graphics!(module).blend_mode(&*mode.extract::<PyRef<PyBlendMode>>()?)
+    }
+
     #[pyfunction]
     #[pyo3(pass_module, signature = (x, y, w, h, tl=0.0, tr=0.0, br=0.0, bl=0.0))]
     fn rect(

crates/processing_render/src/graphics.rs

@@ -132,6 +132,8 @@ 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.
         Mat4::orthographic_rh(
             0.0,
             self.width,

crates/processing_render/src/lib.rs

@@ -34,7 +34,7 @@ pub struct ProcessingRenderPlugin;
 
 impl Plugin for ProcessingRenderPlugin {
     fn build(&self, app: &mut App) {
-        use render::material::{add_custom_materials, add_standard_materials};
+        use render::material::{add_custom_materials, add_processing_materials};
         use render::{activate_cameras, clear_transient_meshes, flush_draw_commands};
 
         let config = app.world().resource::<Config>().clone();
@@ -66,7 +66,7 @@ impl Plugin for ProcessingRenderPlugin {
             surface::SurfacePlugin,
             geometry::GeometryPlugin,
             light::LightPlugin,
-            material::MaterialPlugin,
+            material::ProcessingMaterialPlugin,
             bevy::pbr::wireframe::WireframePlugin::default(),
             material::custom::CustomMaterialPlugin,
         ));
@@ -76,7 +76,7 @@ impl Plugin for ProcessingRenderPlugin {
                 Update,
                 (
                     flush_draw_commands,
-                    add_standard_materials,
+                    add_processing_materials,
                     add_custom_materials,
                 )
                     .chain()

crates/processing_render/src/material/custom.rs

@@ -11,17 +11,23 @@ wesl::wesl_pkg!(lygia);
 
 use bevy::{
     asset::{AsAssetId, AssetEventSystems},
-    core_pipeline::core_3d::Opaque3d,
+    core_pipeline::core_3d::{Opaque3d, Transparent3d},
     ecs::system::{
         SystemParamItem,
         lifetimeless::{SRes, SResMut},
     },
-    material::{MaterialProperties, key::ErasedMeshPipelineKey},
+    material::{
+        MaterialProperties,
+        descriptor::RenderPipelineDescriptor,
+        key::{ErasedMaterialKey, ErasedMaterialPipelineKey, ErasedMeshPipelineKey},
+        specialize::SpecializedMeshPipelineError,
+    },
+    mesh::MeshVertexBufferLayoutRef,
     pbr::{
         DrawMaterial, EntitiesNeedingSpecialization, MainPassOpaqueDrawFunction,
-        MaterialBindGroupAllocator, MaterialBindGroupAllocators, MaterialFragmentShader,
-        MaterialVertexShader, MeshPipelineKey, PreparedMaterial, RenderMaterialBindings,
-        RenderMaterialInstance, RenderMaterialInstances, base_specialize,
+        MainPassTransparentDrawFunction, MaterialBindGroupAllocator, MaterialBindGroupAllocators,
+        MaterialFragmentShader, MaterialVertexShader, MeshPipelineKey, PreparedMaterial,
+        RenderMaterialBindings, RenderMaterialInstance, RenderMaterialInstances, base_specialize,
     },
     prelude::*,
     reflect::{PartialReflect, ReflectMut, ReflectRef, structs::Struct},
@@ -31,7 +37,9 @@ use bevy::{
         erased_render_asset::{ErasedRenderAsset, ErasedRenderAssetPlugin, PrepareAssetError},
         render_asset::RenderAssets,
         render_phase::DrawFunctions,
-        render_resource::{BindGroupLayoutDescriptor, BindingResources, UnpreparedBindGroup},
+        render_resource::{
+            BindGroupLayoutDescriptor, BindingResources, BlendState, UnpreparedBindGroup,
+        },
         renderer::RenderDevice,
         sync_world::MainEntity,
         texture::GpuImage,
@@ -42,17 +50,43 @@ 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};
 use processing_core::error::{ProcessingError, Result};
 
+#[derive(Clone, Hash, PartialEq)]
+struct CustomMaterialKey {
+    blend_state: Option<BlendState>,
+}
+
+fn custom_blend_specialize(
+    key: &dyn Any,
+    descriptor: &mut RenderPipelineDescriptor,
+    _layout: &MeshVertexBufferLayoutRef,
+    _pipeline_key: ErasedMaterialPipelineKey,
+) -> std::result::Result<(), SpecializedMeshPipelineError> {
+    if let Some(key) = key.downcast_ref::<CustomMaterialKey>() {
+        if let Some(blend_state) = key.blend_state {
+            if let Some(fragment_state) = &mut descriptor.fragment {
+                for target in fragment_state.targets.iter_mut().flatten() {
+                    target.blend = Some(blend_state);
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
 #[derive(Asset, TypePath, Clone)]
 pub struct CustomMaterial {
     pub shader: DynamicShader,
     pub shader_handle: Handle<ShaderAsset>,
     pub has_vertex: bool,
     pub has_fragment: bool,
+    pub blend_state: Option<bevy::render::render_resource::BlendState>,
 }
 
 #[derive(Component)]
@@ -227,6 +261,7 @@ pub fn create_custom(
         shader_handle: program.shader_handle.clone(),
         has_vertex,
         has_fragment,
+        blend_state: None,
     };
     let handle = custom_materials.add(material);
     Ok(commands.spawn(UntypedMaterial(handle.untyped())).id())
@@ -393,13 +428,22 @@ impl ErasedRenderAsset for CustomMaterial {
 
         let draw_function = opaque_draw_functions.read().id::<DrawMaterial>();
 
+        let blend_state = source_asset.blend_state;
         let mut properties = MaterialProperties {
             mesh_pipeline_key_bits: ErasedMeshPipelineKey::new(MeshPipelineKey::empty()),
             base_specialize: Some(base_specialize),
             material_layout: Some(bind_group_layout),
+            material_key: ErasedMaterialKey::new(CustomMaterialKey { blend_state }),
+            user_specialize: Some(custom_blend_specialize),
+            alpha_mode: if blend_state.is_some() {
+                AlphaMode::Blend
+            } else {
+                AlphaMode::Opaque
+            },
             ..Default::default()
         };
         properties.add_draw_function(MainPassOpaqueDrawFunction, draw_function);
+        properties.add_draw_function(MainPassTransparentDrawFunction, draw_function);
         if source_asset.has_vertex {
             properties.add_shader(MaterialVertexShader, source_asset.shader_handle.clone());
         }