codimate 0.1.1__tar.gz → 0.1.3__tar.gz

{codimate-0.1.1 → codimate-0.1.3}/Cargo.lock

@@ -211,12 +211,13 @@ version = "0.1.0"
 dependencies = [
  "codimate-core",
  "mitex",
+ "roxmltree",
  "usvg",
 ]
 
 [[package]]
 name = "codimate-py"
-version = "0.1.1"
+version = "0.1.3"
 dependencies = [
  "codimate-animation",
  "codimate-core",
@@ -235,6 +236,8 @@ dependencies = [
  "codimate-core",
  "codimate-math",
  "codimate-render",
+ "jpeg-decoder",
+ "png",
 ]
 
 [[package]]
@@ -585,6 +588,15 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
+[[package]]
+name = "jpeg-decoder"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00810f1d8b74be64b13dbf3db89ac67740615d6c891f0e7b6179326533011a07"
+dependencies = [
+ "rayon",
+]
+
 [[package]]
 name = "jpeg-encoder"
 version = "0.6.1"

{codimate-0.1.1 → codimate-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codimate
-Version: 0.1.1
+Version: 0.1.3
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Multimedia :: Video
@@ -182,6 +182,8 @@ scene.circle(name, r=, at=)
 scene.text(name, content, size=, at=)
 scene.polygon(name, points)                             # cm.ngon, cm.star
 scene.curve(name, points, w=)                           # smooth, through the points
+scene.svg(name, "logo.svg", size=)                       # vector art, as real geometry
+scene.image(name, "photo.jpg", size=)                    # a picture: PNG or JPEG
 scene.line(name, start=slot_or_point, end=slot_or_point, w=)
 scene.formula(name, r"\frac{a}{b}", size=, at=)         # LaTeX, needs `typst`
 cm.measure(text, size) -> (w, h)                        # to size a box around text

{codimate-0.1.1 → codimate-0.1.3}/README.md

@@ -170,6 +170,8 @@ scene.circle(name, r=, at=)
 scene.text(name, content, size=, at=)
 scene.polygon(name, points)                             # cm.ngon, cm.star
 scene.curve(name, points, w=)                           # smooth, through the points
+scene.svg(name, "logo.svg", size=)                       # vector art, as real geometry
+scene.image(name, "photo.jpg", size=)                    # a picture: PNG or JPEG
 scene.line(name, start=slot_or_point, end=slot_or_point, w=)
 scene.formula(name, r"\frac{a}{b}", size=, at=)         # LaTeX, needs `typst`
 cm.measure(text, size) -> (w, h)                        # to size a box around text

{codimate-0.1.1 → codimate-0.1.3}/crates/codimate-core/src/scene/mod.rs

@@ -27,7 +27,7 @@ pub use connection::{connection, Connection};
 pub use path::{path_node, ConcretePath, PathNode};
 pub use primitive::{
     primitive_circle, primitive_path, primitive_rect, primitive_text, ConcreteGeometry,
-    ConcretePrimitive, Geometry, Primitive, Transformable,
+    ConcretePrimitive, Geometry, Pixels, Primitive, Transformable,
 };
 pub use pulse::{pulse_on, Pulse};
 pub use rect::{rect, ConcreteRect, Rect};

{codimate-0.1.1 → codimate-0.1.3}/crates/codimate-core/src/scene/primitive.rs

@@ -34,6 +34,36 @@ pub enum Geometry {
         font_size: Animated<f32>,
         align: TextAlign,
     },
+    /// A decoded raster picture, drawn into a box (ADR 0013).
+    ///
+    /// The pixels are shared rather than owned: a 1,200-frame render resolves
+    /// this once per frame, and copying a megabyte each time would be the
+    /// whole cost of the feature.
+    Image {
+        pixels: std::sync::Arc<Pixels>,
+        width: Animated<f32>,
+        height: Animated<f32>,
+    },
+}
+
+/// Decoded pixels: premultiplied RGBA, ready to blit.
+///
+/// Core does no decoding — it would need a codec and an opinion about file
+/// formats, and neither belongs in the layer that owns no I/O. Something
+/// upstream hands these over already decoded.
+#[derive(Clone, PartialEq)]
+pub struct Pixels {
+    pub width: u32,
+    pub height: u32,
+    pub rgba: Vec<u8>,
+}
+
+// Dimensions only. The derived version would print several megabytes of
+// channel bytes the first time anyone put a Scene in a debug log.
+impl std::fmt::Debug for Pixels {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Pixels({}x{})", self.width, self.height)
+    }
 }
 
 /// A `Geometry` resolved at a specific `t` — plain shape data, still local-space.
