Clean imports.

Author: tychedelia

crates/processing_ffi/src/lib.rs

@@ -378,10 +378,7 @@ 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(bevy::math::Vec2::new(x, y)),
-        )
+        graphics_record_command(graphics_entity, DrawCommand::Translate(Vec2::new(x, y)))
     });
 }
 
@@ -406,12 +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(bevy::math::Vec2::new(x, y)),
-        )
-    });
+    error::check(|| graphics_record_command(graphics_entity, DrawCommand::Scale(Vec2::new(x, y))));
 }
 
 /// Shear along the X axis.

crates/processing_pyo3/src/graphics.rs

@@ -12,6 +12,7 @@ use pyo3::{
 };
 
 use crate::glfw::GlfwContext;
+use crate::math::{extract_vec2, extract_vec3, extract_vec4};
 
 #[pyclass(unsendable)]
 pub struct Surface {
@@ -45,13 +46,13 @@ pub struct Light {
 impl Light {
     #[pyo3(signature = (*args))]
     pub fn position(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
-        let v = crate::math::extract_vec3(args)?;
+        let v = extract_vec3(args)?;
         transform_set_position(self.entity, v).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
     #[pyo3(signature = (*args))]
     pub fn look_at(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
-        let v = crate::math::extract_vec3(args)?;
+        let v = extract_vec3(args)?;
         transform_look_at(self.entity, v).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 }
@@ -131,19 +132,19 @@ impl Geometry {
 
     #[pyo3(signature = (*args))]
     pub fn color(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
-        let v = crate::math::extract_vec4(args)?;
+        let v = extract_vec4(args)?;
         geometry_color(self.entity, v).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
     #[pyo3(signature = (*args))]
     pub fn normal(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
-        let v = crate::math::extract_vec3(args)?;
+        let v = extract_vec3(args)?;
         geometry_normal(self.entity, v).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
     #[pyo3(signature = (*args))]
     pub fn vertex(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
-        let v = crate::math::extract_vec3(args)?;
+        let v = extract_vec3(args)?;
         geometry_vertex(self.entity, v).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
@@ -153,7 +154,7 @@ impl Geometry {
 
     #[pyo3(signature = (i, *args))]
     pub fn set_vertex(&self, i: u32, args: &Bound<'_, PyTuple>) -> PyResult<()> {
-        let v = crate::math::extract_vec3(args)?;
+        let v = extract_vec3(args)?;
         geometry_set_vertex(self.entity, i, v).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 }
@@ -403,7 +404,7 @@ impl Graphics {
 
     #[pyo3(signature = (*args))]
     pub fn translate(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
-        let v = crate::math::extract_vec2(args)?;
+        let v = extract_vec2(args)?;
         graphics_record_command(self.entity, DrawCommand::Translate(v))
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
@@ -471,7 +472,7 @@ impl Graphics {
 
     #[pyo3(signature = (*args))]
     pub fn scale(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
-        let v = crate::math::extract_vec2(args)?;
+        let v = extract_vec2(args)?;
         graphics_record_command(self.entity, DrawCommand::Scale(v))
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
@@ -513,13 +514,13 @@ impl Graphics {
 
     #[pyo3(signature = (*args))]
     pub fn camera_position(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
-        let v = crate::math::extract_vec3(args)?;
+        let v = extract_vec3(args)?;
         transform_set_position(self.entity, v).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
     #[pyo3(signature = (*args))]
     pub fn camera_look_at(&self, args: &Bound<'_, PyTuple>) -> PyResult<()> {
-        let v = crate::math::extract_vec3(args)?;
+        let v = extract_vec3(args)?;
         transform_look_at(self.entity, v).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 

crates/processing_pyo3/src/lib.rs

@@ -145,38 +145,38 @@ mod mewnala {
         use super::*;
 
         #[pymodule_export]
-        use super::super::math::PyQuat;
+        use crate::math::PyQuat;
         #[pymodule_export]
-        use super::super::math::PyVec2;
+        use crate::math::PyVec2;
         #[pymodule_export]
-        use super::super::math::PyVec3;
+        use crate::math::PyVec3;
         #[pymodule_export]
-        use super::super::math::PyVec4;
+        use crate::math::PyVec4;
         #[pymodule_export]
-        use super::super::math::PyVecIter;
+        use crate::math::PyVecIter;
 
         #[pyfunction]
         #[pyo3(signature = (*args))]
-        fn vec2(args: &Bound<'_, PyTuple>) -> PyResult<super::super::math::PyVec2> {
-            super::super::math::PyVec2::py_new(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<super::super::math::PyVec3> {
-            super::super::math::PyVec3::py_new(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<super::super::math::PyVec4> {
-            super::super::math::PyVec4::py_new(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<super::super::math::PyQuat> {
-            super::super::math::PyQuat::py_new(args)
+        fn quat(args: &Bound<'_, PyTuple>) -> PyResult<crate::math::PyQuat> {
+            crate::math::PyQuat::py_new(args)
         }
     }
 

crates/processing_render/src/surface.rs

@@ -32,6 +32,7 @@ use raw_window_handle::{
 };
 
 use processing_core::error::{self, ProcessingError, Result};
+#[cfg(not(target_os = "windows"))]
 use std::ptr::NonNull;
 
 use crate::image::{Image, ImageTextures};

crates/processing_wasm/src/lib.rs

@@ -1,6 +1,9 @@
 #![cfg(target_arch = "wasm32")]
 
-use bevy::prelude::Entity;
+use bevy::{
+    math::{Vec2, Vec3},
+    prelude::Entity,
+};
 use processing_render::{
     config::Config, exit, geometry_box, geometry_sphere, graphics_begin_draw, graphics_end_draw,
     graphics_flush, graphics_record_command, image_create, image_destroy, image_load,
@@ -191,7 +194,7 @@ pub fn js_reset_matrix(surface_id: u64) -> Result<(), JsValue> {
 pub fn js_translate(surface_id: u64, x: f32, y: f32) -> Result<(), JsValue> {
     check(graphics_record_command(
         Entity::from_bits(surface_id),
-        DrawCommand::Translate(bevy::math::Vec2::new(x, y)),
+        DrawCommand::Translate(Vec2::new(x, y)),
     ))
 }
 
@@ -207,7 +210,7 @@ pub fn js_rotate(surface_id: u64, angle: f32) -> Result<(), JsValue> {
 pub fn js_scale(surface_id: u64, x: f32, y: f32) -> Result<(), JsValue> {
     check(graphics_record_command(
         Entity::from_bits(surface_id),
-        DrawCommand::Scale(bevy::math::Vec2::new(x, y)),
+        DrawCommand::Scale(Vec2::new(x, y)),
     ))
 }
 
@@ -279,23 +282,23 @@ pub fn js_image_destroy(image_id: u64) -> Result<(), JsValue> {
 pub fn js_transform_set_position(entity_id: u64, x: f32, y: f32, z: f32) -> Result<(), JsValue> {
     check(transform_set_position(
         Entity::from_bits(entity_id),
-        bevy::math::Vec3::new(x, y, z),
+        Vec3::new(x, y, z),
     ))
 }
 
 #[wasm_bindgen(js_name = "transformTranslate")]
 pub fn js_transform_translate(entity_id: u64, x: f32, y: f32, z: f32) -> Result<(), JsValue> {
     check(transform_translate(
         Entity::from_bits(entity_id),
-        bevy::math::Vec3::new(x, y, z),
+        Vec3::new(x, y, z),
     ))
 }
 
 #[wasm_bindgen(js_name = "transformSetRotation")]
 pub fn js_transform_set_rotation(entity_id: u64, x: f32, y: f32, z: f32) -> Result<(), JsValue> {
     check(transform_set_rotation(
         Entity::from_bits(entity_id),
-        bevy::math::Vec3::new(x, y, z),
+        Vec3::new(x, y, z),
     ))
 }
 
@@ -325,23 +328,23 @@ pub fn js_transform_rotate_axis(
     check(transform_rotate_axis(
         Entity::from_bits(entity_id),
         angle,
-        bevy::math::Vec3::new(axis_x, axis_y, axis_z),
+        Vec3::new(axis_x, axis_y, axis_z),
     ))
 }
 
 #[wasm_bindgen(js_name = "transformSetScale")]
 pub fn js_transform_set_scale(entity_id: u64, x: f32, y: f32, z: f32) -> Result<(), JsValue> {
     check(transform_set_scale(
         Entity::from_bits(entity_id),
-        bevy::math::Vec3::new(x, y, z),
+        Vec3::new(x, y, z),
     ))
 }
 
 #[wasm_bindgen(js_name = "transformScale")]
 pub fn js_transform_scale(entity_id: u64, x: f32, y: f32, z: f32) -> Result<(), JsValue> {
     check(transform_scale(
         Entity::from_bits(entity_id),
-        bevy::math::Vec3::new(x, y, z),
+        Vec3::new(x, y, z),
     ))
 }
 
@@ -354,7 +357,7 @@ pub fn js_transform_look_at(
 ) -> Result<(), JsValue> {
     check(transform_look_at(
         Entity::from_bits(entity_id),
-        bevy::math::Vec3::new(target_x, target_y, target_z),
+        Vec3::new(target_x, target_y, target_z),
     ))
 }