Add math module.

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/gltf.rs

@@ -48,4 +48,3 @@ impl Gltf {
         Ok(Light { entity })
     }
 }
-

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<()> {