Transform stack

Author: tychedelia

Cargo.toml

@@ -46,6 +46,10 @@ path = "examples/background_image.rs"
 name = "update_pixels"
 path = "examples/update_pixels.rs"
 
+[[example]]
+name = "transforms"
+path = "examples/transforms.rs"
+
 [profile.wasm-release]
 inherits = "release"
 opt-level = "z"

crates/processing_ffi/src/lib.rs

@@ -211,6 +211,110 @@ pub extern "C" fn processing_no_stroke(window_id: u64) {
     error::check(|| graphics_record_command(window_entity, DrawCommand::NoStroke));
 }
 
+/// Push the current transformation matrix onto the stack.
+///
+/// SAFETY:
+/// - Init and surface_create have been called.
+/// - window_id is a valid ID returned from surface_create.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_push_matrix(window_id: u64) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    error::check(|| graphics_record_command(window_entity, DrawCommand::PushMatrix));
+}
+
+/// Pop the transformation matrix from the stack.
+///
+/// SAFETY:
+/// - Init and surface_create have been called.
+/// - window_id is a valid ID returned from surface_create.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_pop_matrix(window_id: u64) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    error::check(|| graphics_record_command(window_entity, DrawCommand::PopMatrix));
+}
+
+/// Reset the transformation matrix to identity.
+///
+/// SAFETY:
+/// - Init and surface_create have been called.
+/// - window_id is a valid ID returned from surface_create.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_reset_matrix(window_id: u64) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    error::check(|| graphics_record_command(window_entity, DrawCommand::ResetMatrix));
+}
+
+/// Translate the coordinate system.
+///
+/// SAFETY:
+/// - Init and surface_create have been called.
+/// - window_id is a valid ID returned from surface_create.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_translate(window_id: u64, x: f32, y: f32) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    error::check(|| graphics_record_command(window_entity, DrawCommand::Translate { x, y }));
+}
+
+/// Rotate the coordinate system.
+///
+/// SAFETY:
+/// - Init and surface_create have been called.
+/// - window_id is a valid ID returned from surface_create.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_rotate(window_id: u64, angle: f32) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    error::check(|| graphics_record_command(window_entity, DrawCommand::Rotate { angle }));
+}
+
+/// Scale the coordinate system.
+///
+/// SAFETY:
+/// - Init and surface_create have been called.
+/// - window_id is a valid ID returned from surface_create.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_scale(window_id: u64, x: f32, y: f32) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    error::check(|| graphics_record_command(window_entity, DrawCommand::Scale { x, y }));
+}
+
+/// Shear along the X axis.
+///
+/// SAFETY:
+/// - Init and surface_create have been called.
+/// - window_id is a valid ID returned from surface_create.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_shear_x(window_id: u64, angle: f32) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    error::check(|| graphics_record_command(window_entity, DrawCommand::ShearX { angle }));
+}
+
+/// Shear along the Y axis.
+///
+/// SAFETY:
+/// - Init and surface_create have been called.
+/// - window_id is a valid ID returned from surface_create.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_shear_y(window_id: u64, angle: f32) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    error::check(|| graphics_record_command(window_entity, DrawCommand::ShearY { angle }));
+}
+
 /// Draw a rectangle.
 ///
 /// SAFETY:

crates/processing_pyo3/src/graphics.rs

