Cleanup.

Author: tychedelia

crates/processing_ffi/src/lib.rs

@@ -1376,14 +1376,6 @@ pub extern "C" fn processing_text_leading(graphics_id: u64, leading: f32) {
     error::check(|| graphics_record_command(graphics_entity, DrawCommand::TextLeading(leading)));
 }
 
-/// Set the text direction. 0=AUTO, 1=LTR, 2=RTL
-#[unsafe(no_mangle)]
-pub extern "C" fn processing_text_direction(graphics_id: u64, dir: u8) {
-    error::clear_error();
-    let graphics_entity = Entity::from_bits(graphics_id);
-    error::check(|| graphics_text_direction(graphics_entity, dir));
-}
-
 /// Set the text wrap mode. 0=WORD, 1=CHAR
 #[unsafe(no_mangle)]
 pub extern "C" fn processing_text_wrap(graphics_id: u64, mode: u8) {

crates/processing_pyo3/src/graphics.rs

@@ -230,7 +230,9 @@ pub struct Font {
 
 #[pymethods]
 impl Font {
-    /// Query variable font axes. Returns list of dicts: {tag, min, max, default}.
+    /// Query variable font axes.
+    ///
+    /// Returns a list of `(tag, min, max, default)` tuples.
     pub fn variations(&self) -> PyResult<Vec<(String, f32, f32, f32)>> {
         font_variations(self.entity)
             .map(|axes| {
@@ -241,14 +243,46 @@ impl Font {
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
-    /// Query font metadata. Returns dict with family, style, weight, width, is_variable.
+    /// Query font metadata.
+    ///
+    /// Returns a `(family, style, weight, width, is_variable)` tuple.
     pub fn metadata(&self) -> PyResult<(String, String, f32, f32, bool)> {
         font_metadata(self.entity)
             .map(|m| (m.family, m.style, m.weight, m.width, m.is_variable))
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 }
 
+/// Convert glyph outline data into per-glyph (or per-contour) lists of Python
+/// tuples. Each command is a variable-length tuple tagged by a single letter:
+/// `("M", x, y)`, `("L", x, y)`, `("Q", cx, cy, x, y)`,
+/// `("C", cx1, cy1, cx2, cy2, x, y)`, or `("Z",)`.
+fn path_commands_to_py(
+    py: Python<'_>,
+    groups: Vec<Vec<processing_render::render::primitive::text::PathCommand>>,
+) -> Vec<Vec<Py<PyAny>>> {
+    use processing_render::render::primitive::text::PathCommand;
+
+    let to_py = |cmd: PathCommand| -> Py<PyAny> {
+        match cmd {
+            PathCommand::MoveTo(x, y) => ("M", x, y).into_pyobject(py).unwrap().into_any().unbind(),
+            PathCommand::LineTo(x, y) => ("L", x, y).into_pyobject(py).unwrap().into_any().unbind(),
+            PathCommand::QuadTo { cx, cy, x, y } => {
+                ("Q", cx, cy, x, y).into_pyobject(py).unwrap().into_any().unbind()
+            }
+            PathCommand::CubicTo { cx1, cy1, cx2, cy2, x, y } => {
+                ("C", cx1, cy1, cx2, cy2, x, y).into_pyobject(py).unwrap().into_any().unbind()
+            }
+            PathCommand::Close => ("Z",).into_pyobject(py).unwrap().into_any().unbind(),
+        }
+    };
+
+    groups
+        .into_iter()
+        .map(|group| group.into_iter().map(to_py).collect())
+        .collect()
+}
+
 #[pyclass]
 #[derive(Debug)]
 pub struct Image {
@@ -1081,60 +1115,23 @@ impl Graphics {
         x: f32,
         y: f32,
     ) -> PyResult<Vec<Vec<Py<PyAny>>>> {
-        use processing_render::render::primitive::text::PathCommand;
-
         let paths = graphics_text_to_paths(self.entity, content, x, y)
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
-
-        Python::attach(|py| {
-            Ok(paths
-                .into_iter()
-                .map(|glyph| {
-                    glyph
-                        .into_iter()
-                        .map(|cmd| match cmd {
-                            PathCommand::MoveTo(x, y) => ("M", x, y, 0.0, 0.0, 0.0, 0.0).into_pyobject(py).unwrap().into_any().unbind(),
-                            PathCommand::LineTo(x, y) => ("L", x, y, 0.0, 0.0, 0.0, 0.0).into_pyobject(py).unwrap().into_any().unbind(),
-                            PathCommand::QuadTo { cx, cy, x, y } => ("Q", cx, cy, x, y, 0.0, 0.0).into_pyobject(py).unwrap().into_any().unbind(),
-                            PathCommand::CubicTo { cx1, cy1, cx2, cy2, x, y } => ("C", cx1, cy1, cx2, cy2, x, y).into_pyobject(py).unwrap().into_any().unbind(),
-                            PathCommand::Close => ("Z", 0.0, 0.0, 0.0, 0.0, 0.0, 0.0).into_pyobject(py).unwrap().into_any().unbind(),
-                        })
-                        .collect()
-                })
-                .collect())
-        })
+        Python::attach(|py| Ok(path_commands_to_py(py, paths)))
     }
 
     /// Extract glyph outlines as per-contour path commands.
     /// Each contour (MoveTo...Close sequence) is a separate list.
+    /// Commands use the same tuple shapes as `text_to_paths`.
     pub fn text_to_contours(
         &self,
         content: &str,
         x: f32,
         y: f32,
     ) -> PyResult<Vec<Vec<Py<PyAny>>>> {
-        use processing_render::render::primitive::text::PathCommand;
-
         let contours = graphics_text_to_contours(self.entity, content, x, y)
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
-
-        Python::attach(|py| {
-            Ok(contours
-                .into_iter()
-                .map(|contour| {
-                    contour
-                        .into_iter()
-                        .map(|cmd| match cmd {
-                            PathCommand::MoveTo(x, y) => ("M", x, y, 0.0, 0.0, 0.0, 0.0).into_pyobject(py).unwrap().into_any().unbind(),
-                            PathCommand::LineTo(x, y) => ("L", x, y, 0.0, 0.0, 0.0, 0.0).into_pyobject(py).unwrap().into_any().unbind(),
-                            PathCommand::QuadTo { cx, cy, x, y } => ("Q", cx, cy, x, y, 0.0, 0.0).into_pyobject(py).unwrap().into_any().unbind(),
-                            PathCommand::CubicTo { cx1, cy1, cx2, cy2, x, y } => ("C", cx1, cy1, cx2, cy2, x, y).into_pyobject(py).unwrap().into_any().unbind(),
-                            PathCommand::Close => ("Z", 0.0, 0.0, 0.0, 0.0, 0.0, 0.0).into_pyobject(py).unwrap().into_any().unbind(),
-                        })
-                        .collect()
-                })
-                .collect())
-        })
+        Python::attach(|py| Ok(path_commands_to_py(py, contours)))
     }
 
     /// Sample points along text outlines.
@@ -1167,12 +1164,11 @@ impl Graphics {
     }
 
     /// Set per-glyph colors for the next text() call.
-    /// colors: list of (r, g, b) or (r, g, b, a) tuples with values 0-255.
-    pub fn text_glyph_colors(&self, colors: Vec<(f32, f32, f32, f32)>) -> PyResult<()> {
-        let colors: Vec<bevy::color::Color> = colors
-            .into_iter()
-            .map(|(r, g, b, a)| bevy::color::Color::srgba(r, g, b, a))
-            .collect();
+    ///
+    /// `colors` is a list of color objects (as built by `color(...)`); they are
+    /// cycled across the glyphs of the next `text()` call.
+    pub fn text_glyph_colors(&self, colors: Vec<PyRef<crate::color::PyColor>>) -> PyResult<()> {
+        let colors: Vec<bevy::color::Color> = colors.iter().map(|c| c.0).collect();
         graphics_text_glyph_colors(self.entity, colors)
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
@@ -1200,12 +1196,6 @@ impl Graphics {
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
-    /// Set text direction. 0=AUTO, 1=LTR, 2=RTL
-    pub fn text_direction(&self, dir: u8) -> PyResult<()> {
-        graphics_text_direction(self.entity, dir)
-            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
-    }
-
     pub fn text_wrap(&self, mode: u8) -> PyResult<()> {
         use processing::prelude::TextWrapMode;
         graphics_record_command(self.entity, DrawCommand::TextWrap(TextWrapMode::from(mode)))

crates/processing_render/src/graphics.rs

@@ -9,8 +9,7 @@ use bevy::{
         ImageRenderTarget, MsaaWriteback, Projection, RenderTarget, visibility::RenderLayers,
     },
     core_pipeline::tonemapping::Tonemapping,
-    post_process::bloom::Bloom,
-    ecs::{entity::EntityHashMap, query::QueryEntityError},
+    ecs::query::QueryEntityError,
     math::{Mat4, Vec3A},
     prelude::*,
     render::{
@@ -208,7 +207,7 @@ pub fn create(
             ..default()
         },
         target,
-        // tonemapping is conditionally set below based on HDR mode
+        // tonemapping prevents color accurate readback, so we disable it
         Tonemapping::None,
         // we need to be able to write to the texture
         CameraMainTextureUsages::default().with(TextureUsages::COPY_DST),
@@ -226,9 +225,9 @@ pub fn create(
         },
     ));
 
-    // enable Hdr, Bloom, and tonemapping for floating-point texture formats
+    // only enable Hdr for floating-point texture formats
     if is_hdr {
-        entity_commands.insert((Hdr, Bloom::NATURAL, Tonemapping::TonyMcMapface));
+        entity_commands.insert(Hdr);
     }
 
     let entity = entity_commands.id();