EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
Graph Editor: the speed graph of a curved motion path is smooth, not jagged (#456)
Claude1c9b5f1828cd
diff --git a/crates/keyframe/src/lib.rs b/crates/keyframe/src/lib.rsindex 805371491..3ef50882d 100644--- a/crates/keyframe/src/lib.rs+++ b/crates/keyframe/src/lib.rs@@ -233,26 +233,44 @@ struct SpatialSeg {const ARC_N: usize = 96;+/// 5-point Gauss-Legendre nodes and weights on -1..1.+const GAUSS: [(f64, f64); 5] = [+ (0.0, 0.568_888_888_888_888_9),+ (-0.538_469_310_105_683_1, 0.478_628_670_499_366_5),+ (0.538_469_310_105_683_1, 0.478_628_670_499_366_5),+ (-0.906_179_845_938_664, 0.236_926_885_056_189_1),+ (0.906_179_845_938_664, 0.236_926_885_056_189_1),+];+impl SpatialSeg {fn new(p: [[f64; 3]; 4]) -> SpatialSeg {let mut table = Vec::with_capacity(ARC_N + 1);table.push(0.0);- let mut prev = Self::point(&p, 0.0);let mut acc = 0.0;for i in 1..=ARC_N {- let q = Self::point(&p, i as f64 / ARC_N as f64);- acc += ((q[0] - prev[0]).powi(2) + (q[1] - prev[1]).powi(2) + (q[2] - prev[2]).powi(2)).sqrt();+ acc += Self::arc(&p, (i - 1) as f64 / ARC_N as f64, i as f64 / ARC_N as f64);table.push(acc);- prev = q;}SpatialSeg { p, table }}fn point(p: &[[f64; 3]; 4], u: f64) -> [f64; 3] {[bez(p[0][0], p[1][0], p[2][0], p[3][0], u), bez(p[0][1], p[1][1], p[2][1], p[3][1], u), bez(p[0][2], p[1][2], p[2][2], p[3][2], u)]}+ /// |dB/du|.+ fn tangent_len(p: &[[f64; 3]; 4], u: f64) -> f64 {+ (0..3).map(|k| bez_d(p[0][k], p[1][k], p[2][k], p[3][k], u).powi(2)).sum::<f64>().sqrt()+ }+ /// Arc length between `a` and `b` (Gauss-Legendre; exact enough on one table cell).+ fn arc(p: &[[f64; 3]; 4], a: f64, b: f64) -> f64 {+ let (m, h) = ((a + b) * 0.5, (b - a) * 0.5);+ GAUSS.iter().map(|(x, w)| w * Self::tangent_len(p, m + h * x)).sum::<f64>() * h+ }fn length(&self) -> f64 {*self.table.last().unwrap_or(&0.0)}+ /// The point at arc length `s`. The table cell's linear guess is refined with Newton steps+ /// on the true arc length, so the position (and the speed graph, its derivative) is smooth+ /// along curved paths instead of piecewise linear per cell (#456).fn at_length(&self, s: f64) -> [f64; 3] {let len = self.length();if len <= 0.0 {@@ -260,9 +278,21 @@ impl SpatialSeg {}let s = s.clamp(0.0, len);let i = self.table.partition_point(|&v| v < s).clamp(1, ARC_N);- let (a, b) = (self.table[i - 1], self.table[i]);- let f = if b > a { (s - a) / (b - a) } else { 0.0 };- Self::point(&self.p, (i as f64 - 1.0 + f) / ARC_N as f64)+ let (Some(&a), Some(&b)) = (self.table.get(i - 1), self.table.get(i)) else { return self.p[0] };+ let (u0, u1) = ((i - 1) as f64 / ARC_N as f64, i as f64 / ARC_N as f64);+ let mut u = u0 + if b > a { (s - a) / (b - a) } else { 0.0 } * (u1 - u0);+ for _ in 0..4 {+ let d = Self::tangent_len(&self.p, u);+ if d <= 1e-12 {+ break;+ }+ let e = a + Self::arc(&self.p, u0, u) - s;+ u = (u - e / d).clamp(u0, u1);+ if e.abs() <= 1e-12 * len.max(1.0) {+ break;+ }+ }+ Self::point(&self.p, u)}}@@ -764,6 +794,24 @@ mod tests {assert!((p[0] - 150.0).abs() < 0.5 && (p[1] - 200.0).abs() < 0.5, "{p:?}");}+ /// #456: along a curved spatial path with linear (constant-speed) keys the speed graph is+ /// flat, not a sawtooth from a piecewise-linear arc-length table.+ #[test]+ fn spatial_curved_path_has_smooth_constant_speed() {+ let mut a = Keyframe::new(s(0.0), Value::Vec2([0.0, 0.0]));+ let mut b = Keyframe::new(s(2.0), Value::Vec2([400.0, 0.0]));+ a.spatial_auto = false;+ b.spatial_auto = false;+ a.spatial_out = [50.0, -300.0, 0.0];+ b.spatial_in = [80.0, 250.0, 0.0];+ let keys = vec![a, b];+ let len = spatial_segment_length(&keys, 0);+ let speeds: Vec<f64> = (1..400).map(|i| speed(&keys, s(i as f64 * 0.005), true)).collect();+ for v in &speeds {+ assert!((v - len / 2.0).abs() < 1e-3 * len, "speed {v} vs {}", len / 2.0);+ }+ }+#[test]fn spatial_auto_bezier_passes_through_keys() {let keys = vec![