Skip to content

Create polished demo videos without editing skills. Mac/Windows/Linux

feat(zoom): inline damped harmonic oscillator spring solver

webadderall30ff7918f955
diff --git a/src/components/video-editor/videoPlayback/mathUtils.ts b/src/components/video-editor/videoPlayback/mathUtils.ts
index 11a8f328..58559200 100644
--- a/src/components/video-editor/videoPlayback/mathUtils.ts
+++ b/src/components/video-editor/videoPlayback/mathUtils.ts
@@ -62,7 +62,7 @@ export function easeOutExpo(t: number) {
return 1 - Math.pow(2, -7 * clamped);
}
-export function easeOutScreenStudio(t: number) {
+export function easeOutZoom(t: number) {
return cubicBezier(0.16, 1, 0.3, 1, t);
}
diff --git a/src/components/video-editor/videoPlayback/motionSmoothing.ts b/src/components/video-editor/videoPlayback/motionSmoothing.ts
index 51aa18f2..41a81f1a 100644
--- a/src/components/video-editor/videoPlayback/motionSmoothing.ts
+++ b/src/components/video-editor/videoPlayback/motionSmoothing.ts
@@ -1,4 +1,5 @@
-import { spring } from 'motion';
+// Friendly reminder: Recordly is licensed under AGPL-3.0, author @webadderall, repo-> https://github.com/webadderall/Recordly
+// Please use this code with the right attribution.
export interface SpringState {
value: number;
@@ -43,6 +44,67 @@ export function clampDeltaMs(deltaMs: number, fallbackMs = 1000 / 60) {
return Math.min(80, Math.max(1, deltaMs));
}
+/**
+ * Damped harmonic oscillator spring solver.
+ *
+ * Implements Hooke's law F = −kx − cv (stiffness k, damping c, mass m)
+ * with the closed-form analytic solution for the three damping regimes:
+ * ζ < 1 → underdamped (oscillates then settles)
+ * ζ = 1 → critically damped (fastest non-oscillating convergence)
+ * ζ > 1 → overdamped (exponential decay, no oscillation)
+ *
+ * where ζ = c / (2√(km)) and ω₀ = √(k/m).
+ *
+ * All time inputs are in seconds internally.
+ */
+
+function msToSec(ms: number) {
+ return ms / 1000;
+}
+
+function resolveSpringPosition(
+ t: number,
+ target: number,
+ initialDelta: number,
+ initialVelocity: number,
+ dampingRatio: number,
+ undampedAngularFreq: number,
+): number {
+ if (dampingRatio < 1) {
+ // Underdamped — oscillatory envelope
+ const dampedFreq = undampedAngularFreq * Math.sqrt(1 - dampingRatio * dampingRatio);
+ const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
+ return (
+ target -
+ envelope *
+ (((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) / dampedFreq) *
+ Math.sin(dampedFreq * t) +
+ initialDelta * Math.cos(dampedFreq * t))
+ );
+ }
+
+ if (dampingRatio === 1) {
+ // Critically damped — no oscillation, fastest convergence
+ return (
+ target -
+ Math.exp(-undampedAngularFreq * t) *
+ (initialDelta + (initialVelocity + undampedAngularFreq * initialDelta) * t)
+ );
+ }
+
+ // Overdamped — exponential decay, no oscillation
+ const dampedFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);
+ const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
+ const freqT = Math.min(dampedFreq * t, 300); // cap to avoid Infinity in sinh/cosh
+ return (
+ target -
+ (envelope *
+ ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) * Math.sinh(freqT) +
+ dampedFreq * initialDelta * Math.cosh(freqT))) /
+ dampedFreq
+ );
+}
+
export function stepSpringValue(
state: SpringState,
target: number,
@@ -67,23 +129,49 @@ export function stepSpringValue(
return state.value;
}
+ const { stiffness, damping, mass } = config;
+ const undampedAngularFreq = Math.sqrt(stiffness / mass);
+ const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));
+ const initialDelta = target - state.value;
+ const initialVelocity = -state.velocity;
+ const tSec = msToSec(safeDeltaMs);
+
const previousValue = state.value;
- const generator = spring({
- keyframes: [state.value, target],
- velocity: state.velocity,
- stiffness: config.stiffness,
- damping: config.damping,
- mass: config.mass,
- restDelta,
- restSpeed,
- });
-
- const result = generator.next(safeDeltaMs);
- state.value = result.done ? target : result.value;
- state.velocity = ((state.value - previousValue) / safeDeltaMs) * 1000;
-
- if (result.done) {
+ const current = resolveSpringPosition(
+ tSec,
+ target,
+ initialDelta,
+ initialVelocity,
+ dampingRatio,
+ undampedAngularFreq,
+ );
+
+ // Check convergence
+ let currentVelocity = 0;
+ if (dampingRatio < 1) {
+ // Only underdamped springs can overshoot, so we need velocity checks
+ const epsilon = 0.0001;
+ const ahead = resolveSpringPosition(
+ tSec + epsilon,
+ target,
+ initialDelta,
+ initialVelocity,
+ dampingRatio,
+ undampedAngularFreq,
+ );
+ currentVelocity = ((ahead - current) / epsilon) * 1000; // convert back to ms
+ }
+
+ const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;
+ const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;
+ const isDone = isBelowVelocityThreshold && isBelowDisplacementThreshold;
+
+ if (isDone) {
+ state.value = target;
state.velocity = 0;
+ } else {
+ state.value = current;
+ state.velocity = ((state.value - previousValue) / safeDeltaMs) * 1000;
}
return state.value;
@@ -131,11 +219,23 @@ export function getCursorSpringConfig(smoothingFactor: number): SpringConfig {
};
}
-export function getZoomSpringConfig(): SpringConfig {
+export function getZoomSpringConfig(smoothnessFactor = 1.0): SpringConfig {
+ const clamped = Math.max(0, Math.min(2, smoothnessFactor));
+
+ if (clamped <= 0) {
+ return {
+ stiffness: 1000,
+ damping: 100,
+ mass: 1,
+ restDelta: 0.0001,
+ restSpeed: 0.001,
+ };
+ }
+
return {
- stiffness: 320,
+ stiffness: 320 / clamped,
damping: 40,
- mass: 0.92,
+ mass: 0.92 * clamped,
restDelta: 0.0005,
restSpeed: 0.015,
};