@erclx/canon 5.77.0 → 5.79.0

package/src/take/zoom/math-utils.ts

@@ -1,69 +0,0 @@
-// Vendored from OpenScreen at ca8104c, MIT. See NOTICE.md beside this file.
-// Source: src/components/video-editor/videoPlayback/mathUtils.ts
-
-export function clamp01(value: number) {
-  return Math.max(0, Math.min(1, value))
-}
-
-function sampleCubicBezier(a1: number, a2: number, t: number) {
-  const oneMinusT = 1 - t
-  return (
-    3 * a1 * oneMinusT * oneMinusT * t + 3 * a2 * oneMinusT * t * t + t * t * t
-  )
-}
-
-function sampleCubicBezierDerivative(a1: number, a2: number, t: number) {
-  const oneMinusT = 1 - t
-  return (
-    3 * a1 * oneMinusT * oneMinusT +
-    6 * (a2 - a1) * oneMinusT * t +
-    3 * (1 - a2) * t * t
-  )
-}
-
-export function cubicBezier(
-  x1: number,
-  y1: number,
-  x2: number,
-  y2: number,
-  t: number,
-) {
-  const targetX = clamp01(t)
-  let solvedT = targetX
-
-  for (let i = 0; i < 8; i += 1) {
-    const currentX = sampleCubicBezier(x1, x2, solvedT) - targetX
-    const currentDerivative = sampleCubicBezierDerivative(x1, x2, solvedT)
-
-    if (Math.abs(currentX) < 1e-6 || Math.abs(currentDerivative) < 1e-6) {
-      break
-    }
-
-    solvedT -= currentX / currentDerivative
-  }
-
-  let lower = 0
-  let upper = 1
-  solvedT = clamp01(solvedT)
-
-  for (let i = 0; i < 10; i += 1) {
-    const currentX = sampleCubicBezier(x1, x2, solvedT)
-    if (Math.abs(currentX - targetX) < 1e-6) {
-      break
-    }
-
-    if (currentX < targetX) {
-      lower = solvedT
-    } else {
-      upper = solvedT
-    }
-
-    solvedT = (lower + upper) / 2
-  }
-
-  return sampleCubicBezier(y1, y2, solvedT)
-}
-
-export function easeOutScreenStudio(t: number) {
-  return cubicBezier(0.16, 1, 0.3, 1, t)
-}

package/src/take/zoom/region-utils.ts

@@ -1,55 +0,0 @@
-// Vendored from OpenScreen at ca8104c, MIT. See NOTICE.md beside this file.
-// Source: src/components/video-editor/videoPlayback/zoomRegionUtils.ts and the
-// two window constants from constants.ts. The zoom-out window and the chained
-// pan's duration carry the operator's tuning, and NOTICE.md lists both.
-
-import {
-  clamp01,
-  cubicBezier,
-  easeOutScreenStudio,
-} from '@/take/zoom/math-utils'
-
-/** OpenScreen's 1015.05 ms, shortened to 700 ms for a quicker zoom-out. */
-export const TRANSITION_WINDOW_MS = 700
-/** OpenScreen's zoom-in window, 1.5 times its original 1015.05 ms window. */
-export const ZOOM_IN_TRANSITION_WINDOW_MS = 1015.05 * 1.5
-
-export const CHAINED_ZOOM_PAN_GAP_MS = 1500
-/** OpenScreen's 1000 ms, shortened to 600 ms. */
-export const CONNECTED_ZOOM_PAN_DURATION_MS = 600
-export const ZOOM_IN_OVERLAP_MS = 500
-
-export interface ZoomRegion {
-  startMs: number
-  endMs: number
-}
-
-export function lerp(start: number, end: number, amount: number) {
-  return start + (end - start) * amount
-}
-
-export function easeConnectedPan(value: number) {
-  return cubicBezier(0.1, 0.0, 0.2, 1.0, value)
-}
-
-export function computeRegionStrength(region: ZoomRegion, timeMs: number) {
-  const zoomInEnd = region.startMs + ZOOM_IN_OVERLAP_MS
-  const leadInStart = zoomInEnd - ZOOM_IN_TRANSITION_WINDOW_MS
-  const leadOutEnd = region.endMs + TRANSITION_WINDOW_MS
-
-  if (timeMs < leadInStart || timeMs > leadOutEnd) {
-    return 0
-  }
-
-  if (timeMs < zoomInEnd) {
-    const progress = (timeMs - leadInStart) / ZOOM_IN_TRANSITION_WINDOW_MS
-    return easeOutScreenStudio(progress)
-  }
-
-  if (timeMs <= region.endMs) {
-    return 1
-  }
-
-  const progress = clamp01((timeMs - region.endMs) / TRANSITION_WINDOW_MS)
-  return 1 - easeOutScreenStudio(progress)
-}