@@ -123,6 +123,46 @@ impl Graphics {
         .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
+    pub fn push_matrix(&self) -> PyResult<()> {
+        graphics_record_command(self.entity, DrawCommand::PushMatrix)
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn pop_matrix(&self) -> PyResult<()> {
+        graphics_record_command(self.entity, DrawCommand::PopMatrix)
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn reset_matrix(&self) -> PyResult<()> {
+        graphics_record_command(self.entity, DrawCommand::ResetMatrix)
+            .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 })
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn rotate(&self, angle: f32) -> PyResult<()> {
+        graphics_record_command(self.entity, DrawCommand::Rotate { angle })
+            .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 })
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn shear_x(&self, angle: f32) -> PyResult<()> {
+        graphics_record_command(self.entity, DrawCommand::ShearX { angle })
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn shear_y(&self, angle: f32) -> PyResult<()> {
+        graphics_record_command(self.entity, DrawCommand::ShearY { angle })
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
     pub fn begin_draw(&self) -> PyResult<()> {
         graphics_begin_draw(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }

crates/processing_render/src/render/command.rs

@@ -16,6 +16,14 @@ pub enum DrawCommand {
         h: f32,
         radii: [f32; 4], // [tl, tr, br, bl]
     },
+    PushMatrix,
+    PopMatrix,
+    ResetMatrix,
+    Translate { x: f32, y: f32 },
+    Rotate { angle: f32 },
+    Scale { x: f32, y: f32 },
+    ShearX { angle: f32 },
+    ShearY { angle: f32 },
 }
 
 #[derive(Debug, Default, Component)]

crates/processing_render/src/render/mod.rs

@@ -2,11 +2,13 @@ pub mod command;
 pub mod material;
 pub mod mesh_builder;
 pub mod primitive;
+pub mod transform;
 
-use bevy::{camera::visibility::RenderLayers, ecs::system::SystemParam, prelude::*};
+use bevy::{camera::visibility::RenderLayers, ecs::system::SystemParam, math::Affine3A, prelude::*};
 use command::{CommandBuffer, DrawCommand};
 use material::MaterialKey;
 use primitive::{TessellationMode, empty_mesh};
+use transform::TransformStack;
 
 use crate::{Flush, graphics::SurfaceSize, image::Image, render::primitive::rect};
 
@@ -27,21 +29,36 @@ pub struct RenderContext<'w, 's> {
     state: Local<'s, RenderState>,
 }
 
-#[derive(Default)]
 struct BatchState {
     current_mesh: Option<Mesh>,
     material_key: Option<MaterialKey>,
+    transform: Affine3A,
     draw_index: u32,
     render_layers: RenderLayers,
     graphics_entity: Option<Entity>,
 }
 
+impl Default for BatchState {
+    fn default() -> Self {
+        Self {
+            current_mesh: None,
+            material_key: None,
+            transform: Affine3A::IDENTITY,
+            draw_index: 0,
+            render_layers: RenderLayers::default(),
+            graphics_entity: None,
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct RenderState {
     // drawing state
     pub fill_color: Option<Color>,
     pub stroke_color: Option<Color>,
     pub stroke_weight: f32,
+    // transform state
+    pub transform: TransformStack,
 }
 
 impl Default for RenderState {
@@ -50,6 +67,7 @@ impl Default for RenderState {
             fill_color: Some(Color::WHITE),
             stroke_color: Some(Color::BLACK),
             stroke_weight: 1.0,
+            transform: TransformStack::new(),
         }
     }
 }
@@ -172,6 +190,26 @@ pub fn flush_draw_commands(
 
                     flush_batch(&mut ctx);
                 }
+                DrawCommand::PushMatrix => ctx.state.transform.push(),
+                DrawCommand::PopMatrix => ctx.state.transform.pop(),
+                DrawCommand::ResetMatrix => {
+                    ctx.state.transform.reset();
+                }
+                DrawCommand::Translate { x, y } => {
+                    ctx.state.transform.translate(x, y);
+                }
+                DrawCommand::Rotate { angle } => {
+                    ctx.state.transform.rotate(angle);
+                }
+                DrawCommand::Scale { x, y } => {
+                    ctx.state.transform.scale(x, y);
+                }
+                DrawCommand::ShearX { angle } => {
+                    ctx.state.transform.shear_x(angle);
+                }
+                DrawCommand::ShearY { angle } => {
+                    ctx.state.transform.shear_y(angle);
+                }
             }
         }
 
@@ -207,15 +245,38 @@ fn spawn_mesh(ctx: &mut RenderContext, mesh: Mesh, z_offset: f32) {
     let mesh_handle = ctx.meshes.add(mesh);
     let material_handle = ctx.materials.add(material_key.to_material());
 
+    let (scale, rotation, translation) = ctx.batch.transform.to_scale_rotation_translation();
+    let transform = Transform {
+        translation: translation + Vec3::new(0.0, 0.0, z_offset),
+        rotation,
+        scale,
+    };
+
     ctx.commands.spawn((
         Mesh3d(mesh_handle),
         MeshMaterial3d(material_handle),
         BelongsToGraphics(surface_entity),
-        Transform::from_xyz(0.0, 0.0, z_offset),
+        transform,
         ctx.batch.render_layers.clone(),
     ));
 }
 
+fn maybe_start_batch(ctx: &mut RenderContext, material_key: MaterialKey) -> bool {
+    let current_transform = ctx.state.transform.current();
+    let material_changed = ctx.batch.material_key.as_ref() != Some(&material_key);
+    let transform_changed = ctx.batch.transform != current_transform;
+
+    if material_changed || transform_changed {
+        flush_batch(ctx);
+        ctx.batch.material_key = Some(material_key);
+        ctx.batch.transform = current_transform;
+        ctx.batch.current_mesh = Some(empty_mesh());
+        true
+    } else {
+        false
+    }
+}
+
 fn add_fill(ctx: &mut RenderContext, tessellate: impl FnOnce(&mut Mesh, Color)) {
     let Some(color) = ctx.state.fill_color else {
         return;
@@ -225,12 +286,7 @@ fn add_fill(ctx: &mut RenderContext, tessellate: impl FnOnce(&mut Mesh, Color))
         background_image: None,
     };
 
-    // when the material changes, flush the current batch
-    if ctx.batch.material_key.as_ref() != Some(&material_key) {
-        flush_batch(ctx);
-        ctx.batch.material_key = Some(material_key);
-        ctx.batch.current_mesh = Some(empty_mesh());
-    }
+    maybe_start_batch(ctx, material_key);
 
     // accumulate geometry into the current mega mesh
     if let Some(ref mut mesh) = ctx.batch.current_mesh {
@@ -248,12 +304,7 @@ fn add_stroke(ctx: &mut RenderContext, tessellate: impl FnOnce(&mut Mesh, Color,
         background_image: None,
     };
 
-    // when the material changes, flush the current batch
-    if ctx.batch.material_key.as_ref() != Some(&material_key) {
-        flush_batch(ctx);
-        ctx.batch.material_key = Some(material_key);
-        ctx.batch.current_mesh = Some(empty_mesh());
-    }
+    maybe_start_batch(ctx, material_key);
 
     // accumulate geometry into the current mega mesh
     if let Some(ref mut mesh) = ctx.batch.current_mesh {