greenlight-motion 0.3.2 → 0.3.4

package/README.md

@@ -17,16 +17,16 @@ The agent writes the video as data: a `project.json` and its files. The engine t
 ## Quick start
 
 ```bash
-npx greenlight-motion@0.3.2 doctor          # Node 18+, Chrome or Edge, WebGPU, H.264: what's missing and how to fix it
-npx greenlight-motion@0.3.2 init my-video   # a working starter: index.html, project.json, assets/
+npx greenlight-motion@0.3.4 doctor          # Node 18+, Chrome or Edge, WebGPU, H.264: what's missing and how to fix it
+npx greenlight-motion@0.3.4 init my-video   # a working starter: index.html, project.json, assets/
 # edit my-video/project.json, put pictures / video / sound in my-video/assets/
 # or: write my-video/script.json (a scene script, skill/references/scene-script.md), then
-npx greenlight-motion@0.3.2 script my-video # script.json → project.json with the Video Editor's own presets
-npx greenlight-motion@0.3.2 check my-video  # what to fix: missing files, template mistakes, blank frames, broken plugins
-npx greenlight-motion@0.3.2 stills my-video # frames + a labelled contact sheet, to look at
-npx greenlight-motion@0.3.2 render my-video --fps 60 --motion-blur
-npx greenlight-motion@0.3.2 pack my-video   # everything in ONE html file
-npx greenlight-motion@0.3.2 pack my-video --glvideo   # ONE .glvideo: double-clicked, it opens in GreenLight Dash
+npx greenlight-motion@0.3.4 script my-video # script.json → project.json with the Video Editor's own presets
+npx greenlight-motion@0.3.4 check my-video  # what to fix: missing files, template mistakes, blank frames, broken plugins
+npx greenlight-motion@0.3.4 stills my-video # frames + a labelled contact sheet, to look at
+npx greenlight-motion@0.3.4 render my-video --fps 60 --motion-blur
+npx greenlight-motion@0.3.4 pack my-video   # everything in ONE html file
+npx greenlight-motion@0.3.4 pack my-video --glvideo   # ONE .glvideo: double-clicked, it opens in GreenLight Dash
 ```
 
 Also: `trace` (every animated layer's values frame by frame, plus the layer's moments), `set key=value`