package/src/take/zoom/spring.ts

@@ -1,133 +0,0 @@
-// Adapted from OpenScreen at ca8104c, MIT. See NOTICE.md beside this file.
-// Source: getZoomSpringConfig, stepSpringValue, and clampDeltaMs in
-// src/components/video-editor/videoPlayback/motionSmoothing.ts, and stepAxis in
-// zoomSpring.ts. OpenScreen steps its spring through the `motion` package, and
-// this solves the same damped spring in closed form instead, so a target
-// inherits no dependency for one function.
-
-export interface SpringState {
-  value: number
-  velocity: number
-  initialized: boolean
-}
-
-export interface SpringConfig {
-  stiffness: number
-  damping: number
-  mass: number
-  restDelta: number
-  restSpeed: number
-}
-
-export const ZOOM_SPRING: SpringConfig = {
-  stiffness: 320,
-  damping: 40,
-  mass: 0.92,
-  restDelta: 0.0005,
-  restSpeed: 0.015,
-}
-
-export function createSpringState(initialValue = 0): SpringState {
-  return { value: initialValue, velocity: 0, initialized: false }
-}
-
-export function clampDeltaMs(deltaMs: number, fallbackMs = 1000 / 60) {
-  if (!Number.isFinite(deltaMs) || deltaMs <= 0) {
-    return fallbackMs
-  }
-
-  return Math.min(80, Math.max(1, deltaMs))
-}
-
-/**
- * Advances one axis toward `target` by `deltaMs`. The first call snaps to the
- * target, a spring at rest stays there, and a step that would cross a moving
- * target lands on it with no velocity, which keeps a quick chase from wobbling
- * on a reversal.
- */
-export function stepSpring(
-  state: SpringState,
-  target: number,
-  deltaMs: number,
-  config: SpringConfig = ZOOM_SPRING,
-): number {
-  if (!state.initialized || !Number.isFinite(state.value)) {
-    state.value = target
-    state.velocity = 0
-    state.initialized = true
-    return state.value
-  }
-
-  if (
-    Math.abs(target - state.value) <= config.restDelta &&
-    Math.abs(state.velocity) <= config.restSpeed
-  ) {
-    state.value = target
-    state.velocity = 0
-    return state.value
-  }
-
-  const before = state.value
-  const [offset, velocity] = solve(
-    state.value - target,
-    state.velocity,
-    clampDeltaMs(deltaMs) / 1000,
-    config,
-  )
-  const after = target + offset
-
-  const crossed =
-    (before <= target && after > target) || (before >= target && after < target)
-  if (crossed) {
-    state.value = target
-    state.velocity = 0
-    return target
-  }
-
-  state.value = after
-  state.velocity = velocity
-  return after
-}
-
-/**
- * The displacement and velocity of a damped spring `seconds` after it sat at
- * `x0` from rest length moving at `v0`, for each of the three damping regimes.
- */
-function solve(
-  x0: number,
-  v0: number,
-  seconds: number,
-  { stiffness, damping, mass }: SpringConfig,
-): [number, number] {
-  const omega = Math.sqrt(stiffness / mass)
-  const zeta = damping / (2 * Math.sqrt(stiffness * mass))
-  const t = seconds
-
-  if (zeta < 1) {
-    const omegaD = omega * Math.sqrt(1 - zeta * zeta)
-    const decay = Math.exp(-zeta * omega * t)
-    const b = (v0 + zeta * omega * x0) / omegaD
-    const cos = Math.cos(omegaD * t)
-    const sin = Math.sin(omegaD * t)
-    const x = decay * (x0 * cos + b * sin)
-    const v =
-      decay *
-      (-zeta * omega * (x0 * cos + b * sin) + omegaD * (b * cos - x0 * sin))
-    return [x, v]
-  }
-
-  if (zeta === 1) {
-    const decay = Math.exp(-omega * t)
-    const b = v0 + omega * x0
-    return [(x0 + b * t) * decay, (b - omega * (x0 + b * t)) * decay]
-  }
-
-  const root = Math.sqrt(zeta * zeta - 1)
-  const r1 = -omega * (zeta - root)
-  const r2 = -omega * (zeta + root)
-  const c1 = (v0 - r2 * x0) / (r1 - r2)
-  const c2 = x0 - c1
-  const e1 = Math.exp(r1 * t)
-  const e2 = Math.exp(r2 * t)
-  return [c1 * e1 + c2 * e2, c1 * r1 * e1 + c2 * r2 * e2]
-}