@@ -54,6 +84,11 @@ pub enum ConcreteGeometry {
         font_size: f32,
         align: TextAlign,
     },
+    Image {
+        pixels: std::sync::Arc<Pixels>,
+        width: f32,
+        height: f32,
+    },
 }
 
 impl Geometry {
@@ -110,6 +145,7 @@ impl Geometry {
                 }
             }
             Geometry::Text { .. } => Vec2::new(0.0, 0.0),
+            Geometry::Image { .. } => Vec2::new(0.0, 0.0),
         }
     }
 
@@ -134,10 +170,34 @@ impl Geometry {
                 font_size: font_size.resolve(t),
                 align: *align,
             },
+            Geometry::Image {
+                pixels,
+                width,
+                height,
+            } => ConcreteGeometry::Image {
+                pixels: pixels.clone(),
+                width: width.resolve(t),
+                height: height.resolve(t),
+            },
         }
     }
 
     pub(crate) fn ease_with(self, curve: super::TimeCurve) -> Self {
+        // An image eases by its box; the pixels are the same pixels whatever
+        // the time is.
+        if let Geometry::Image {
+            pixels,
+            width,
+            height,
+        } = self
+        {
+            let width_curve = curve.clone();
+            return Geometry::Image {
+                pixels,
+                width: Animated::new(move |t| width.resolve(width_curve(t))),
+                height: Animated::new(move |t| height.resolve(curve(t))),
+            };
+        }
         match self {
             Geometry::Circle { radius } => Geometry::Circle {
                 radius: Animated::new(move |t| radius.resolve(curve(t))),
@@ -164,6 +224,9 @@ impl Geometry {
                     align,
                 }
             }
+            // Handled above, before the match, because it needs to move its
+            // Arc rather than borrow it.
+            Geometry::Image { .. } => unreachable!("eased before the match"),
         }
     }
 
@@ -239,6 +302,7 @@ impl Geometry {
             Geometry::Rect { .. } => "Rect",
             Geometry::Path { .. } => "Path",
             Geometry::Text { .. } => "Text",
+            Geometry::Image { .. } => "Image",
         }
     }
 }

{codimate-0.1.1 → codimate-0.1.3}/crates/codimate-export/src/lib.rs

@@ -294,6 +294,14 @@ pub fn export_mp4(
     let mut command = Command::new(encoder_binary());
     command
         .arg("-y")
+        // ffmpeg's default is 46 lines of banner, build configuration and
+        // libx264 internals per render, which buries anything that actually
+        // went wrong and is the first thing a new author sees. `error` keeps
+        // the failures; `-stats` keeps the one rewriting progress line, so a
+        // two-minute render still looks alive rather than hung.
+        .arg("-loglevel")
+        .arg("error")
+        .arg("-stats")
         .arg("-f")
         .arg("rawvideo")
         .arg("-pix_fmt")

{codimate-0.1.1 → codimate-0.1.3}/crates/codimate-math/Cargo.toml

@@ -8,3 +8,8 @@ codimate-core = { path = "../codimate-core" }
 # See docs/adr/0005; pinned for deterministic golden images.
 mitex = "0.2"                                          # LaTeX -> Typst markup
 usvg = { version = "0.47", default-features = false }  # SVG  -> path geometry
+# Already in the tree as a usvg dependency. Declared directly so an imported
+# SVG's `<text>` can be read: usvg is built without its `text` feature and
+# discards those elements while parsing, so they have to be picked up from the
+# source (ADR 0014).
+roxmltree = "0.21"