@@ -72,7 +72,7 @@ The engine is one classic script, so it runs from a double-clicked file, a CDN o
 
 ```html
 <div id="app"></div>
-<script src="https://cdn.jsdelivr.net/npm/greenlight-motion@0.3.2/dist/greenlight-motion.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/greenlight-motion@0.3.4/dist/greenlight-motion.js"></script>
 <script>
   GreenLightMotion.mountStudio(document.getElementById('app'), {
     project: { /* project.json */ },

package/dist/greenlight-motion-script.mjs

@@ -14804,8 +14804,18 @@ var num3 = (value, fallback = 0) => {
   const parsed = Number(value);
   return Number.isFinite(parsed) ? parsed : fallback;
 };
+var SLOW_SHARE = 0.25;
 var LOG_SLOW = -Math.log(SPEED_MIN);
 var LOG_FAST = Math.log(SPEED_MAX);
+var speedToNorm = (speed) => {
+  const v = clamp2(num3(speed, 1), SPEED_MIN, SPEED_MAX);
+  return v <= 1 ? SLOW_SHARE * (1 + Math.log(v) / LOG_SLOW) : SLOW_SHARE + (1 - SLOW_SHARE) * (Math.log(v) / LOG_FAST);
+};
+var normToSpeed = (norm) => {
+  const n2 = clamp2(num3(norm, 0), 0, 1);
+  const v = n2 <= SLOW_SHARE ? Math.exp((n2 / SLOW_SHARE - 1) * LOG_SLOW) : Math.exp((n2 - SLOW_SHARE) / (1 - SLOW_SHARE) * LOG_FAST);
+  return clamp2(v, SPEED_MIN, SPEED_MAX);
+};
 var cubic = (a, b2, c, d, t) => {
   const u = 1 - t;
   return u * u * u * a + 3 * u * u * t * b2 + 3 * u * t * t * c + t * t * t * d;
@@ -14815,10 +14825,154 @@ var cubicDeriv = (a, b2, c, d, t) => {
   return 3 * u * u * (b2 - a) + 6 * u * t * (c - b2) + 3 * t * t * (d - c);
 };
 var speedCurveCache = /* @__PURE__ */ new WeakMap();
+var TANGENT_MODES = ["auto", "linked", "separate", "flat"];
+var TANGENT_SET = new Set(TANGENT_MODES);
+var isPlotSpeedCurve = (points) => Array.isArray(points) && points.some((p) => p && TANGENT_SET.has(p.tan));
+function speedAutoSlopes(xs, ys) {
+  const n2 = xs.length;
+  const m = new Array(n2).fill(0);
+  if (n2 < 2) return m;
+  const h = [];
+  const d = [];
+  for (let i = 0; i < n2 - 1; i += 1) {
+    h[i] = xs[i + 1] - xs[i];
+    d[i] = h[i] > 1e-9 ? (ys[i + 1] - ys[i]) / h[i] : 0;
+  }
+  if (n2 === 2) {
+    m[0] = d[0];
+    m[1] = d[0];
+    return m;
+  }
+  for (let i = 1; i < n2 - 1; i += 1) {
+    if (d[i - 1] * d[i] <= 0) m[i] = 0;
+    else {
+      const w1 = 2 * h[i] + h[i - 1];
+      const w2 = h[i] + 2 * h[i - 1];
+      m[i] = (w1 + w2) / (w1 / d[i - 1] + w2 / d[i]);
+    }
+  }
+  const end = (h0, h1, d0, d1) => {
+    let s = ((2 * h0 + h1) * d0 - h0 * d1) / (h0 + h1);
+    if (Math.sign(s) !== Math.sign(d0)) s = 0;
+    else if (Math.sign(d0) !== Math.sign(d1) && Math.abs(s) > Math.abs(3 * d0)) s = 3 * d0;
+    return s;
+  };
+  m[0] = end(h[0], h[1], d[0], d[1]);
+  m[n2 - 1] = end(h[n2 - 2], h[n2 - 3], d[n2 - 2], d[n2 - 3]);
+  return m;
+}
+function fitHandleK(n0, m, k, dx) {
+  const dn = m * k * dx;
+  const y = n0 + dn;
+  if (y > 1 && dn > 0) return k * ((1 - n0) / dn);
+  if (y < 0 && dn < 0) return k * ((0 - n0) / dn);
+  return k;
+}
+function plotSegmentKinks(seg) {
+  const ys = [seg.y0, seg.y1, seg.y2, seg.y3];
+  if (Math.min(...ys) >= SLOW_SHARE || Math.max(...ys) <= SLOW_SHARE) return [];
+  const f2 = (t) => cubic(seg.y0, seg.y1, seg.y2, seg.y3, t) - SLOW_SHARE;
+  const out = [];
+  const N = 24;
+  for (let j = 0; j < N; j += 1) {
+    let lo = j / N;
+    let hi = (j + 1) / N;
+    if (f2(lo) * f2(hi) >= 0) continue;
+    for (let i = 0; i < 40; i += 1) {
+      const mid = (lo + hi) * 0.5;
+      if (f2(lo) * f2(mid) <= 0) hi = mid;
+      else lo = mid;
+    }
+    out.push((lo + hi) * 0.5);
+  }
+  return out;
+}
+function resolvePlotCurve(points) {
+  const sorted = points.filter((p) => p && Number.isFinite(Number(p.x)) && Number.isFinite(Number(p.y))).map((p) => {
+    const y = clamp2(num3(p.y, 1), SPEED_MIN, SPEED_MAX);
+    return {
+      x: num3(p.x),
+      y,
+      n: speedToNorm(y),
+      tan: TANGENT_SET.has(p.tan) ? p.tan : "auto",
+      mIn: num3(p.mIn),
+      mOut: num3(p.mOut),
+      kIn: clamp2(num3(p.kIn, AUTO_HANDLE), 0, 1),
+      kOut: clamp2(num3(p.kOut, AUTO_HANDLE), 0, 1)
+    };
+  }).sort((a, b2) => a.x - b2.x);
+  if (sorted.length === 0) return null;
+  const auto = speedAutoSlopes(sorted.map((p) => p.x), sorted.map((p) => p.n));
+  const anchors = sorted.map((p, i) => {
+    let { mIn, mOut, kIn, kOut } = p;
+    if (p.tan === "auto") {
+      mIn = auto[i];
+      mOut = auto[i];
+      kIn = AUTO_HANDLE;
+      kOut = AUTO_HANDLE;
+    } else if (p.tan === "flat") {
+      mIn = 0;
+      mOut = 0;
+    }
+    const prev = sorted[i - 1];
+    const next = sorted[i + 1];
+    const dxL = prev ? p.x - prev.x : 0;
+    const dxR = next ? next.x - p.x : 0;
+    const kInE = prev ? fitHandleK(p.n, mIn, kIn, -dxL) : 0;
+    const kOutE = next ? fitHandleK(p.n, mOut, kOut, dxR) : 0;
+    return {
+      x: p.x,
+      y: p.y,
+      n: p.n,
+      tan: p.tan,
+      mIn,
+      mOut,
+      kIn: kInE,
+      kOut: kOutE,
+      // The handles as plot-space offsets — what the editor draws and drags.
+      pIn: prev ? { x: -kInE * dxL, y: -mIn * kInE * dxL } : null,
+      pOut: next ? { x: kOutE * dxR, y: mOut * kOutE * dxR } : null
+    };
+  });
+  const segments = [];
+  for (let i = 0; i < anchors.length - 1; i += 1) {
+    const a = anchors[i];
+    const b2 = anchors[i + 1];
+    const seg = {
+      space: "norm",
+      linear: false,
+      x0: a.x,
+      x1: a.x + a.pOut.x,
+      x2: b2.x + b2.pIn.x,
+      x3: b2.x,
+      y0: a.n,
+      y1: a.n + a.pOut.y,
+      y2: b2.n + b2.pIn.y,
+      y3: b2.n
+    };
+    seg.flat = Math.abs(seg.y1 - seg.y0) < 1e-12 && Math.abs(seg.y2 - seg.y0) < 1e-12 && Math.abs(seg.y3 - seg.y0) < 1e-12;
+    seg.kinks = seg.flat ? [] : plotSegmentKinks(seg);
+    seg.area = segmentArea(seg, 1);
+    segments.push(seg);
+  }
+  return {
+    space: "norm",
+    anchors,
+    segments,
+    area: segments.reduce((sum, s) => sum + s.area, 0),
+    first: anchors[0],
+    last: anchors[anchors.length - 1]
+  };
+}
 function resolveSpeedCurve(points) {
   if (!Array.isArray(points) || points.length === 0) return null;
   const cached = speedCurveCache.get(points);
   if (cached) return cached;
+  if (isPlotSpeedCurve(points)) {
+    const plot = resolvePlotCurve(points);
+    if (plot) speedCurveCache.set(points, plot);
+    return plot;
+  }
   const sorted = points.filter((p) => p && Number.isFinite(Number(p.x)) && Number.isFinite(Number(p.y))).map((p) => ({
     x: num3(p.x),
     y: clamp2(num3(p.y, 1), SPEED_MIN, SPEED_MAX),
@@ -14886,16 +15040,18 @@ function solveSegmentT(seg, x) {
   if (span <= 1e-9) return 0;
   let t = clamp2((x - seg.x0) / span, 0, 1);
   if (seg.linear) return t;
-  for (let i = 0; i < 8; i += 1) {
+  const plot = seg.space === "norm";
+  const tol = plot ? 1e-14 : 1e-7;
+  for (let i = 0; i < (plot ? 30 : 8); i += 1) {
     const err = cubic(seg.x0, seg.x1, seg.x2, seg.x3, t) - x;
-    if (Math.abs(err) < 1e-7) return t;
+    if (Math.abs(err) < tol) return t;
     const d = cubicDeriv(seg.x0, seg.x1, seg.x2, seg.x3, t);
-    if (Math.abs(d) < 1e-7) break;
+    if (Math.abs(d) < (plot ? 1e-12 : 1e-7)) break;
     t = clamp2(t - err / d, 0, 1);
   }
   let lo = 0;
   let hi = 1;
-  for (let i = 0; i < 24; i += 1) {
+  for (let i = 0; i < (plot ? 60 : 24); i += 1) {
     const mid = (lo + hi) * 0.5;
     if (cubic(seg.x0, seg.x1, seg.x2, seg.x3, mid) < x) lo = mid;
     else hi = mid;
@@ -14910,6 +15066,7 @@ var GAUSS = [
 ];
 function segmentArea(seg, tEnd) {
   if (tEnd <= 0) return 0;
+  if (seg.space === "norm") return plotSegmentArea(seg, tEnd);
   if (seg.linear) {
     const width = (seg.x3 - seg.x0) * tEnd;
     const yAtT = seg.y0 + (seg.y3 - seg.y0) * tEnd;
@@ -14923,6 +15080,25 @@ function segmentArea(seg, tEnd) {
   }
   return sum * half;
 }
+function plotSegmentArea(seg, tEnd) {
+  const xAt = (t) => cubic(seg.x0, seg.x1, seg.x2, seg.x3, t);
+  if (seg.flat) return (xAt(tEnd) - seg.x0) * normToSpeed(seg.y0);
+  const cuts = [0, ...(seg.kinks || []).filter((t) => t < tEnd), tEnd];
+  const SUB = 8;
+  let sum = 0;
+  for (let c = 0; c < cuts.length - 1; c += 1) {
+    const step = (cuts[c + 1] - cuts[c]) / SUB;
+    for (let s = 0; s < SUB; s += 1) {
+      const half = step * 0.5;
+      const mid = cuts[c] + s * step + half;
+      for (const [node, weight] of GAUSS) {
+        const t = mid + half * node;
+        sum += weight * half * normToSpeed(cubic(seg.y0, seg.y1, seg.y2, seg.y3, t)) * cubicDeriv(seg.x0, seg.x1, seg.x2, seg.x3, t);
+      }
+    }
+  }
+  return sum;
+}
 var getAverageSpeed = (points) => {
   const curve = resolveSpeedCurve(points);
   if (!curve) return 1;