Add math module. (#91)

Author: tychedelia

crates/processing_ffi/src/lib.rs

@@ -1,4 +1,5 @@
 use bevy::{
+    math::{Vec2, Vec3, Vec4},
     prelude::Entity,
     render::render_resource::{Extent3d, TextureFormat},
 };
@@ -376,7 +377,9 @@ pub extern "C" fn processing_reset_matrix(graphics_id: u64) {
 pub extern "C" fn processing_translate(graphics_id: u64, x: f32, y: f32) {
     error::clear_error();
     let graphics_entity = Entity::from_bits(graphics_id);
-    error::check(|| graphics_record_command(graphics_entity, DrawCommand::Translate { x, y }));
+    error::check(|| {
+        graphics_record_command(graphics_entity, DrawCommand::Translate(Vec2::new(x, y)))
+    });
 }
 
 /// Rotate the coordinate system.
@@ -400,7 +403,7 @@ pub extern "C" fn processing_rotate(graphics_id: u64, angle: f32) {
 pub extern "C" fn processing_scale(graphics_id: u64, x: f32, y: f32) {
     error::clear_error();
     let graphics_entity = Entity::from_bits(graphics_id);
-    error::check(|| graphics_record_command(graphics_entity, DrawCommand::Scale { x, y }));
+    error::check(|| graphics_record_command(graphics_entity, DrawCommand::Scale(Vec2::new(x, y))));
 }
 
 /// Shear along the X axis.
@@ -625,21 +628,21 @@ pub extern "C" fn processing_ortho(
 pub extern "C" fn processing_transform_set_position(entity_id: u64, x: f32, y: f32, z: f32) {
     error::clear_error();
     let entity = Entity::from_bits(entity_id);
-    error::check(|| transform_set_position(entity, x, y, z));
+    error::check(|| transform_set_position(entity, Vec3::new(x, y, z)));
 }
 
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_transform_translate(entity_id: u64, x: f32, y: f32, z: f32) {
     error::clear_error();
     let entity = Entity::from_bits(entity_id);
-    error::check(|| transform_translate(entity, x, y, z));
+    error::check(|| transform_translate(entity, Vec3::new(x, y, z)));
 }
 
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_transform_set_rotation(entity_id: u64, x: f32, y: f32, z: f32) {
     error::clear_error();
     let entity = Entity::from_bits(entity_id);
-    error::check(|| transform_set_rotation(entity, x, y, z));
+    error::check(|| transform_set_rotation(entity, Vec3::new(x, y, z)));
 }
 
 #[unsafe(no_mangle)]
@@ -673,21 +676,21 @@ pub extern "C" fn processing_transform_rotate_axis(
 ) {
     error::clear_error();
     let entity = Entity::from_bits(entity_id);
-    error::check(|| transform_rotate_axis(entity, angle, axis_x, axis_y, axis_z));
+    error::check(|| transform_rotate_axis(entity, angle, Vec3::new(axis_x, axis_y, axis_z)));
 }
 
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_transform_set_scale(entity_id: u64, x: f32, y: f32, z: f32) {
     error::clear_error();
     let entity = Entity::from_bits(entity_id);
-    error::check(|| transform_set_scale(entity, x, y, z));
+    error::check(|| transform_set_scale(entity, Vec3::new(x, y, z)));
 }
 
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_transform_scale(entity_id: u64, x: f32, y: f32, z: f32) {
     error::clear_error();
     let entity = Entity::from_bits(entity_id);
-    error::check(|| transform_scale(entity, x, y, z));
+    error::check(|| transform_scale(entity, Vec3::new(x, y, z)));
 }
 
 #[unsafe(no_mangle)]
@@ -699,7 +702,7 @@ pub extern "C" fn processing_transform_look_at(
 ) {
     error::clear_error();
     let entity = Entity::from_bits(entity_id);
-    error::check(|| transform_look_at(entity, target_x, target_y, target_z));
+    error::check(|| transform_look_at(entity, Vec3::new(target_x, target_y, target_z)));
 }
 
 #[unsafe(no_mangle)]
@@ -808,14 +811,14 @@ pub extern "C" fn processing_geometry_create(topology: u8) -> u64 {
 pub extern "C" fn processing_geometry_normal(geo_id: u64, nx: f32, ny: f32, nz: f32) {
     error::clear_error();
     let entity = Entity::from_bits(geo_id);
-    error::check(|| geometry_normal(entity, nx, ny, nz));
+    error::check(|| geometry_normal(entity, Vec3::new(nx, ny, nz)));
 }
 
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_geometry_color(geo_id: u64, r: f32, g: f32, b: f32, a: f32) {
     error::clear_error();
     let entity = Entity::from_bits(geo_id);
-    error::check(|| geometry_color(entity, r, g, b, a));
+    error::check(|| geometry_color(entity, Vec4::new(r, g, b, a)));
 }
 
 #[unsafe(no_mangle)]
@@ -932,7 +935,7 @@ pub extern "C" fn processing_geometry_attribute_float4(
 pub extern "C" fn processing_geometry_vertex(geo_id: u64, x: f32, y: f32, z: f32) {
     error::clear_error();
     let entity = Entity::from_bits(geo_id);
-    error::check(|| geometry_vertex(entity, x, y, z));
+    error::check(|| geometry_vertex(entity, Vec3::new(x, y, z)));
 }
 
 #[unsafe(no_mangle)]
@@ -1075,7 +1078,7 @@ pub unsafe extern "C" fn processing_geometry_get_indices(
 pub extern "C" fn processing_geometry_set_vertex(geo_id: u64, index: u32, x: f32, y: f32, z: f32) {
     error::clear_error();
     let entity = Entity::from_bits(geo_id);
-    error::check(|| geometry_set_vertex(entity, index, x, y, z));
+    error::check(|| geometry_set_vertex(entity, index, Vec3::new(x, y, z)));
 }
 
 #[unsafe(no_mangle)]
@@ -1088,7 +1091,7 @@ pub extern "C" fn processing_geometry_set_normal(
 ) {
     error::clear_error();
     let entity = Entity::from_bits(geo_id);
-    error::check(|| geometry_set_normal(entity, index, nx, ny, nz));
+    error::check(|| geometry_set_normal(entity, index, Vec3::new(nx, ny, nz)));
 }
 
 #[unsafe(no_mangle)]
@@ -1102,14 +1105,14 @@ pub extern "C" fn processing_geometry_set_color(
 ) {
     error::clear_error();
     let entity = Entity::from_bits(geo_id);
-    error::check(|| geometry_set_color(entity, index, r, g, b, a));
+    error::check(|| geometry_set_color(entity, index, Vec4::new(r, g, b, a)));
 }
 
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_geometry_set_uv(geo_id: u64, index: u32, u: f32, v: f32) {
     error::clear_error();
     let entity = Entity::from_bits(geo_id);
-    error::check(|| geometry_set_uv(entity, index, u, v));
+    error::check(|| geometry_set_uv(entity, index, Vec2::new(u, v)));
 }
 
 #[unsafe(no_mangle)]

crates/processing_pyo3/src/graphics.rs

@@ -5,9 +5,14 @@ use bevy::{
     render::render_resource::TextureFormat,
 };
 use processing::prelude::*;
-use pyo3::{exceptions::PyRuntimeError, prelude::*, types::PyDict};
+use pyo3::{
+    exceptions::PyRuntimeError,
+    prelude::*,
+    types::{PyDict, PyTuple},
+};
 
 use crate::glfw::GlfwContext;
+use crate::math::{extract_vec2, extract_vec3, extract_vec4};
 
 #[pyclass(unsendable)]
 pub struct Surface {
@@ -39,13 +44,16 @@ pub struct Light {
 
 #[pymethods]
 impl Light {
-    pub fn position(&self, x: f32, y: f32, z: f32) -> PyResult<()> {
-        transform_set_position(self.entity, x, y, z)
-            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    #[pyo3(signature = (*args))]
+    pub fn position(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
+        let v = extract_vec3(args)?;
+        transform_set_position(self.entity, v).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
-    pub fn look_at(&self, x: f32, y: f32, z: f32) -> PyResult<()> {
-        transform_look_at(self.entity, x, y, z).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    #[pyo3(signature = (*args))]
+    pub fn look_at(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
+        let v = extract_vec3(args)?;
+        transform_look_at(self.entity, v).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 }
 
@@ -122,26 +130,32 @@ impl Geometry {
         Ok(Self { entity: geometry })
     }
 
-    pub fn color(&self, r: f32, g: f32, b: f32, a: f32) -> PyResult<()> {
-        geometry_color(self.entity, r, g, b, a).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    #[pyo3(signature = (*args))]
+    pub fn color(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
+        let v = extract_vec4(args)?;
+        geometry_color(self.entity, v).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
-    pub fn normal(&self, nx: f32, ny: f32, nz: f32) -> PyResult<()> {
-        geometry_normal(self.entity, nx, ny, nz)
-            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    #[pyo3(signature = (*args))]
+    pub fn normal(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
+        let v = extract_vec3(args)?;
+        geometry_normal(self.entity, v).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
-    pub fn vertex(&self, x: f32, y: f32, z: f32) -> PyResult<()> {
-        geometry_vertex(self.entity, x, y, z).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    #[pyo3(signature = (*args))]
+    pub fn vertex(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
+        let v = extract_vec3(args)?;
+        geometry_vertex(self.entity, v).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
     pub fn index(&self, i: u32) -> PyResult<()> {
         geometry_index(self.entity, i).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
-    pub fn set_vertex(&self, i: u32, x: f32, y: f32, z: f32) -> PyResult<()> {
-        geometry_set_vertex(self.entity, i, x, y, z)
-            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    #[pyo3(signature = (i, *args))]
+    pub fn set_vertex(&self, i: u32, args: &Bound<'_, PyTuple>) -> PyResult<()> {
+        let v = extract_vec3(args)?;
+        geometry_set_vertex(self.entity, i, v).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 }
 
@@ -388,8 +402,10 @@ impl Graphics {
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
-    pub fn translate(&self, x: f32, y: f32) -> PyResult<()> {
-        graphics_record_command(self.entity, DrawCommand::Translate { x, y })
+    #[pyo3(signature = (*args))]
+    pub fn translate(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
+        let v = extract_vec2(args)?;
+        graphics_record_command(self.entity, DrawCommand::Translate(v))
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
@@ -454,8 +470,10 @@ impl Graphics {
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
-    pub fn scale(&self, x: f32, y: f32) -> PyResult<()> {
-        graphics_record_command(self.entity, DrawCommand::Scale { x, y })
+    #[pyo3(signature = (*args))]
+    pub fn scale(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
+        let v = extract_vec2(args)?;
+        graphics_record_command(self.entity, DrawCommand::Scale(v))
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
@@ -494,14 +512,16 @@ impl Graphics {
         graphics_mode_2d(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
-    pub fn camera_position(&self, x: f32, y: f32, z: f32) -> PyResult<()> {
-        transform_set_position(self.entity, x, y, z)
-            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    #[pyo3(signature = (*args))]
+    pub fn camera_position(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
+        let v = extract_vec3(args)?;
+        transform_set_position(self.entity, v).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
-    pub fn camera_look_at(&self, target_x: f32, target_y: f32, target_z: f32) -> PyResult<()> {
-        transform_look_at(self.entity, target_x, target_y, target_z)
-            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    #[pyo3(signature = (*args))]
+    pub fn camera_look_at(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
+        let v = extract_vec3(args)?;
+        transform_look_at(self.entity, v).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
     pub fn perspective(&self, fov: f32, aspect: f32, near: f32, far: f32) -> PyResult<()> {

crates/processing_pyo3/src/lib.rs

@@ -12,6 +12,7 @@ mod glfw;
 mod gltf;
 mod graphics;
 pub(crate) mod material;
+pub(crate) mod math;
 mod midi;
 pub(crate) mod shader;
 #[cfg(feature = "webcam")]
@@ -139,6 +140,46 @@ mod mewnala {
     #[pymodule_export]
     const BEVEL: u8 = 2;
 
+    #[pymodule]
+    mod math {
+        use super::*;
+
+        #[pymodule_export]
+        use crate::math::PyQuat;
+        #[pymodule_export]
+        use crate::math::PyVec2;
+        #[pymodule_export]
+        use crate::math::PyVec3;
+        #[pymodule_export]
+        use crate::math::PyVec4;
+        #[pymodule_export]
+        use crate::math::PyVecIter;
+
+        #[pyfunction]
+        #[pyo3(signature = (*args))]
+        fn vec2(args: &Bound<'_, PyTuple>) -> PyResult<crate::math::PyVec2> {
+            crate::math::PyVec2::py_new(args)
+        }
+
+        #[pyfunction]
+        #[pyo3(signature = (*args))]
+        fn vec3(args: &Bound<'_, PyTuple>) -> PyResult<crate::math::PyVec3> {
+            crate::math::PyVec3::py_new(args)
+        }
+
+        #[pyfunction]
+        #[pyo3(signature = (*args))]
+        fn vec4(args: &Bound<'_, PyTuple>) -> PyResult<crate::math::PyVec4> {
+            crate::math::PyVec4::py_new(args)
+        }
+
+        #[pyfunction]
+        #[pyo3(signature = (*args))]
+        fn quat(args: &Bound<'_, PyTuple>) -> PyResult<crate::math::PyQuat> {
+            crate::math::PyQuat::py_new(args)
+        }
+    }
+
     #[cfg(feature = "webcam")]
     #[pymodule_export]
     use super::webcam::Webcam;
@@ -352,20 +393,15 @@ mod mewnala {
     }
 
     #[pyfunction]
-    #[pyo3(pass_module)]
-    fn camera_position(module: &Bound<'_, PyModule>, x: f32, y: f32, z: f32) -> PyResult<()> {
-        graphics!(module).camera_position(x, y, z)
+    #[pyo3(pass_module, signature = (*args))]
+    fn camera_position(module: &Bound<'_, PyModule>, args: &Bound<'_, PyTuple>) -> PyResult<()> {
+        graphics!(module).camera_position(args)
     }
 
     #[pyfunction]
-    #[pyo3(pass_module)]
-    fn camera_look_at(
-        module: &Bound<'_, PyModule>,
-        target_x: f32,
-        target_y: f32,
-        target_z: f32,
-    ) -> PyResult<()> {
-        graphics!(module).camera_look_at(target_x, target_y, target_z)
+    #[pyo3(pass_module, signature = (*args))]
+    fn camera_look_at(module: &Bound<'_, PyModule>, args: &Bound<'_, PyTuple>) -> PyResult<()> {
+        graphics!(module).camera_look_at(args)
     }
 
     #[pyfunction]

crates/processing_pyo3/src/material.rs

@@ -3,6 +3,7 @@ use processing::prelude::*;
 use pyo3::types::PyDict;
 use pyo3::{exceptions::PyRuntimeError, prelude::*};
 
+use crate::math::{PyVec2, PyVec3, PyVec4};
 use crate::shader::Shader;
 
 #[pyclass(unsendable)]
@@ -18,6 +19,18 @@ fn py_to_material_value(value: &Bound<'_, PyAny>) -> PyResult<material::Material
         return Ok(material::MaterialValue::Int(v));
     }
 
+    // Accept PyVec types
+    if let Ok(v) = value.extract::<PyRef<PyVec4>>() {
+        return Ok(material::MaterialValue::Float4(v.0.to_array()));
+    }
+    if let Ok(v) = value.extract::<PyRef<PyVec3>>() {
+        return Ok(material::MaterialValue::Float3(v.0.to_array()));
+    }
+    if let Ok(v) = value.extract::<PyRef<PyVec2>>() {
+        return Ok(material::MaterialValue::Float2(v.0.to_array()));
+    }
+
+    // Fall back to raw arrays
     if let Ok(v) = value.extract::<[f32; 4]>() {
         return Ok(material::MaterialValue::Float4(v));
     }