Implement blend mode support.

Author: tychedelia

crates/processing_ffi/src/lib.rs

@@ -466,24 +466,16 @@ 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)));
+    error::check(|| {
+        let blend_state = processing::prelude::BlendMode::try_from(mode)?.to_blend_state();
+        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,
@@ -496,10 +488,10 @@ pub extern "C" fn processing_set_custom_blend_mode(
 ) {
     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(|| {
+        let blend_state = custom_blend_state(
+            color_src, color_dst, color_op, alpha_src, alpha_dst, alpha_op,
+        )?;
         graphics_record_command(graphics_entity, DrawCommand::BlendMode(Some(blend_state)))
     });
 }
@@ -805,6 +797,35 @@ pub const PROCESSING_STROKE_JOIN_ROUND: u8 = 0;
 pub const PROCESSING_STROKE_JOIN_MITER: u8 = 1;
 pub const PROCESSING_STROKE_JOIN_BEVEL: u8 = 2;
 
+pub const PROCESSING_BLEND_MODE_BLEND: u8 = 0;
+pub const PROCESSING_BLEND_MODE_ADD: u8 = 1;
+pub const PROCESSING_BLEND_MODE_SUBTRACT: u8 = 2;
+pub const PROCESSING_BLEND_MODE_DARKEST: u8 = 3;
+pub const PROCESSING_BLEND_MODE_LIGHTEST: u8 = 4;
+pub const PROCESSING_BLEND_MODE_DIFFERENCE: u8 = 5;
+pub const PROCESSING_BLEND_MODE_EXCLUSION: u8 = 6;
+pub const PROCESSING_BLEND_MODE_MULTIPLY: u8 = 7;
+pub const PROCESSING_BLEND_MODE_SCREEN: u8 = 8;
+pub const PROCESSING_BLEND_MODE_REPLACE: u8 = 9;
+
+pub const PROCESSING_BLEND_FACTOR_ZERO: u8 = 0;
+pub const PROCESSING_BLEND_FACTOR_ONE: u8 = 1;
+pub const PROCESSING_BLEND_FACTOR_SRC: u8 = 2;
+pub const PROCESSING_BLEND_FACTOR_ONE_MINUS_SRC: u8 = 3;
+pub const PROCESSING_BLEND_FACTOR_SRC_ALPHA: u8 = 4;
+pub const PROCESSING_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA: u8 = 5;
+pub const PROCESSING_BLEND_FACTOR_DST: u8 = 6;
+pub const PROCESSING_BLEND_FACTOR_ONE_MINUS_DST: u8 = 7;
+pub const PROCESSING_BLEND_FACTOR_DST_ALPHA: u8 = 8;
+pub const PROCESSING_BLEND_FACTOR_ONE_MINUS_DST_ALPHA: u8 = 9;
+pub const PROCESSING_BLEND_FACTOR_SRC_ALPHA_SATURATED: u8 = 10;
+
+pub const PROCESSING_BLEND_OP_ADD: u8 = 0;
+pub const PROCESSING_BLEND_OP_SUBTRACT: u8 = 1;
+pub const PROCESSING_BLEND_OP_REVERSE_SUBTRACT: u8 = 2;
+pub const PROCESSING_BLEND_OP_MIN: u8 = 3;
+pub const PROCESSING_BLEND_OP_MAX: u8 = 4;
+
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_geometry_layout_create() -> u64 {
     error::clear_error();
@@ -1602,6 +1623,16 @@ pub extern "C" fn processing_key_is_down(key_code: u32) -> bool {
     .unwrap_or(false)
 }
 
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_key_just_pressed(key_code: u32) -> bool {
+    error::clear_error();
+    error::check(|| {
+        let kc = key_code_from_u32(key_code)?;
+        input_key_just_pressed(kc)
+    })
+    .unwrap_or(false)
+}
+
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_key() -> u32 {
     error::clear_error();

crates/processing_input/src/lib.rs

@@ -241,6 +241,15 @@ pub fn input_key_is_pressed() -> error::Result<bool> {
     })
 }
 
+pub fn input_key_just_pressed(key_code: KeyCode) -> error::Result<bool> {
+    app_mut(|app| {
+        Ok(app
+            .world()
+            .resource::<ButtonInput<KeyCode>>()
+            .just_pressed(key_code))
+    })
+}
+
 pub fn input_key_is_down(key_code: KeyCode) -> error::Result<bool> {
     app_mut(|app| {
         Ok(app

crates/processing_pyo3/examples/blend_modes.py

@@ -0,0 +1,30 @@
+from mewnala import *
+
+MODES = [BLEND, ADD, SUBTRACT, DARKEST, LIGHTEST, DIFFERENCE, EXCLUSION, MULTIPLY, SCREEN, REPLACE]
+index = 0
+
+def setup():
+    size(500, 500)
+
+def draw():
+    global index
+
+    if key_just_pressed(RIGHT_ARROW) or key_just_pressed(SPACE):
+        index = (index + 1) % len(MODES)
+    elif key_just_pressed(LEFT_ARROW):
+        index = (index - 1) % len(MODES)
+
+    background(38)
+    no_stroke()
+    blend_mode(MODES[index])
+
+    fill(230, 51, 51, 191)
+    rect(80, 100, 200, 250)
+
+    fill(51, 204, 51, 191)
+    rect(180, 80, 200, 250)
+
+    fill(51, 77, 230, 191)
+    rect(130, 200, 200, 200)
+
+run()

crates/processing_pyo3/src/graphics.rs

@@ -1,10 +1,7 @@
 use crate::color::{ColorMode, extract_color_with_mode};
-use crate::color::{ColorMode, extract_color_with_mode};
-use crate::glfw::GlfwContext;
 use crate::glfw::GlfwContext;
 use crate::input;
 use crate::math::{extract_vec2, extract_vec3, extract_vec4};
-use crate::math::{extract_vec2, extract_vec3, extract_vec4};
 use bevy::{
     color::{ColorToPacked, Srgba},
     math::Vec4,
@@ -18,9 +15,6 @@ use pyo3::{
     types::{PyDict, PyTuple},
 };
 
-use crate::glfw::GlfwContext;
-use crate::math::{extract_vec2, extract_vec3, extract_vec4};
-
 #[pyclass(name = "BlendMode")]
 #[derive(Clone)]
 pub struct PyBlendMode {
@@ -39,11 +33,6 @@ impl PyBlendMode {
 
 #[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(
@@ -53,13 +42,15 @@ impl PyBlendMode {
         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,
-            )),
+    ) -> PyResult<Self> {
+        let blend_state = custom_blend_state(
+            color_src, color_dst, color_op, alpha_src, alpha_dst, alpha_op,
+        )
+        .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+        Ok(Self {
+            blend_state: Some(blend_state),
             name: None,
-        }
+        })
     }
 
     fn __repr__(&self) -> String {
@@ -68,8 +59,41 @@ impl PyBlendMode {
             None => "BlendMode(custom)".to_string(),
         }
     }
-}
 
+    #[classattr]
+    const ZERO: u8 = 0;
+    #[classattr]
+    const ONE: u8 = 1;
+    #[classattr]
+    const SRC_COLOR: u8 = 2;
+    #[classattr]
+    const ONE_MINUS_SRC_COLOR: u8 = 3;
+    #[classattr]
+    const SRC_ALPHA: u8 = 4;
+    #[classattr]
+    const ONE_MINUS_SRC_ALPHA: u8 = 5;
+    #[classattr]
+    const DST_COLOR: u8 = 6;
+    #[classattr]
+    const ONE_MINUS_DST_COLOR: u8 = 7;
+    #[classattr]
+    const DST_ALPHA: u8 = 8;
+    #[classattr]
+    const ONE_MINUS_DST_ALPHA: u8 = 9;
+    #[classattr]
+    const SRC_ALPHA_SATURATED: u8 = 10;
+
+    #[classattr]
+    const OP_ADD: u8 = 0;
+    #[classattr]
+    const OP_SUBTRACT: u8 = 1;
+    #[classattr]
+    const OP_REVERSE_SUBTRACT: u8 = 2;
+    #[classattr]
+    const OP_MIN: u8 = 3;
+    #[classattr]
+    const OP_MAX: u8 = 4;
+}
 
 #[pyclass(unsendable)]
 pub struct Surface {

crates/processing_pyo3/src/input.rs

@@ -62,6 +62,12 @@ pub fn key_is_down(key_code: u32) -> PyResult<bool> {
     processing::prelude::input_key_is_down(kc).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
 }
 
+pub fn key_just_pressed(key_code: u32) -> PyResult<bool> {
+    let kc = u32_to_key_code(key_code)?;
+    processing::prelude::input_key_just_pressed(kc)
+        .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+}
+
 pub fn key() -> PyResult<Option<String>> {
     processing::prelude::input_key()
         .map(|opt| opt.map(String::from))

crates/processing_pyo3/src/lib.rs

@@ -345,43 +345,6 @@ 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;
@@ -1045,4 +1008,9 @@ mod mewnala {
     fn key_is_down(key_code: u32) -> PyResult<bool> {
         input::key_is_down(key_code)
     }
+
+    #[pyfunction]
+    fn key_just_pressed(key_code: u32) -> PyResult<bool> {
+        input::key_just_pressed(key_code)
+    }
 }

crates/processing_render/src/graphics.rs

@@ -132,7 +132,6 @@ impl ProcessingProjection {
 
 impl CameraProjection for ProcessingProjection {
     fn get_clip_from_view(&self) -> Mat4 {
-        // near/far swapped for Bevy's reverse-Z depth
         Mat4::orthographic_rh(
             0.0,
             self.width,

crates/processing_render/src/material/custom.rs

@@ -60,7 +60,7 @@ struct CustomMaterialKey {
     blend_state: Option<BlendState>,
 }
 
-fn custom_blend_specialize(
+fn specialize(
     key: &dyn Any,
     descriptor: &mut RenderPipelineDescriptor,
     _layout: &MeshVertexBufferLayoutRef,
@@ -432,7 +432,7 @@ impl ErasedRenderAsset for CustomMaterial {
             base_specialize: Some(base_specialize),
             material_layout: Some(bind_group_layout),
             material_key: ErasedMaterialKey::new(CustomMaterialKey { blend_state }),
-            user_specialize: Some(custom_blend_specialize),
+            user_specialize: Some(specialize),
             alpha_mode: if blend_state.is_some() {
                 AlphaMode::Blend
             } else {

crates/processing_render/src/material/mod.rs

@@ -11,7 +11,7 @@ use bevy::pbr::{
 use bevy::prelude::*;
 use bevy::render::render_resource::{AsBindGroup, BlendState};
 use bevy::shader::ShaderRef;
-use processing_core::error::ProcessingError;
+use processing_core::error::{self, ProcessingError};
 
 pub struct ProcessingMaterialPlugin;
 
@@ -70,7 +70,7 @@ pub fn set_property(
     material_handles: Query<&UntypedMaterial>,
     mut standard_materials: ResMut<Assets<StandardMaterial>>,
     mut custom_materials: ResMut<Assets<custom::CustomMaterial>>,
-) -> processing_core::error::Result<()> {
+) -> error::Result<()> {
     let untyped = material_handles
         .get(entity)
         .map_err(|_| ProcessingError::MaterialNotFound)?;
@@ -100,7 +100,7 @@ pub fn destroy(
     material_handles: Query<&UntypedMaterial>,
     mut standard_materials: ResMut<Assets<StandardMaterial>>,
     mut custom_materials: ResMut<Assets<custom::CustomMaterial>>,
-) -> processing_core::error::Result<()> {
+) -> error::Result<()> {
     let untyped = material_handles
         .get(entity)
         .map_err(|_| ProcessingError::MaterialNotFound)?;