Skip to content

armgit / klad

Public Imported from GitHub
0

A drawing app built for agent/human collaboration

Rust

The bone tool, and keys on layers, groups and shapes

Indicode BV14964196cc3a
diff --git a/crates/app/src/commands.rs b/crates/app/src/commands.rs
index 9a6c88a..d32adc5 100644
--- a/crates/app/src/commands.rs
+++ b/crates/app/src/commands.rs
@@ -10,6 +10,7 @@ pub enum Cmd {
Pen,
ShapeTool,
TextTool,
+ BoneTool,
Symmetry,
Parallax,
MakeRepeat,
@@ -472,13 +473,14 @@ use Repeat as R;
use Trigger as T;
impl Cmd {
- pub const ALL: [Cmd; 154] = [
+ pub const ALL: [Cmd; 155] = [
Cmd::Brush,
Cmd::Eraser,
Cmd::Fill,
Cmd::Pen,
Cmd::ShapeTool,
Cmd::TextTool,
+ Cmd::BoneTool,
Cmd::Symmetry,
Cmd::Parallax,
Cmd::MakeRepeat,
@@ -703,6 +705,15 @@ impl Cmd {
R::No,
"click on the canvas and type: Return starts a new line, Esc finishes; click text to edit it",
),
+ Cmd::BoneTool => spec(
+ "tool.bones",
+ "bones",
+ icon::TURN,
+ G::Tools,
+ T::Press(const { &[plain(Key::J)] }),
+ R::No,
+ "draw a skeleton on the layer or group, paint how much each bone moves the drawing, and pose it",
+ ),
Cmd::Symmetry => spec(
"brush.mirror",
"mirror painting",
diff --git a/crates/app/src/composite.rs b/crates/app/src/composite.rs
index 7cdf77f..b52e467 100644
--- a/crates/app/src/composite.rs
+++ b/crates/app/src/composite.rs
@@ -954,7 +954,9 @@ fn structure(doc: &Document, frame: u32) -> u64 {
layers.iter().for_each(|l| {
out.extend(l.id.as_bytes());
out.extend(l.kind().name().as_bytes());
- out.extend(l.opacity.to_le_bytes());
+ let (opacity, moved) = l.keyed(frame);
+ out.extend(opacity.to_le_bytes());
+ out.extend(serde_json::to_vec(&moved).unwrap_or_default());
out.push(l.blend as u8);
out.push(l.visible as u8);
out.push(l.clip as u8);
diff --git a/crates/app/src/editor.rs b/crates/app/src/editor.rs
index 56c57e2..62ac61f 100644
--- a/crates/app/src/editor.rs
+++ b/crates/app/src/editor.rs
@@ -1,4 +1,5 @@
mod between;
+mod bones;
mod brushwin;
mod buffer;
mod cells;
@@ -10,6 +11,7 @@ mod copy;
mod depth;
mod export;
mod history;
+mod keys;
mod layers;
mod look;
mod make;
@@ -110,6 +112,7 @@ enum Tool {
Shape,
Text,
Note,
+ Bone,
}
struct PenPath {
@@ -609,6 +612,8 @@ pub(crate) struct Editor {
export: export::Form,
paintover: paintover::Form,
compare: Option<compare::Compared>,
+ bones: bones::BoneTool,
+ key_ease: klad_core::keys::Ease,
bindings: crate::commands::Bindings,
capturing: Option<Cmd>,
key_filter: String,
@@ -768,6 +773,8 @@ impl Editor {
export: export::Form::default(),
paintover: paintover::Form::default(),
compare: None,
+ bones: bones::BoneTool::default(),
+ key_ease: klad_core::keys::Ease::Linear,
bindings: crate::commands::Bindings::default(),
capturing: None,
key_filter: String::new(),
@@ -2410,6 +2417,9 @@ impl Editor {
(Tool::Shape, Phase::Move) => self.shape_move(c),
(Tool::Shape, Phase::Up) => self.shape_up()?,
(Tool::Text, Phase::Down) => self.text_down(c)?,
+ (Tool::Bone, Phase::Down) => self.bone_down(c),
+ (Tool::Bone, Phase::Move) => self.bone_move(c),
+ (Tool::Bone, Phase::Up) => self.bone_up()?,
(Tool::Pen, Phase::Down) => self.pen_down(view, rect, e.pos, c)?,
(Tool::Pen, Phase::Move) => self.pen_move(c),
(Tool::Pen, Phase::Up) => {
@@ -2853,6 +2863,12 @@ impl Editor {
self.parallax(ui, view, rect);
self.prepare_typing(&ctx, view, rect);
self.decorate(ui, view, rect);
+ let hover = ui
+ .input(|i| i.pointer.hover_pos())
+ .filter(|p| rect.contains(*p))
+ .map(|p| view.to_canvas(p - rect.min, rect.size()));
+ let painter = ui.painter().with_clip_rect(rect);
+ self.decorate_bones(&painter, |c| rect.min + view.to_screen(c, rect.size()), hover);
if self.live.is_some()
|| self.lasso.is_some()
|| self.drag.is_some()
@@ -3476,8 +3492,9 @@ impl Editor {
self.apply(vec![Op::Remove {
ids: vec![id.to_string()],
}])?;
+ return Ok(());
}
- Ok(())
+ self.animation_section(ui, id)
}
fn paint_editor(&mut self, ui: &mut egui::Ui, id: &str, node: &Node) -> Option<Paint> {
@@ -3787,7 +3804,8 @@ impl Editor {
self.set(&id, props)?;
self.depth_section(ui, &layer)?;
self.adjust_section(ui, &layer)?;
- self.effects_section(ui, &layer)
+ self.effects_section(ui, &layer)?;
+ self.animation_section(ui, &id)
}
fn colour_panel(&mut self, ui: &mut egui::Ui) -> Result<()> {
diff --git a/crates/app/src/editor/bones.rs b/crates/app/src/editor/bones.rs
new file mode 100644
index 0000000..fa61b91
--- /dev/null
+++ b/crates/app/src/editor/bones.rs
@@ -0,0 +1,543 @@
+use super::Editor;
+use crate::jobs::{Spec, Tag};
+use crate::theme::{self, Hint};
+use anyhow::{Context, Result, bail};
+use egui::{Color32, Pos2, RichText, Vec2};
+use klad_core::doc::Kind;
+use klad_core::ops::{BoneSpec, Op, WeightsSpec};
+use klad_core::rig::{Bone, CELL, Pose, Weights, tips, weights_for};
+use std::collections::BTreeMap;
+use std::path::PathBuf;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub(super) enum Mode {
+ #[default]
+ Draw,
+ Weights,
+ Pose,
+}
+
+pub(super) struct BoneTool {
+ pub mode: Mode,
+ pub selected: Option<String>,
+ pub drag: Option<(Vec2, Vec2, Option<String>)>,
+ pub dabs: Vec<[f32; 4]>,
+ pub radius: f32,
+ pub strength: f32,
+ pub pose: BTreeMap<String, f32>,
+ pub turning: Option<String>,
+ pub name: String,
+ pub heat: Option<(String, u64, egui::TextureHandle)>,
+}
+
+impl Default for BoneTool {
+ fn default() -> Self {
+ Self {
+ mode: Mode::Draw,
+ selected: None,
+ drag: None,
+ dabs: Vec::new(),
+ radius: 24.0,
+ strength: 1.0,
+ pose: BTreeMap::new(),
+ turning: None,
+ name: String::new(),
+ heat: None,
+ }
+ }
+}
+
+const NEAR: f32 = 10.0;
+
+type Later = Box<dyn FnOnce(&mut Editor) -> Result<()>>;
+
+fn near_segment(p: Vec2, a: [f32; 2], b: [f32; 2]) -> f32 {
+ let (a, b) = (Vec2::new(a[0], a[1]), Vec2::new(b[0], b[1]));
+ let d = b - a;
+ let t = ((p - a).dot(d) / d.length_sq().max(1e-6)).clamp(0.0, 1.0);
+ (a + d * t - p).length()
+}
+
+pub(super) fn pose_args(
+ bundle: &std::path::Path,
+ owner: &str,
+ frame: u32,
+ pose: &BTreeMap<String, f32>,
+) -> Vec<String> {
+ let mut args = vec![
+ "pose".to_string(),
+ bundle.to_string_lossy().to_string(),
+ owner.to_string(),
+ "--from".into(),
+ frame.to_string(),
+ "--to".into(),
+ frame.to_string(),
+ ];
+ pose.iter()
+ .filter(|(_, v)| v.abs() > 1e-3)
+ .for_each(|(k, v)| args.extend(["--bone".to_string(), format!("{k}={v:.2}")]));
+ args
+}
+
+impl Editor {
+ pub(super) fn rig_owner(&self) -> Option<String> {
+ let doc = &self.scene.bundle.doc;
+ let path = self.scene.active.clone();
+ (1..=path.len())
+ .rev()
+ .map(|n| doc.layer_at(&path[..n]))
+ .find(|l| !l.bones.is_empty())
+ .or_else(|| match path.len() {
+ 0 => None,
+ 1 => Some(doc.layer_at(&path)).filter(|l| matches!(l.kind(), Kind::Paint | Kind::Group)),
+ _ => Some(doc.layer_at(&path[..1])),
+ })
+ .map(|l| l.id.clone())
+ }
+
+ fn rig_bones(&self) -> Vec<Bone> {
+ self.rig_owner()
+ .and_then(|id| self.scene.bundle.doc.layer(&id).map(|l| l.bones.clone()))
+ .unwrap_or_default()
+ }
+
+ fn shown_pose(&self) -> Pose {
+ Pose {
+ angles: self.bones.pose.clone(),
+ ..Pose::default()
+ }
+ }
+
+ fn bone_at(&self, c: Vec2) -> Option<String> {
+ let bones = self.rig_bones();
+ let zoom = self.view.map_or(1.0, |v| v.zoom);
+ let shown = tips(&bones, &self.shown_pose());
+ bones
+ .iter()
+ .zip(shown)
+ .map(|(b, (h, t))| (b.name.clone(), near_segment(c, h, t)))
+ .filter(|(_, d)| *d <= NEAR / zoom)
+ .min_by(|a, b| a.1.total_cmp(&b.1))
+ .map(|(n, _)| n)
+ }
+
+ pub(super) fn bone_down(&mut self, c: Vec2) {
+ match self.bones.mode {
+ Mode::Draw => {
+ let bones = self.rig_bones();
+ let zoom = self.view.map_or(1.0, |v| v.zoom);
+ let parent = bones
+ .iter()
+ .filter(|b| (Vec2::new(b.tail[0], b.tail[1]) - c).length() <= NEAR / zoom)
+ .map(|b| (b.name.clone(), Vec2::new(b.tail[0], b.tail[1])))
+ .next();
+ let start = parent.as_ref().map_or(c, |p| p.1);
+ self.bones.drag = Some((start, c, parent.map(|p| p.0)));
+ }
+ Mode::Weights => {
+ self.bones.dabs.clear();
+ self.bone_dab(c);
+ }
+ Mode::Pose => {
+ self.bones.turning = self.bone_at(c);
+ if let Some(b) = &self.bones.turning {
+ self.bones.selected = Some(b.clone());
+ }
+ }
+ }
+ }
+
+ fn bone_dab(&mut self, c: Vec2) {
+ let value = if self.modifiers.alt { 0.0 } else { self.bones.strength };
+ if self
+ .bones
+ .dabs
+ .last()
+ .is_none_or(|d| (Vec2::new(d[0], d[1]) - c).length() > self.bones.radius * 0.25)
+ {
+ self.bones.dabs.push([c.x, c.y, self.bones.radius, value]);
+ }
+ }
+
+ pub(super) fn bone_move(&mut self, c: Vec2) {
+ match self.bones.mode {
+ Mode::Draw => {
+ if let Some(drag) = self.bones.drag.as_mut() {
+ drag.1 = c;
+ }
+ }
+ Mode::Weights => {
+ if !self.bones.dabs.is_empty() {
+ self.bone_dab(c);
+ }
+ }
+ Mode::Pose => {
+ let Some(name) = self.bones.turning.clone() else {
+ return;
+ };
+ let bones = self.rig_bones();
+ let Some(i) = bones.iter().position(|b| b.name == name) else {
+ return;
+ };
+ let shown = tips(&bones, &self.shown_pose());
+ let (head, tail) = shown[i];
+ let now = (tail[1] - head[1]).atan2(tail[0] - head[0]);
+ let want = (c.y - head[1]).atan2(c.x - head[0]);
+ let mut turn = (want - now).to_degrees();
+ turn = (turn + 540.0).rem_euclid(360.0) - 180.0;
+ *self.bones.pose.entry(name).or_insert(0.0) += turn;
+ }
+ }
+ }
+
+ pub(super) fn bone_up(&mut self) -> Result<()> {
+ match self.bones.mode {
+ Mode::Draw => {
+ let Some((a, b, parent)) = self.bones.drag.take() else {
+ return Ok(());
+ };
+ if (b - a).length() < 6.0 {
+ self.bones.selected = self.bone_at(b);
+ self.bones.name = self.bones.selected.clone().unwrap_or_default();
+ return Ok(());
+ }
+ let owner = self
+ .rig_owner()
+ .context("pick the layer or group the bones go on first")?;
+ let taken = self.rig_bones();
+ let name = (1..)
+ .map(|n| format!("bone {n}"))
+ .find(|n| !taken.iter().any(|b| &b.name == n))
+ .unwrap_or_default();
+ self.apply(vec![Op::Bone(BoneSpec {
+ layer: owner,
+ add: Some(name.clone()),
+ rm: None,
+ rename: None,
+ to_name: None,
+ moved: None,
+ reparent: None,
+ parent,
+ head: Some([a.x, a.y]),
+ tail: Some([b.x, b.y]),
+ })])?;
+ self.bones.name = name.clone();
+ self.bones.selected = Some(name);
+ }
+ Mode::Weights => {
+ let dabs = std::mem::take(&mut self.bones.dabs);
+ if dabs.is_empty() {
+ return Ok(());
+ }
+ let bone = self
+ .bones
+ .selected
+ .clone()
+ .context("pick a bone to paint its weights: click it in draw mode")?;
+ self.paint_weights(WeightsSpec {
+ layer: self.rig_owner().context("no skeleton here")?,
+ frame: self.scene.frame,
+ auto: false,
+ bone: Some(bone),
+ set: dabs,
+ part: None,
+ value: 1.0,
+ smooth: false,
+ resolved: None,
+ })?;
+ }
+ Mode::Pose => self.bones.turning = None,
+ }
+ Ok(())
+ }
+
+ fn paint_weights(&mut self, mut spec: WeightsSpec) -> Result<()> {
+ let bundle = &self.scene.bundle;
+ let made = weights_for(bundle, &bundle.doc, &spec, &BTreeMap::new())?;
+ spec.resolved = Some(made);
+ self.apply(vec![Op::Weights(spec)])?;
+ self.bones.heat = None;
+ Ok(())
+ }
+
+ pub(super) fn bone_edit(&mut self, edit: impl FnOnce(&mut BoneSpec)) -> Result<()> {
+ let mut spec = BoneSpec {
+ layer: self.rig_owner().context("no skeleton here")?,
+ add: None,
+ rm: None,
+ rename: None,
+ to_name: None,
+ moved: None,
+ reparent: None,
+ parent: None,
+ head: None,
+ tail: None,
+ };
+ edit(&mut spec);
+ self.apply(vec![Op::Bone(spec)])
+ }
+
+ fn pose_drawing(&mut self) -> Result<()> {
+ let owner = self.rig_owner().context("no skeleton here")?;
+ if self.bones.pose.values().all(|v| v.abs() < 1e-3) {
+ bail!("turn a bone first: drag a bone's end in pose mode");
+ }
+ let frame = self.scene.frame;
+ self.start_job(Spec {
+ tag: Tag::Edit,
+ name: format!("pose at frame {frame}"),
+ exe: PathBuf::new(),
+ args: pose_args(&self.scene.bundle.root, &owner, frame, &self.bones.pose),
+ env: Vec::new(),
+ reruns: 3,
+ summary: |out, _| {
+ out.lines()
+ .find(|l| l.starts_with("posed"))
+ .unwrap_or_default()
+ .to_string()
+ },
+ failure: |_, err| super::tweens::failure(err),
+ });
+ self.bones.pose.clear();
+ Ok(())
+ }
+
+ pub(super) fn bone_options(&mut self, ui: &mut egui::Ui) -> Result<()> {
+ let mut run: Option<Later> = None;
+ [
+ (
+ Mode::Draw,
+ "draw",
+ "drag to draw a bone; start on a bone's end to make it its child; click a bone to pick it",
+ ),
+ (
+ Mode::Weights,
+ "weights",
+ "paint the picked bone's weight; alt removes it",
+ ),
+ (Mode::Pose, "pose", "drag a bone's end to turn it, its children follow"),
+ ]
+ .iter()
+ .for_each(|(mode, label, hint)| {
+ if ui
+ .selectable_label(self.bones.mode == *mode, *label)
+ .hint(*hint)
+ .clicked()
+ {
+ self.bones.mode = *mode;
+ if *mode == Mode::Pose {
+ self.bones.pose = self
+ .rig_owner()
+ .and_then(|o| self.scene.bundle.doc.layer(&o).cloned())
+ .and_then(|o| {
+ klad_core::rig::painted(&o)
+ .iter()
+ .find_map(|l| l.content_at(self.scene.frame).and_then(|c| c.pose.clone()))
+ })
+ .map(|p| p.angles)
+ .unwrap_or_default();
+ }
+ }
+ });
+ ui.separator();
+ match self.bones.mode {
+ Mode::Draw => {
+ if let Some(picked) = self.bones.selected.clone() {
+ let label = ui.label("name");
+ let r = ui
+ .add(egui::TextEdit::singleline(&mut self.bones.name).desired_width(110.0))
+ .labelled_by(label.id)
+ .hint("the picked bone's name; Return renames it");
+ if r.lost_focus() && self.bones.name.trim() != picked && !self.bones.name.trim().is_empty() {
+ let to = self.bones.name.trim().to_string();
+ run = Some(Box::new(move |e| {
+ e.bone_edit(|s| {
+ s.rename = Some(picked);
+ s.to_name = Some(to.clone());
+ })?;
+ e.bones.selected = Some(to);
+ Ok(())
+ }));
+ } else if ui.button("remove").hint("the picked bone and its children").clicked() {
+ run = Some(Box::new(move |e| {
+ e.bone_edit(|s| s.rm = Some(picked))?;
+ e.bones.selected = None;
+ Ok(())
+ }));
+ }
+ } else {
+ ui.label(RichText::new("drag on the canvas to draw a bone").color(theme::WEAK));
+ }
+ }
+ Mode::Weights => {
+ ui.add(
+ egui::Slider::new(&mut self.bones.radius, 4.0..=200.0)
+ .logarithmic(true)
+ .text("size"),
+ )
+ .hint("the weight brush's radius in px");
+ ui.add(egui::Slider::new(&mut self.bones.strength, 0.0..=1.0).text("weight"))
+ .hint("the weight a dab paints; alt paints 0");
+ if ui
+ .button("automatic weights")
+ .hint("start again from the bones, by distance")
+ .clicked()
+ {
+ run = Some(Box::new(|e| {
+ e.paint_weights(WeightsSpec {
+ layer: e.rig_owner().context("no skeleton here")?,
+ frame: e.scene.frame,
+ auto: true,
+ bone: None,
+ set: Vec::new(),
+ part: None,
+ value: 1.0,
+ smooth: false,
+ resolved: None,
+ })
+ }));
+ }
+ if ui.button("smooth").hint("blur every bone's weights a little").clicked() {
+ run = Some(Box::new(|e| {
+ e.paint_weights(WeightsSpec {
+ layer: e.rig_owner().context("no skeleton here")?,
+ frame: e.scene.frame,
+ auto: false,
+ bone: None,
+ set: Vec::new(),
+ part: None,
+ value: 1.0,
+ smooth: true,
+ resolved: None,
+ })
+ }));
+ }
+ ui.label(
+ RichText::new(
+ self.bones
+ .selected
+ .as_deref()
+ .map_or("click a bone in draw mode first".to_string(), |b| {
+ format!("painting {b}")
+ }),
+ )
+ .color(theme::WEAK),
+ );
+ }
+ Mode::Pose => {
+ if ui
+ .button("make this pose a drawing")
+ .hint("bends the drawing here (or its rest drawing) into this pose, as klad pose")
+ .clicked()
+ {
+ run = Some(Box::new(|e| e.pose_drawing()));
+ }
+ if ui.button("back to rest").hint("forget the turns").clicked() {
+ self.bones.pose.clear();
+ }
+ }
+ }
+ if let Some(f) = run {
+ f(self)?;
+ }
+ Ok(())
+ }
+
+ fn heat_texture(&mut self, bone: &str) -> Option<egui::TextureHandle> {
+ let rev = self.scene.bundle.doc.rev;
+ if let Some((b, r, t)) = &self.bones.heat
+ && b == bone
+ && *r == rev
+ {
+ return Some(t.clone());
+ }
+ let owner = self.rig_owner()?;
+ let bones = self.rig_bones();
+ let i = bones.iter().position(|b| b.name == bone)?;
+ let weights: Weights = self.scene.bundle.read_weights(&owner).ok()?;
+ let (w, h) = (weights.width as usize, weights.height as usize);
+ let pixels: Vec<Color32> = (0..h)
+ .flat_map(|y| (0..w).map(move |x| (x, y)))
+ .map(|(x, y)| {
+ let p = [(x as f32 + 0.5) * CELL as f32, (y as f32 + 0.5) * CELL as f32];
+ let v = weights.at(&bones, p)[i];
+ Color32::from_rgba_unmultiplied(240, (60.0 + 160.0 * v) as u8, 40, (v * 150.0) as u8)
+ })
+ .collect();
+ let image = egui::ColorImage::new([w, h], pixels);
+ let texture = self
+ .ctx
+ .load_texture("bone weights", image, egui::TextureOptions::LINEAR);
+ self.bones.heat = Some((bone.to_string(), rev, texture.clone()));
+ Some(texture)
+ }
+
+ pub(super) fn decorate_bones(
+ &mut self,
+ painter: &egui::Painter,
+ place: impl Fn(Vec2) -> Pos2,
+ hover: Option<Vec2>,
+ ) {
+ if self.tool != super::Tool::Bone {
+ return;
+ }
+ if self.bones.mode == Mode::Weights
+ && let Some(bone) = self.bones.selected.clone()
+ && let Some(texture) = self.heat_texture(&bone)
+ {
+ let canvas = self.canvas_size();
+ let rect = egui::Rect::from_two_pos(place(Vec2::ZERO), place(canvas));
+ painter.image(
+ texture.id(),
+ rect,
+ egui::Rect::from_min_max(Pos2::ZERO, Pos2::new(1.0, 1.0)),
+ Color32::WHITE,
+ );
+ }
+ let bones = self.rig_bones();
+ let shown = tips(&bones, &self.shown_pose());
+ bones.iter().zip(shown).for_each(|(b, (h, t))| {
+ let (a, z) = (place(Vec2::new(h[0], h[1])), place(Vec2::new(t[0], t[1])));
+ let picked = self.bones.selected.as_ref() == Some(&b.name);
+ let colour = if picked {
+ theme::ACCENT
+ } else {
+ Color32::from_rgb(120, 200, 240)
+ };
+ painter.line_segment([a, z], egui::Stroke::new(6.0, Color32::from_black_alpha(150)));
+ painter.line_segment([a, z], egui::Stroke::new(3.0, colour));
+ painter.circle_filled(a, 4.5, colour);
+ painter.circle_stroke(z, 4.0, egui::Stroke::new(1.5, colour));
+ painter.text(
+ a + (z - a) * 0.5 + egui::vec2(6.0, -6.0),
+ egui::Align2::LEFT_BOTTOM,
+ &b.name,
+ egui::FontId::proportional(11.0),
+ colour,
+ );
+ });
+ if let Some((a, b, _)) = self.bones.drag {
+ painter.line_segment([place(a), place(b)], egui::Stroke::new(2.0, theme::ACCENT));
+ }
+ if self.bones.mode == Mode::Weights
+ && let Some(p) = hover
+ {
+ let r = self.bones.radius * self.view.map_or(1.0, |v| v.zoom);
+ painter.circle_stroke(place(p), r, egui::Stroke::new(1.0, theme::ACCENT));
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn a_pose_from_the_editor_is_the_cli_pose() {
+ let pose = BTreeMap::from([("fore".to_string(), -45.0), ("upper".to_string(), 0.0)]);
+ assert_eq!(
+ pose_args(std::path::Path::new("/w/a.draw"), "l1", 4, &pose).join(" "),
+ "pose /w/a.draw l1 --from 4 --to 4 --bone fore=-45.00"
+ );
+ }
+}
diff --git a/crates/app/src/editor/commands.rs b/crates/app/src/editor/commands.rs
index 4317f71..0f89bea 100644
--- a/crates/app/src/editor/commands.rs
+++ b/crates/app/src/editor/commands.rs
@@ -309,6 +309,7 @@ impl Editor {
Cmd::Pen => self.tool == Tool::Pen,
Cmd::ShapeTool => self.tool == Tool::Shape,
Cmd::TextTool => self.tool == Tool::Text,
+ Cmd::BoneTool => self.tool == Tool::Bone,
Cmd::Symmetry => self.mirror.is_some(),
Cmd::Note => self.tool == Tool::Note,
Cmd::CutLasso => self.cut_lasso,
@@ -440,6 +441,7 @@ impl Editor {
Cmd::Pen => self.tool = Tool::Pen,
Cmd::ShapeTool => self.tool = Tool::Shape,
Cmd::TextTool => self.tool = Tool::Text,
+ Cmd::BoneTool => self.tool = Tool::Bone,
Cmd::Symmetry => {
self.mirror = match self.mirror {
Some(_) => None,
diff --git a/crates/app/src/editor/keys.rs b/crates/app/src/editor/keys.rs
new file mode 100644
index 0000000..c6006a3
--- /dev/null
+++ b/crates/app/src/editor/keys.rs
@@ -0,0 +1,113 @@
+use super::Editor;
+use crate::theme::{self, Hint};
+use anyhow::Result;
+use egui::RichText;
+use klad_core::doc::Item;
+use klad_core::keys::{Ease, Keys, PROPS, value};
+use klad_core::ops::{KeySpec, Op};
+use std::collections::BTreeMap;
+
+const EASES: [(Ease, &str); 5] = [
+ (Ease::Linear, "linear"),
+ (Ease::In, "in"),
+ (Ease::Out, "out"),
+ (Ease::InOut, "in-out"),
+ (Ease::Step, "step"),
+];
+
+fn resting(doc: &klad_core::doc::Document, id: &str) -> Option<(Keys, [f32; 6])> {
+ match doc.item(id)? {
+ Item::Layer(l) => Some((l.keys.clone(), [0.0, 0.0, 0.0, 1.0, 1.0, l.opacity])),
+ Item::Node(_, _, n) => Some((
+ n.keys.clone(),
+ [
+ n.transform.x,
+ n.transform.y,
+ n.transform.rotate,
+ n.transform.sx,
+ n.transform.sy,
+ n.opacity,
+ ],
+ )),
+ _ => None,
+ }
+}
+
+impl Editor {
+ pub(super) fn key_here(&mut self, id: &str, values: BTreeMap<String, f32>, rm: bool) -> Result<()> {
+ self.apply(vec![Op::Key(KeySpec {
+ id: id.to_string(),
+ frame: self.scene.frame,
+ values,
+ ease: self.key_ease,
+ rm,
+ })])
+ }
+
+ pub(super) fn animation_section(&mut self, ui: &mut egui::Ui, id: &str) -> Result<()> {
+ let Some((keys, rest)) = resting(&self.scene.bundle.doc, id) else {
+ return Ok(());
+ };
+ let frame = self.scene.frame;
+ let mut run: Option<(BTreeMap<String, f32>, bool)> = None;
+ ui.collapsing(RichText::new("keys").strong(), |ui| {
+ ui.label(
+ RichText::new("animate without a drawing per frame: set a value here and key it at this frame")
+ .color(theme::WEAK),
+ );
+ PROPS.iter().zip(rest).for_each(|(prop, rest)| {
+ let now = value(&keys, prop, frame).unwrap_or(rest);
+ ui.horizontal(|ui| {
+ let slot = format!("{id}.key.{prop}");
+ let mut v = self.edits.get(&slot).copied().unwrap_or(now);
+ let r = ui
+ .add(
+ egui::DragValue::new(&mut v)
+ .speed(if *prop == "opacity" { 0.01 } else { 0.5 })
+ .prefix(format!("{prop} ")),
+ )
+ .hint(format!("{prop} at this frame; key it to keep it"));
+ if r.changed() {
+ self.edits.insert(slot.clone(), v);
+ }
+ if ui.button("key").hint(format!("key {prop} at frame {frame}")).clicked() {
+ self.edits.remove(&slot);
+ run = Some((BTreeMap::from([(prop.to_string(), v)]), false));
+ }
+ let list = keys.get(*prop).cloned().unwrap_or_default();
+ let shown: Vec<String> = list.iter().map(|k| format!("{}:{:.1}", k.frame, k.value)).collect();
+ if !shown.is_empty() {
+ ui.label(RichText::new(shown.join(" ")).small().color(theme::WEAK));
+ }
+ });
+ });
+ ui.horizontal(|ui| {
+ egui::ComboBox::from_id_salt(format!("{id}.ease"))
+ .selected_text(
+ EASES
+ .iter()
+ .find(|(e, _)| *e == self.key_ease)
+ .map_or("curve", |(_, n)| *n),
+ )
+ .show_ui(ui, |ui| {
+ EASES.iter().for_each(|(e, n)| {
+ ui.selectable_value(&mut self.key_ease, *e, *n);
+ });
+ })
+ .response
+ .hint("how the next keys ease towards the key after them");
+ if ui
+ .button("remove keys here")
+ .hint(format!("every key at frame {frame}"))
+ .clicked()
+ {
+ run = Some((BTreeMap::new(), true));
+ }
+ });
+ });
+ if let Some((values, rm)) = run {
+ self.key_here(id, values, rm)?;
+ }
+ Ok(())
+ }
+}
diff --git a/crates/app/src/editor/options.rs b/crates/app/src/editor/options.rs
index 786ae79..85af4a8 100644
--- a/crates/app/src/editor/options.rs
+++ b/crates/app/src/editor/options.rs
@@ -292,6 +292,7 @@ impl Editor {
Tool::Shape => (Cmd::ShapeTool, "rectangles and ellipses"),
Tool::Text => (Cmd::TextTool, "text"),
Tool::Note => (Cmd::Note, "note"),
+ Tool::Bone => (Cmd::BoneTool, "bones"),
};
ui.label(RichText::new(format!("{} {name}", cmd.spec().icon)).strong());
ui.separator();
@@ -392,6 +393,7 @@ impl Editor {
);
}
Tool::Text => self.check(|e| e.text_options(ui)),
+ Tool::Bone => self.check(|e| e.bone_options(ui)),
Tool::Pen => {
self.vector_colours(
ui,
diff --git a/crates/app/src/editor/panels.rs b/crates/app/src/editor/panels.rs
index 5a7cff0..585bedd 100644
--- a/crates/app/src/editor/panels.rs
+++ b/crates/app/src/editor/panels.rs
@@ -36,7 +36,7 @@ fn ago(at: Instant, now: Instant) -> String {
}
}
-const STRIP_TOOLS: [Cmd; 10] = [
+const STRIP_TOOLS: [Cmd; 11] = [
Cmd::Brush,
Cmd::Eraser,
Cmd::Fill,
@@ -46,6 +46,7 @@ const STRIP_TOOLS: [Cmd; 10] = [
Cmd::Pen,
Cmd::ShapeTool,
Cmd::TextTool,
+ Cmd::BoneTool,
Cmd::Note,
];
diff --git a/crates/app/src/editor/ui_tests.rs b/crates/app/src/editor/ui_tests.rs
index 6bba9c6..ef60c3f 100644
--- a/crates/app/src/editor/ui_tests.rs
+++ b/crates/app/src/editor/ui_tests.rs
@@ -2528,3 +2528,87 @@ fn text_is_typed_on_the_canvas_and_edited_in_place() {
);
assert!(path.join("fonts/Cinzel.ttf").is_file(), "picking a font copies it in");
}
+
+#[test]
+fn bones_are_drawn_weighted_and_posed_on_the_canvas() {
+ let path = sample("bones");
+ let mut h = harness(editor(&path), vec2(1440.0, 1000.0));
+ activate(&mut h, "lines");
+ h.key_press(Key::J);
+ h.run_steps(2);
+ assert_eq!(h.state().tool, Tool::Bone);
+ let (a, b, c) = (
+ canvas_at(&h, 40.0, 40.0),
+ canvas_at(&h, 170.0, 120.0),
+ canvas_at(&h, 300.0, 200.0),
+ );
+ drag(&mut h, a, b);
+ h.run_steps(2);
+ drag(&mut h, b, c);
+ h.run_steps(2);
+ let bones = |h: &Harness<'static, Editor>| h.state().scene.bundle.doc.layer("l6").unwrap().bones.clone();
+ let made = bones(&h);
+ assert_eq!(made.len(), 2, "{made:?}");
+ assert_eq!(
+ made[1].parent.as_deref(),
+ Some("bone 1"),
+ "a bone started on a tail is its child"
+ );
+ assert!((made[1].tail[0] - 300.0).abs() < 2.0 && (made[1].tail[1] - 200.0).abs() < 2.0);
+ h.state_mut().bones.name = "shin".into();
+ h.state_mut()
+ .bone_edit(|s| {
+ s.rename = Some("bone 2".into());
+ s.to_name = Some("shin".into());
+ })
+ .unwrap();
+ assert_eq!(bones(&h)[1].name, "shin");
+ h.state_mut().bones.mode = super::bones::Mode::Weights;
+ h.state_mut().bones.selected = Some("shin".into());
+ let (dab, more) = (canvas_at(&h, 250.0, 170.0), canvas_at(&h, 260.0, 175.0));
+ drag(&mut h, dab, more);
+ h.run_steps(2);
+ let weights = h.state().scene.bundle.read_weights("l6").unwrap();
+ assert!(
+ weights.maps.contains_key("shin"),
+ "painting weights writes the bone's map"
+ );
+ h.state_mut().bones.mode = super::bones::Mode::Pose;
+ let (end, there) = (canvas_at(&h, 290.0, 190.0), canvas_at(&h, 200.0, 260.0));
+ drag(&mut h, end, there);
+ h.run_steps(2);
+ let turned = h.state().bones.pose.get("shin").copied().unwrap_or(0.0);
+ assert!(turned > 20.0, "dragging the shin's end turns it: {turned}");
+ let _ = std::fs::remove_dir_all(&path);
+}
+
+#[test]
+fn a_layer_is_keyed_from_the_inspector_and_eases_between_its_keys() {
+ let path = sample("keyed-layer");
+ let mut h = harness(editor(&path), vec2(1440.0, 1000.0));
+ activate(&mut h, "lines");
+ let id = h.state().scene.active_id().unwrap();
+ h.state_mut()
+ .key_here(&id, std::collections::BTreeMap::from([("y".to_string(), 0.0)]), false)
+ .unwrap();
+ h.state_mut().scene.frame = 6;
+ h.state_mut().key_ease = klad_core::keys::Ease::Linear;
+ h.state_mut()
+ .key_here(&id, std::collections::BTreeMap::from([("y".to_string(), -30.0)]), false)
+ .unwrap();
+ h.run_steps(2);
+ let layer = h.state().scene.bundle.doc.find_layer("lines").unwrap().clone();
+ assert_eq!(layer.keyed(3).1.unwrap().y, -15.0);
+ assert!(
+ h.query_all(By::new().label_contains("keys")).count() > 0,
+ "the inspector shows the keys section"
+ );
+ h.state_mut()
+ .key_here(&id, std::collections::BTreeMap::new(), true)
+ .unwrap();
+ assert_eq!(
+ h.state().scene.bundle.doc.find_layer("lines").unwrap().keys["y"].len(),
+ 1
+ );
+ let _ = std::fs::remove_dir_all(&path);
+}
diff --git a/crates/cli/src/keys.rs b/crates/cli/src/keys.rs
new file mode 100644
index 0000000..3f02073
--- /dev/null
+++ b/crates/cli/src/keys.rs
@@ -0,0 +1,152 @@
+use anyhow::Result;
+use klad_core::bundle::Bundle;
+use klad_core::doc::{Document, Node};
+use klad_core::keys::Keys;
+use serde_json::json;
+
+fn walk<'a>(nodes: &'a [Node], out: &mut Vec<(String, String, &'a Keys)>) {
+ nodes.iter().for_each(|n| {
+ if !n.keys.is_empty() {
+ out.push((
+ n.id.clone(),
+ if n.name.is_empty() {
+ n.type_name().to_string()
+ } else {
+ n.name.clone()
+ },
+ &n.keys,
+ ));
+ }
+ walk(n.shape.children(), out);
+ });
+}
+
+pub fn keyed(doc: &Document) -> Vec<(String, String, &Keys)> {
+ let mut out = Vec::new();
+ doc.all_layers().into_iter().for_each(|l| {
+ if !l.keys.is_empty() {
+ out.push((l.id.clone(), l.name.clone(), &l.keys));
+ }
+ l.cels().iter().for_each(|c| walk(&c.nodes, &mut out));
+ });
+ out
+}
+
+pub fn list(bundle: &Bundle, only: Option<&str>, as_json: bool) -> Result<()> {
+ let found: Vec<_> = keyed(&bundle.doc)
+ .into_iter()
+ .filter(|(id, name, _)| only.is_none_or(|o| o == id || o == name))
+ .collect();
+ if as_json {
+ let rows: Vec<_> = found
+ .iter()
+ .map(|(id, name, keys)| json!({"id": id, "name": name, "keys": keys}))
+ .collect();
+ println!("{}", serde_json::to_string_pretty(&rows)?);
+ return Ok(());
+ }
+ if found.is_empty() {
+ println!("no keys yet: klad key <bundle> <layer or shape> --frame 0 y=0");
+ }
+ found.iter().for_each(|(id, name, keys)| {
+ println!("{name} ({id})");
+ keys.iter().for_each(|(prop, list)| {
+ let shown: Vec<String> = list
+ .iter()
+ .map(|k| match k.ease {
+ klad_core::keys::Ease::Linear => format!("{}:{}", k.frame, k.value),
+ e => format!(
+ "{}:{} {}",
+ k.frame,
+ k.value,
+ serde_json::to_string(&e).unwrap_or_default().trim_matches('"')
+ ),
+ })
+ .collect();
+ println!(" {prop:<8} {}", shown.join(" "));
+ });
+ });
+ Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::agent::{Look, Output, render_look};
+ use klad_core::doc::Layer;
+ use klad_core::ops::parse_lines;
+ use klad_render::View;
+
+ fn centre(bundle: &Bundle, frame: u32, dark: impl Fn(&[u8]) -> bool) -> (f32, f32) {
+ let out = std::env::temp_dir().join(format!("klad-keys-{}-{frame}.png", std::process::id()));
+ let f = render_look(
+ bundle,
+ frame,
+ View::scaled(1.0),
+ &Look::plain(None),
+ Some(out.clone()),
+ false,
+ )
+ .unwrap()
+ .frame;
+ let _ = std::fs::remove_file(&out);
+ let (mut sx, mut sy, mut n) = (0.0, 0.0, 0.0);
+ f.rgba
+ .chunks(4)
+ .enumerate()
+ .filter(|(_, p)| dark(p))
+ .for_each(|(i, _)| {
+ sx += (i % f.width as usize) as f32;
+ sy += (i / f.width as usize) as f32;
+ n += 1.0;
+ });
+ (sx / n, sy / n)
+ }
+
+ #[test]
+ fn a_keyed_layer_and_shape_move_between_their_keys_with_the_ease() {
+ let dir = std::env::temp_dir().join(format!("klad-keys-{}", std::process::id()));
+ let _ = std::fs::remove_dir_all(&dir);
+ let mut doc = Document::new(300, 200);
+ doc.canvas.background = Some("#ffffff".into());
+ doc.timeline.frames = 12;
+ doc.layers = vec![
+ Layer::paint("l1", "float", "c1"),
+ Layer::vector("l2", "shapes", "c2", Vec::new()),
+ ];
+ Bundle::create(&dir, doc).unwrap();
+ let ops = r##"{"op":"stroke","layer":"l1","brush":"ink","size":20,"color":"#000000","path":"M140 100 L160 100"}
+{"op":"add","node":{"id":"dot","type":"ellipse","cx":50,"cy":50,"rx":10,"ry":10,"fill":"#ff0000"},"in":"l2"}
+{"op":"key","id":"l1","frame":0,"y":0}
+{"op":"key","id":"l1","frame":10,"y":-60,"ease":"in-out"}
+{"op":"key","id":"dot","frame":0,"x":0,"ease":"step"}
+{"op":"key","id":"dot","frame":10,"x":200}"##;
+ let quiet = Output {
+ json: false,
+ render: false,
+ scale: None,
+ frame: 0,
+ overlay: None,
+ };
+ crate::agent::edit(&dir, &parse_lines(ops).unwrap(), &quiet).unwrap();
+ let bundle = Bundle::open(&dir).unwrap();
+ let black = |p: &[u8]| p[0] < 60 && p[1] < 60;
+ let red = |p: &[u8]| p[0] > 200 && p[1] < 80;
+ let (at0, at5, at10) = (
+ centre(&bundle, 0, black),
+ centre(&bundle, 5, black),
+ centre(&bundle, 10, black),
+ );
+ assert!(
+ (at0.1 - 100.0).abs() < 1.5 && (at5.1 - 70.0).abs() < 1.5 && (at10.1 - 40.0).abs() < 1.5,
+ "{at0:?} {at5:?} {at10:?}"
+ );
+ assert!(
+ (centre(&bundle, 9, red).0 - 50.0).abs() < 1.5,
+ "a step key holds until the next"
+ );
+ assert!((centre(&bundle, 11, red).0 - 250.0).abs() < 1.5);
+ assert_eq!(keyed(&bundle.doc).len(), 2);
+ std::fs::remove_dir_all(&dir).unwrap();
+ }
+}
diff --git a/crates/cli/src/layers.rs b/crates/cli/src/layers.rs
index 584b417..28fbb71 100644
--- a/crates/cli/src/layers.rs
+++ b/crates/cli/src/layers.rs
@@ -149,14 +149,15 @@ pub struct Vectors {
impl Vectors {
pub fn add_to(&mut self, doc: &Document, frame: u32, rasters: &mut Rasters) -> Result<()> {
let (w, h) = (doc.canvas.width, doc.canvas.height);
- let cels: Vec<(String, u64, &Vec<Node>)> = doc
+ let cels: Vec<(String, u64, Vec<Node>)> = doc
.all_layers()
.into_iter()
.filter(|l| l.kind() == Kind::Vector)
.filter_map(|l| l.content_at(frame))
.map(|c| {
- let hash = fnv(FNV_OFFSET, &serde_json::to_vec(&c.nodes).unwrap_or_default());
- (c.id.clone(), hash, &c.nodes)
+ let nodes = klad_core::doc::nodes_at(&c.nodes, frame);
+ let hash = fnv(FNV_OFFSET, &serde_json::to_vec(&nodes).unwrap_or_default());
+ (c.id.clone(), hash, nodes)
})
.collect();
let fresh = cels
diff --git a/crates/cli/src/main.rs b/crates/cli/src/main.rs
index 867bdb0..e83f9ed 100644
--- a/crates/cli/src/main.rs
+++ b/crates/cli/src/main.rs
@@ -13,6 +13,7 @@ mod frames;
mod history;
mod inbetween;
mod install;
+mod keys;
mod layers;
mod looks;
mod marks;
@@ -1237,6 +1238,31 @@ enum Command {
#[command(flatten)]
flags: EditFlags,
},
+ #[command(
+ about = "Key a layer, group or shape: its position, turn, scale or opacity at a frame, eased to the next key",
+ long_about = "Keys animate a layer, a group or a vector shape without a drawing per frame: x and y (px), rotate (degrees), sx, sy or scale, and opacity, each with its own keys. Between two keys the value follows the first key's ease: linear, in, out, in-out, step, or a curve x1,y1,x2,y2 (as in CSS). Before the first key and after the last the value holds. A layer or group turns and scales about the canvas centre; a shape about its own pivot. --rm removes the keys at that frame (only the named properties, or all).\n\n klad key art.draw lantern --frame 0 y=0\n klad key art.draw lantern --frame 12 y=-14 --ease in-out\n klad key art.draw glow --frame 6 opacity=0.4\n klad key art.draw lantern --frame 12 --rm\n\nAlso a key op: {\"op\":\"key\",\"id\":\"lantern\",\"frame\":12,\"y\":-14,\"ease\":\"in-out\"}."
+ )]
+ Key {
+ bundle: PathBuf,
+ id: String,
+ #[arg(long)]
+ frame: u32,
+ #[arg(help = "prop=value: x, y, rotate, sx, sy, scale, opacity")]
+ values: Vec<String>,
+ #[arg(long, default_value = "linear")]
+ ease: String,
+ #[arg(long)]
+ rm: bool,
+ #[command(flatten)]
+ flags: EditFlags,
+ },
+ #[command(about = "List the keys of every keyed layer, group and shape (or one)")]
+ Keys {
+ bundle: PathBuf,
+ id: Option<String>,
+ #[arg(long)]
+ json: bool,
+ },
#[command(
about = "Measure a drawing against a reference picture: values, saturation, texture, edges, colour per region",
long_about = "Render the drawing (or read a PNG or JPEG) at the reference's size and compare the two in OKLab: the value range (L at the 5th, 50th and 95th percentile), mean chroma, stroke texture (mean absolute Laplacian of L), edge sharpness (99th percentile of the gradient) and the mean colour difference, with what differs in words (lighter, bluer, busier, softer edges). --region adds a row per named rectangle; --heat writes a picture of where they differ most (black, red, yellow, white as the difference grows to 20).\n\n klad compare cafe.draw reference.png --region shade=40,300,200,120 --region cup=610,180,90,120 --heat diff.png"
@@ -2765,6 +2791,33 @@ fn run() -> Result<()> {
agent::edit(&bundle, &[Op::Bone(spec)], &output(&flags, 0))?;
}
Command::Bones { bundle, json } => rig::list(&Bundle::open(&bundle)?, json)?,
+ Command::Key {
+ bundle,
+ id,
+ frame,
+ values,
+ ease,
+ rm,
+ flags,
+ } => {
+ let opened = Bundle::open(&bundle)?;
+ let id = match opened.doc.locate(&id) {
+ Some(_) => id,
+ None => opened.doc.find_layer(&id)?.id.clone(),
+ };
+ let mut op = serde_json::json!({"op": "key", "id": id, "frame": frame, "rm": rm, "ease": ease});
+ values.iter().try_for_each(|v| -> Result<()> {
+ let (k, n) = v.split_once('=').ok_or_else(|| anyhow!("{v:?} is not prop=value"))?;
+ op[k.trim()] = serde_json::json!(n.trim().parse::<f64>()?);
+ Ok(())
+ })?;
+ agent::edit(
+ &bundle,
+ &klad_core::ops::parse_lines(&op.to_string())?,
+ &output(&flags, frame),
+ )?;
+ }
+ Command::Keys { bundle, id, json } => keys::list(&Bundle::open(&bundle)?, id.as_deref(), json)?,
Command::Weights {
bundle,
layer,
diff --git a/crates/cli/src/rig.rs b/crates/cli/src/rig.rs
index e9f3147..e65b323 100644
--- a/crates/cli/src/rig.rs
+++ b/crates/cli/src/rig.rs
@@ -1,23 +1,13 @@
use anyhow::{Context, Result, anyhow, bail};
use klad_core::bundle::Bundle;
-use klad_core::doc::{Document, Kind, Layer};
-use klad_core::ops::{Applied, Op, PoseSpec, PosedCel, WeightsSpec, apply, rig_owner};
-use klad_core::rig::{Bone, CELL, Pose, Rig, Weights, tips};
+use klad_core::doc::{Document, Layer};
+use klad_core::ops::{Applied, Op, PoseSpec, PosedCel, apply, rig_owner};
+use klad_core::rig::{Bone, CELL, Pose, Rig, Weights, family, painted, tips, weights_for};
use klad_core::stroke::Mark;
use klad_render::overlay::Heat;
use serde_json::json;
use std::collections::BTreeMap;
-fn family(layer: &Layer) -> Vec<&Layer> {
- std::iter::once(layer)
- .chain(layer.children().iter().flat_map(family))
- .collect()
-}
-
-pub fn painted(owner: &Layer) -> Vec<&Layer> {
- family(owner).into_iter().filter(|l| l.kind() == Kind::Paint).collect()
-}
-
pub fn owners(doc: &Document) -> Vec<&Layer> {
doc.all_layers().into_iter().filter(|l| !l.bones.is_empty()).collect()
}
@@ -65,100 +55,6 @@ pub fn heat(bundle: &Bundle, bone: &str) -> Result<Heat> {
})
}
-fn weights_for(
- bundle: &Bundle,
- doc: &Document,
- spec: &WeightsSpec,
- current: &BTreeMap<String, Weights>,
-) -> Result<Weights> {
- let owner = rig_owner(doc, &spec.layer)?;
- let canvas = (doc.canvas.width, doc.canvas.height);
- if owner.bones.is_empty() {
- bail!("{} has no bones yet: add them with klad bone first", owner.name);
- }
- let mut w = match current.get(&owner.id) {
- Some(w) => w.clone(),
- None => bundle.read_weights(&owner.id)?,
- };
- if (w.width, w.height) != Weights::new(canvas).dims() {
- w = Weights::new(canvas);
- }
- if spec.auto {
- let fresh = Weights::auto(&owner.bones, canvas);
- match &spec.bone {
- Some(b) => {
- let map = fresh.maps.get(b).cloned().ok_or_else(|| anyhow!("no bone {b}"))?;
- w.maps.insert(b.clone(), map);
- }
- None => w = fresh,
- }
- }
- let bone = || -> Result<String> {
- let b = spec.bone.clone().context("say which bone: \"bone\"")?;
- if !owner.bones.iter().any(|o| o.name == b) {
- bail!("no bone {b} on {}", owner.name);
- }
- Ok(b)
- };
- if !spec.set.is_empty() {
- let b = bone()?;
- spec.set.iter().for_each(|d| w.dab(&b, [d[0], d[1]], d[2], d[3]));
- }
- if let Some(part) = &spec.part {
- let b = bone()?;
- let mut cells = Vec::new();
- painted(owner).iter().try_for_each(|layer| -> Result<()> {
- let Some(cel) = layer.content_at(spec.frame) else {
- return Ok(());
- };
- let Some(ids) = cel.parts.get(part) else {
- return Ok(());
- };
- let marks = bundle.read_marks(&layer.id, &cel.id)?;
- marks.iter().filter(|m| ids.contains(&m.id())).for_each(|m| match m {
- Mark::Stroke(s) => s.samples.iter().for_each(|q| {
- let (x, y) = q.pos();
- let r = (s.size * 0.5 / CELL as f32).ceil() as i64 + 1;
- let (cx, cy) = ((x / CELL as f32) as i64, (y / CELL as f32) as i64);
- (-r..=r)
- .flat_map(|dy| (-r..=r).map(move |dx| (cx + dx, cy + dy)))
- .for_each(|c| cells.push(c));
- }),
- Mark::Fill(f) => {
- let c = &f.coverage;
- (c.y..c.y + c.height).step_by(CELL as usize / 2).for_each(|y| {
- (c.x..c.x + c.width)
- .step_by(CELL as usize / 2)
- .filter(|&x| c.at(x, y) > 0)
- .for_each(|x| cells.push(((x / CELL) as i64, (y / CELL) as i64)));
- });
- }
- });
- Ok(())
- })?;
- let (gw, gh) = (w.width as i64, w.height as i64);
- let mut cells: Vec<(u32, u32)> = cells
- .into_iter()
- .filter(|(x, y)| *x >= 0 && *y >= 0 && *x < gw && *y < gh)
- .map(|(x, y)| (x as u32, y as u32))
- .collect();
- cells.sort_unstable();
- cells.dedup();
- if cells.is_empty() {
- bail!("no marks in the part {part} at frame {}", spec.frame);
- }
- w.fill(&b, &cells, spec.value);
- if spec.value >= 1.0 {
- let others: Vec<String> = w.maps.keys().filter(|k| **k != b).cloned().collect();
- others.iter().for_each(|o| w.fill(o, &cells, 0.0));
- }
- }
- if spec.smooth {
- w.smooth();
- }
- Ok(w)
-}
-
fn rest_of(layer: &Layer, frame: u32) -> Option<String> {
let cel = layer.content_at(frame)?;
Some(cel.pose.as_ref().map_or_else(|| cel.id.clone(), |p| p.rest.clone()))
diff --git a/crates/core/src/bundle.rs b/crates/core/src/bundle.rs
index 7430295..62acc2a 100644
--- a/crates/core/src/bundle.rs
+++ b/crates/core/src/bundle.rs
@@ -564,6 +564,7 @@ pub fn summarize(ops: &[Op]) -> String {
Op::Foliage(spec) => format!("foliage on {}", spec.layer),
Op::PaintOver(spec) => format!("paint over on {}", spec.layer),
Op::Bone(spec) => format!("bones on {}", spec.layer),
+ Op::Key(spec) => format!("keys on {} at frame {}", spec.id, spec.frame),
Op::Weights(spec) => format!("weights on {}", spec.layer),
Op::Pose(spec) => format!("pose on {} at frame {}", spec.layer, spec.to),
Op::Grass(spec) => format!("grass on {}", spec.layer),
diff --git a/crates/core/src/doc.rs b/crates/core/src/doc.rs
index 54960a4..d00f56a 100644
--- a/crates/core/src/doc.rs
+++ b/crates/core/src/doc.rs
@@ -147,6 +147,8 @@ pub struct Layer {
pub reference: bool,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub bones: Vec<crate::rig::Bone>,
+ #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+ pub keys: crate::keys::Keys,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -296,6 +298,8 @@ pub struct Node {
pub clip: Option<String>,
#[serde(default = "yes", skip_serializing_if = "is_true")]
pub visible: bool,
+ #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+ pub keys: crate::keys::Keys,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -517,6 +521,7 @@ impl Layer {
depth: None,
reference: false,
bones: Vec::new(),
+ keys: BTreeMap::new(),
}
}
@@ -674,6 +679,7 @@ impl Node {
blur: 0.0,
clip: None,
visible: true,
+ keys: BTreeMap::new(),
}
}
@@ -1220,6 +1226,59 @@ impl Document {
}
}
+impl Layer {
+ pub fn keyed(&self, frame: u32) -> (f32, Option<Transform>) {
+ if self.keys.is_empty() {
+ return (self.opacity, None);
+ }
+ let v = |p: &str, d: f32| crate::keys::value(&self.keys, p, frame).unwrap_or(d);
+ let moved = ["x", "y", "rotate", "sx", "sy"]
+ .iter()
+ .any(|p| self.keys.contains_key(*p));
+ (
+ v("opacity", self.opacity),
+ moved.then(|| Transform {
+ x: v("x", 0.0),
+ y: v("y", 0.0),
+ rotate: v("rotate", 0.0),
+ sx: v("sx", 1.0),
+ sy: v("sy", 1.0),
+ pivot: None,
+ }),
+ )
+ }
+}
+
+impl Node {
+ pub fn keyed(&self, frame: u32) -> std::borrow::Cow<'_, Node> {
+ if self.keys.is_empty() {
+ return std::borrow::Cow::Borrowed(self);
+ }
+ let mut node = self.clone();
+ let v = |p: &str, d: f32| crate::keys::value(&self.keys, p, frame).unwrap_or(d);
+ node.transform.x = v("x", self.transform.x);
+ node.transform.y = v("y", self.transform.y);
+ node.transform.rotate = v("rotate", self.transform.rotate);
+ node.transform.sx = v("sx", self.transform.sx);
+ node.transform.sy = v("sy", self.transform.sy);
+ node.opacity = v("opacity", self.opacity);
+ std::borrow::Cow::Owned(node)
+ }
+}
+
+pub fn nodes_at(nodes: &[Node], frame: u32) -> Vec<Node> {
+ nodes
+ .iter()
+ .map(|n| {
+ let mut node = n.keyed(frame).into_owned();
+ if let Some(children) = node.shape.children_mut() {
+ *children = nodes_at(children, frame);
+ }
+ node
+ })
+ .collect()
+}
+
#[cfg(test)]
mod tests {
use super::*;
diff --git a/crates/core/src/keys.rs b/crates/core/src/keys.rs
new file mode 100644
index 0000000..8e54f1b
--- /dev/null
+++ b/crates/core/src/keys.rs
@@ -0,0 +1,187 @@
+use anyhow::{Result, bail};
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+pub const PROPS: [&str; 6] = ["x", "y", "rotate", "sx", "sy", "opacity"];
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum Ease {
+ #[default]
+ Linear,
+ In,
+ Out,
+ InOut,
+ Step,
+ Curve([f32; 4]),
+}
+
+impl Ease {
+ pub fn parse(text: &str) -> Result<Self> {
+ Ok(match text.trim() {
+ "linear" => Ease::Linear,
+ "in" => Ease::In,
+ "out" => Ease::Out,
+ "in-out" => Ease::InOut,
+ "step" => Ease::Step,
+ other => {
+ let n: Vec<f32> = other.split(',').filter_map(|v| v.trim().parse().ok()).collect();
+ match n.as_slice() {
+ [a, b, c, d] => Ease::Curve([*a, *b, *c, *d]),
+ _ => bail!("ease {other:?}: linear, in, out, in-out, step, or a curve x1,y1,x2,y2"),
+ }
+ }
+ })
+ }
+
+ pub fn at(self, t: f32) -> f32 {
+ let t = t.clamp(0.0, 1.0);
+ match self {
+ Ease::Linear => t,
+ Ease::In => t * t,
+ Ease::Out => t * (2.0 - t),
+ Ease::InOut => t * t * (3.0 - 2.0 * t),
+ Ease::Step => {
+ if t < 1.0 {
+ 0.0
+ } else {
+ 1.0
+ }
+ }
+ Ease::Curve([x1, y1, x2, y2]) => {
+ let bez = |a: f32, b: f32, u: f32| {
+ 3.0 * a * u * (1.0 - u) * (1.0 - u) + 3.0 * b * u * u * (1.0 - u) + u * u * u
+ };
+ let (mut lo, mut hi) = (0.0f32, 1.0f32);
+ (0..30).for_each(|_| {
+ let mid = (lo + hi) / 2.0;
+ if bez(x1, x2, mid) < t {
+ lo = mid;
+ } else {
+ hi = mid;
+ }
+ });
+ bez(y1, y2, (lo + hi) / 2.0)
+ }
+ }
+ }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Key {
+ pub frame: u32,
+ pub value: f32,
+ #[serde(default, skip_serializing_if = "is_linear")]
+ pub ease: Ease,
+}
+
+fn is_linear(e: &Ease) -> bool {
+ *e == Ease::Linear
+}
+
+pub type Keys = BTreeMap<String, Vec<Key>>;
+
+pub fn value(keys: &Keys, prop: &str, frame: u32) -> Option<f32> {
+ let list = keys.get(prop).filter(|l| !l.is_empty())?;
+ let after = list.iter().position(|k| k.frame > frame);
+ Some(match after {
+ Some(0) => list[0].value,
+ None => list[list.len() - 1].value,
+ Some(i) => {
+ let (a, b) = (list[i - 1], list[i]);
+ let t = (frame - a.frame) as f32 / (b.frame - a.frame).max(1) as f32;
+ a.value + (b.value - a.value) * a.ease.at(t)
+ }
+ })
+}
+
+pub fn set(keys: &mut Keys, prop: &str, key: Key) -> Result<()> {
+ if !PROPS.contains(&prop) {
+ bail!("no keyable property {prop:?}: {}", PROPS.join(", "));
+ }
+ let list = keys.entry(prop.to_string()).or_default();
+ list.retain(|k| k.frame != key.frame);
+ let at = list.iter().position(|k| k.frame > key.frame).unwrap_or(list.len());
+ list.insert(at, key);
+ Ok(())
+}
+
+pub fn remove(keys: &mut Keys, prop: Option<&str>, frame: u32) {
+ keys.iter_mut()
+ .filter(|(p, _)| prop.is_none_or(|q| q == p.as_str()))
+ .for_each(|(_, list)| list.retain(|k| k.frame != frame));
+ keys.retain(|_, list| !list.is_empty());
+}
+
+pub fn frames(keys: &Keys) -> Vec<u32> {
+ let mut all: Vec<u32> = keys.values().flatten().map(|k| k.frame).collect();
+ all.sort_unstable();
+ all.dedup();
+ all
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn keys_interpolate_with_their_ease_and_hold_outside() {
+ let mut keys = Keys::new();
+ set(
+ &mut keys,
+ "x",
+ Key {
+ frame: 0,
+ value: 0.0,
+ ease: Ease::Linear,
+ },
+ )
+ .unwrap();
+ set(
+ &mut keys,
+ "x",
+ Key {
+ frame: 10,
+ value: 100.0,
+ ease: Ease::Out,
+ },
+ )
+ .unwrap();
+ set(
+ &mut keys,
+ "x",
+ Key {
+ frame: 20,
+ value: 0.0,
+ ease: Ease::Step,
+ },
+ )
+ .unwrap();
+ assert_eq!(value(&keys, "x", 5), Some(50.0));
+ assert!(
+ (value(&keys, "x", 12).unwrap() - 64.0).abs() < 1e-3,
+ "out eases 10 to 20 from 100 towards 0"
+ );
+ assert_eq!(value(&keys, "x", 30), Some(0.0));
+ assert_eq!(value(&keys, "y", 5), None);
+ assert!(Ease::In.at(0.5) < 0.5 && Ease::Out.at(0.5) > 0.5 && Ease::InOut.at(0.5) == 0.5);
+ assert_eq!(Ease::Step.at(0.99), 0.0);
+ let curve = Ease::parse("0.42,0,0.58,1").unwrap();
+ assert!((curve.at(0.5) - 0.5).abs() < 0.01 && curve.at(0.2) < 0.2);
+ assert!(
+ set(
+ &mut keys,
+ "colour",
+ Key {
+ frame: 1,
+ value: 1.0,
+ ease: Ease::Linear
+ }
+ )
+ .is_err()
+ );
+ remove(&mut keys, None, 10);
+ assert_eq!(frames(&keys), [0, 20]);
+ }
+}
diff --git a/crates/core/src/lib.rs b/crates/core/src/lib.rs
index ce5a004..a49deee 100644
--- a/crates/core/src/lib.rs
+++ b/crates/core/src/lib.rs
@@ -6,6 +6,7 @@ pub mod doc;
pub mod fill;
pub mod generators;
pub mod history;
+pub mod keys;
pub mod look;
pub mod markedit;
pub mod migrate;
diff --git a/crates/core/src/ops.rs b/crates/core/src/ops.rs
index 46281eb..1c8263b 100644
--- a/crates/core/src/ops.rs
+++ b/crates/core/src/ops.rs
@@ -151,6 +151,7 @@ pub enum Op {
Bone(BoneSpec),
Weights(WeightsSpec),
Pose(PoseSpec),
+ Key(KeySpec),
Clip(ClipEdit),
Export {
godot: Option<String>,
@@ -684,6 +685,15 @@ pub struct PoseSpec {
pub resolved: Option<Vec<PosedCel>>,
}
+#[derive(Clone, Debug, PartialEq)]
+pub struct KeySpec {
+ pub id: String,
+ pub frame: u32,
+ pub values: BTreeMap<String, f32>,
+ pub ease: crate::keys::Ease,
+ pub rm: bool,
+}
+
#[derive(Clone, Debug, PartialEq)]
pub struct PosedCel {
pub layer: String,
@@ -1451,6 +1461,45 @@ impl Op {
"scatter" => Op::Scatter(serde_json::from_value(Value::Object(std::mem::take(&mut map)))?),
"foliage" => Op::Foliage(serde_json::from_value(Value::Object(std::mem::take(&mut map)))?),
"paintover" => Op::PaintOver(serde_json::from_value(Value::Object(std::mem::take(&mut map)))?),
+ "key" => {
+ let id = map
+ .remove("id")
+ .and_then(|v| v.as_str().map(String::from))
+ .ok_or_else(|| anyhow!("a key needs \"id\": the layer, group or shape it animates"))?;
+ let frame = whole(&mut map, "frame")?.unwrap_or(0);
+ let rm = flag(&mut map, "rm")?;
+ let ease = match map.remove("ease") {
+ None => crate::keys::Ease::Linear,
+ Some(Value::String(e)) => crate::keys::Ease::parse(&e)?,
+ Some(other) => serde_json::from_value(other)
+ .map_err(|_| anyhow!("ease must be linear, in, out, in-out, step or a curve"))?,
+ };
+ let mut values = BTreeMap::new();
+ std::mem::take(&mut map).into_iter().try_for_each(|(k, v)| {
+ let n = v.as_f64().ok_or_else(|| anyhow!("key {k}: a number"))? as f32;
+ match k.as_str() {
+ "scale" => {
+ values.insert("sx".to_string(), n);
+ values.insert("sy".to_string(), n);
+ }
+ p if crate::keys::PROPS.contains(&p) => {
+ values.insert(p.to_string(), n);
+ }
+ other => bail!("no keyable property {other:?}: x, y, rotate, sx, sy, scale, opacity"),
+ }
+ Ok(())
+ })?;
+ if values.is_empty() && !rm {
+ bail!("a key needs a value: x, y, rotate, sx, sy, scale or opacity");
+ }
+ Op::Key(KeySpec {
+ id,
+ frame,
+ values,
+ ease,
+ rm,
+ })
+ }
"bone" => Op::Bone(serde_json::from_value(Value::Object(std::mem::take(&mut map)))?),
"weights" => Op::Weights(serde_json::from_value(Value::Object(std::mem::take(&mut map)))?),
"pose" => Op::Pose(serde_json::from_value(Value::Object(std::mem::take(&mut map)))?),
@@ -1696,6 +1745,39 @@ fn bone(doc: &mut Document, spec: &BoneSpec, out: &mut Applied) -> Result<()> {
Ok(())
}
+fn key(doc: &mut Document, spec: &KeySpec, out: &mut Applied) -> Result<()> {
+ let keys: &mut crate::keys::Keys = match doc.locate(&spec.id) {
+ Some(Loc::Layer(path)) => &mut doc.layer_at_mut(&path).keys,
+ Some(Loc::Node(layer, cel, nodes)) => {
+ let (last, parent) = nodes.split_last().ok_or_else(|| anyhow!("no node {}", spec.id))?;
+ &mut node_list(doc, &layer, cel, parent)?[*last].keys
+ }
+ _ => bail!("{} is not a layer, group or shape: keys go on those", spec.id),
+ };
+ match spec.rm {
+ true => match spec.values.is_empty() {
+ true => crate::keys::remove(keys, None, spec.frame),
+ false => spec
+ .values
+ .keys()
+ .for_each(|p| crate::keys::remove(keys, Some(p), spec.frame)),
+ },
+ false => spec.values.iter().try_for_each(|(p, v)| {
+ crate::keys::set(
+ keys,
+ p,
+ crate::keys::Key {
+ frame: spec.frame,
+ value: *v,
+ ease: spec.ease,
+ },
+ )
+ })?,
+ }
+ out.changed.push(spec.id.clone());
+ Ok(())
+}
+
fn posed(doc: &mut Document, made: &[PosedCel], out: &mut Applied) -> Result<()> {
made.iter().try_for_each(|cel| {
let path = layer_path(doc, &cel.layer)?;
@@ -2915,6 +2997,7 @@ pub fn apply(doc: &mut Document, op: &Op, out: &mut Applied) -> Result<()> {
);
}
Op::Bone(spec) => bone(doc, spec, out)?,
+ Op::Key(spec) => key(doc, spec, out)?,
Op::Weights(spec) => {
let Some(made) = &spec.resolved else {
bail!("weights are computed by klad weights (or klad apply) first");
diff --git a/crates/core/src/patch.rs b/crates/core/src/patch.rs
index 27d9db2..a03af05 100644
--- a/crates/core/src/patch.rs
+++ b/crates/core/src/patch.rs
@@ -127,6 +127,7 @@ fn layer_shell(layer: &Layer) -> Layer {
depth: layer.depth,
reference: layer.reference,
bones: layer.bones.clone(),
+ keys: layer.keys.clone(),
}
}
@@ -159,6 +160,7 @@ fn node_shell(node: &Node) -> Node {
blur: node.blur,
clip: node.clip.clone(),
visible: node.visible,
+ keys: node.keys.clone(),
}
}
diff --git a/crates/core/src/rig.rs b/crates/core/src/rig.rs
index 29cd846..b8bb6db 100644
--- a/crates/core/src/rig.rs
+++ b/crates/core/src/rig.rs
@@ -1,6 +1,9 @@
+use crate::bundle::Bundle;
+use crate::doc::{Document, Kind, Layer};
use crate::fill::{Coverage, FillSource};
+use crate::ops::{WeightsSpec, rig_owner};
use crate::stroke::{Mark, POS_SCALE};
-use anyhow::{Context, Result, bail};
+use anyhow::{Context, Result, anyhow, bail};
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
@@ -459,6 +462,110 @@ impl<'a> Rig<'a> {
}
}
+pub fn family(layer: &Layer) -> Vec<&Layer> {
+ std::iter::once(layer)
+ .chain(layer.children().iter().flat_map(family))
+ .collect()
+}
+
+pub fn painted(owner: &Layer) -> Vec<&Layer> {
+ family(owner).into_iter().filter(|l| l.kind() == Kind::Paint).collect()
+}
+
+pub fn weights_for(
+ bundle: &Bundle,
+ doc: &Document,
+ spec: &WeightsSpec,
+ current: &BTreeMap<String, Weights>,
+) -> Result<Weights> {
+ let owner = rig_owner(doc, &spec.layer)?;
+ let canvas = (doc.canvas.width, doc.canvas.height);
+ if owner.bones.is_empty() {
+ bail!("{} has no bones yet: add them with klad bone first", owner.name);
+ }
+ let mut w = match current.get(&owner.id) {
+ Some(w) => w.clone(),
+ None => bundle.read_weights(&owner.id)?,
+ };
+ if (w.width, w.height) != Weights::new(canvas).dims() {
+ w = Weights::new(canvas);
+ }
+ if spec.auto {
+ let fresh = Weights::auto(&owner.bones, canvas);
+ match &spec.bone {
+ Some(b) => {
+ let map = fresh.maps.get(b).cloned().ok_or_else(|| anyhow!("no bone {b}"))?;
+ w.maps.insert(b.clone(), map);
+ }
+ None => w = fresh,
+ }
+ }
+ let bone = || -> Result<String> {
+ let b = spec.bone.clone().context("say which bone: \"bone\"")?;
+ if !owner.bones.iter().any(|o| o.name == b) {
+ bail!("no bone {b} on {}", owner.name);
+ }
+ Ok(b)
+ };
+ if !spec.set.is_empty() {
+ let b = bone()?;
+ spec.set.iter().for_each(|d| w.dab(&b, [d[0], d[1]], d[2], d[3]));
+ }
+ if let Some(part) = &spec.part {
+ let b = bone()?;
+ let mut cells = Vec::new();
+ painted(owner).iter().try_for_each(|layer| -> Result<()> {
+ let Some(cel) = layer.content_at(spec.frame) else {
+ return Ok(());
+ };
+ let Some(ids) = cel.parts.get(part) else {
+ return Ok(());
+ };
+ let marks = bundle.read_marks(&layer.id, &cel.id)?;
+ marks.iter().filter(|m| ids.contains(&m.id())).for_each(|m| match m {
+ Mark::Stroke(s) => s.samples.iter().for_each(|q| {
+ let (x, y) = q.pos();
+ let r = (s.size * 0.5 / CELL as f32).ceil() as i64 + 1;
+ let (cx, cy) = ((x / CELL as f32) as i64, (y / CELL as f32) as i64);
+ (-r..=r)
+ .flat_map(|dy| (-r..=r).map(move |dx| (cx + dx, cy + dy)))
+ .for_each(|c| cells.push(c));
+ }),
+ Mark::Fill(f) => {
+ let c = &f.coverage;
+ (c.y..c.y + c.height).step_by(CELL as usize / 2).for_each(|y| {
+ (c.x..c.x + c.width)
+ .step_by(CELL as usize / 2)
+ .filter(|&x| c.at(x, y) > 0)
+ .for_each(|x| cells.push(((x / CELL) as i64, (y / CELL) as i64)));
+ });
+ }
+ });
+ Ok(())
+ })?;
+ let (gw, gh) = (w.width as i64, w.height as i64);
+ let mut cells: Vec<(u32, u32)> = cells
+ .into_iter()
+ .filter(|(x, y)| *x >= 0 && *y >= 0 && *x < gw && *y < gh)
+ .map(|(x, y)| (x as u32, y as u32))
+ .collect();
+ cells.sort_unstable();
+ cells.dedup();
+ if cells.is_empty() {
+ bail!("no marks in the part {part} at frame {}", spec.frame);
+ }
+ w.fill(&b, &cells, spec.value);
+ if spec.value >= 1.0 {
+ let others: Vec<String> = w.maps.keys().filter(|k| **k != b).cloned().collect();
+ others.iter().for_each(|o| w.fill(o, &cells, 0.0));
+ }
+ }
+ if spec.smooth {
+ w.smooth();
+ }
+ Ok(w)
+}
+
#[cfg(test)]
mod tests {
use super::*;
diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rs
index 5c0544b..e93ae5c 100644
--- a/crates/render/src/lib.rs
+++ b/crates/render/src/lib.rs
@@ -318,16 +318,22 @@ fn draw_clipped(canvas: &Canvas, base: &Layer, clipped: &[&Layer], ctx: Ctx) ->
draw_onions(canvas, std::iter::once(base).chain(shown.iter().copied()), ctx)?;
let effects = ctx.effects(base);
if !effects.is_empty() || shown.iter().any(|l| l.reads_under()) {
- return effected(canvas, ctx, &effects, Some(base), base.opacity, base.blend, &|c, x| {
- draw_unit(c, base, &shown, x)
- })
+ return effected(
+ canvas,
+ ctx,
+ &effects,
+ Some(base),
+ base.keyed(ctx.frame).0,
+ base.blend,
+ &|c, x| draw_unit(c, base, &shown, x),
+ )
.with_context(|| format!("layer {}", base.id));
}
if shown.is_empty() {
return draw_layer(canvas, base, ctx);
}
let inner = ctx.nested();
- layer_paint_isolated(canvas, base.opacity, base.blend);
+ layer_paint_isolated(canvas, base.keyed(ctx.frame).0, base.blend);
let drawn = draw_content(canvas, base, inner)
.and_then(|_| shown.iter().try_for_each(|layer| draw_clip(canvas, base, layer, inner)));
canvas.restore();
@@ -335,7 +341,7 @@ fn draw_clipped(canvas: &Canvas, base: &Layer, clipped: &[&Layer], ctx: Ctx) ->
}
pub(crate) fn draw_clipped_alone(canvas: &Canvas, base: &Layer, layer: &Layer, ctx: Ctx) -> Result<()> {
- layer_paint_isolated(canvas, layer.opacity, Blend::Normal);
+ layer_paint_isolated(canvas, layer.keyed(ctx.frame).0, Blend::Normal);
let drawn = draw_styled(canvas, layer, ctx).and_then(|_| {
mode_layer(canvas, BlendMode::DstIn);
let base_drawn = draw_content(canvas, base, ctx.nested());
@@ -347,7 +353,7 @@ pub(crate) fn draw_clipped_alone(canvas: &Canvas, base: &Layer, layer: &Layer, c
}
fn draw_clip(canvas: &Canvas, base: &Layer, layer: &Layer, ctx: Ctx) -> Result<()> {
- layer_paint_isolated(canvas, layer.opacity, layer.blend);
+ layer_paint_isolated(canvas, layer.keyed(ctx.frame).0, layer.blend);
let drawn = draw_styled(canvas, layer, ctx).and_then(|_| {
mode_layer(canvas, BlendMode::DstIn);
let base_drawn = draw_content(canvas, base, ctx);
@@ -387,21 +393,16 @@ pub(crate) fn draw_layer(canvas: &Canvas, layer: &Layer, ctx: Ctx) -> Result<()>
};
}
let effects = ctx.effects(layer);
+ let opacity = layer.keyed(ctx.frame).0;
if !effects.is_empty() {
- return effected(
- canvas,
- ctx,
- &effects,
- Some(layer),
- layer.opacity,
- layer.blend,
- &|c, x| draw_content(c, layer, x),
- )
+ return effected(canvas, ctx, &effects, Some(layer), opacity, layer.blend, &|c, x| {
+ draw_content(c, layer, x)
+ })
.with_context(|| format!("layer {}", layer.id));
}
- let isolate = layer.opacity < 1.0 || layer.blend != Blend::Normal || layer.mask_at(ctx.frame).is_some();
+ let isolate = opacity < 1.0 || layer.blend != Blend::Normal || layer.mask_at(ctx.frame).is_some();
if isolate {
- layer_paint_isolated(canvas, layer.opacity, layer.blend);
+ layer_paint_isolated(canvas, opacity, layer.blend);
}
let drawn = draw_content(canvas, layer, ctx);
if isolate {
@@ -681,6 +682,31 @@ fn draw_paint_cel(canvas: &Canvas, cel: &str, ctx: Ctx) -> Result<()> {
}
fn draw_content(canvas: &Canvas, layer: &Layer, ctx: Ctx) -> Result<()> {
+ let Some(moved) = layer.keyed(ctx.frame).1 else {
+ return draw_unmoved(canvas, layer, ctx);
+ };
+ let pivot = ctx.doc.map_or((0.0, 0.0), |d| {
+ (d.canvas.width as f32 / 2.0, d.canvas.height as f32 / 2.0)
+ });
+ canvas.save();
+ canvas.translate((moved.x + pivot.0, moved.y + pivot.1));
+ canvas.rotate(moved.rotate, None);
+ canvas.scale((moved.sx, moved.sy));
+ canvas.translate((-pivot.0, -pivot.1));
+ let whole = Ctx {
+ area: None,
+ sampling: Some(
+ ctx.sampling
+ .unwrap_or(SamplingOptions::new(FilterMode::Linear, MipmapMode::None)),
+ ),
+ ..ctx
+ };
+ let drawn = draw_unmoved(canvas, layer, whole);
+ canvas.restore();
+ drawn
+}
+
+fn draw_unmoved(canvas: &Canvas, layer: &Layer, ctx: Ctx) -> Result<()> {
match &layer.content {
LayerContent::Paint { .. } => layer
.content_at(ctx.frame)
@@ -690,7 +716,7 @@ fn draw_content(canvas: &Canvas, layer: &Layer, ctx: Ctx) -> Result<()> {
.content_at(ctx.frame)
.map_or(Ok(()), |cel| match ctx.rasters.get(&cel.id) {
Some(r) => draw_raster(canvas, r, ctx),
- None => vector::draw_nodes(canvas, &cel.nodes),
+ None => vector::draw_nodes(canvas, &klad_core::doc::nodes_at(&cel.nodes, ctx.frame)),
})
}
LayerContent::Group { children } => draw_layers(canvas, children, ctx.nested()),