@idle-screens/schema 3.11.0 → 3.11.1

package/dist/index.js

@@ -5553,17 +5553,17 @@ function adviseSequence(seq, viewport = { width: 1920, height: 1080 }) {
     });
   }
   for (let i = 0; i < seq.segments.length - 1; i++) {
+    const tr = seq.segments[i].transition;
     const lumaA = backgroundLuma(resolveTimelineAt(seq.segments[i].scene, seq.segments[i].duration ?? 0));
     const lumaB = backgroundLuma(resolveTimelineAt(seq.segments[i + 1].scene, 0));
     const delta = Math.abs(lumaA - lumaB);
-    if (delta > 0.5) {
+    if (delta > 0.5 && tr?.type !== "fade") {
       warnings.push({
         path: `segments[${i}]`,
         code: "boundary-luminance-jump",
-        message: `background luminance jumps ${delta.toFixed(2)} at boundary ${i}\u2192${i + 1} \u2014 may flash on cut`
+        message: `background luminance jumps ${delta.toFixed(2)} at boundary ${i}\u2192${i + 1} \u2014 may flash on cut${tr === void 0 || tr.type === "cut" ? `; declare transition: { type: 'fade', dur } on segments[${i}] to ramp it` : ""}`
       });
     }
-    const tr = seq.segments[i].transition;
     if (tr?.type === "morph") {
       const sigA = structuralSignature(seq.segments[i].scene);
       const sigB = structuralSignature(seq.segments[i + 1].scene);
@@ -5829,6 +5829,37 @@ function distanceToOutline(pts, x, y) {
   }
   return Math.sqrt(best);
 }
+function rotatedBoxCoverage(cx, cy, hx, hy, rot, x0, y0, x1, y1) {
+  const cr = Math.cos(rot), sr = Math.sin(rot);
+  let poly = [[-hx, -hy], [hx, -hy], [hx, hy], [-hx, hy]].map(([x, y]) => [cx + x * cr - y * sr, cy + x * sr + y * cr]);
+  const clip = (inside, cut) => {
+    const out = [];
+    for (let i = 0; i < poly.length; i++) {
+      const a = poly[i], b = poly[(i + 1) % poly.length];
+      if (inside(a)) {
+        out.push(a);
+        if (!inside(b)) out.push(cut(a, b));
+      } else if (inside(b)) out.push(cut(a, b));
+    }
+    poly = out;
+  };
+  const atX = (x) => (a, b) => [x, a[1] + (x - a[0]) / (b[0] - a[0]) * (b[1] - a[1])];
+  const atY = (y) => (a, b) => [a[0] + (y - a[1]) / (b[1] - a[1]) * (b[0] - a[0]), y];
+  clip((p) => p[0] >= x0, atX(x0));
+  if (!poly.length) return 0;
+  clip((p) => p[0] <= x1, atX(x1));
+  if (!poly.length) return 0;
+  clip((p) => p[1] >= y0, atY(y0));
+  if (!poly.length) return 0;
+  clip((p) => p[1] <= y1, atY(y1));
+  if (!poly.length) return 0;
+  let area = 0;
+  for (let i = 0; i < poly.length; i++) {
+    const a = poly[i], b = poly[(i + 1) % poly.length];
+    area += a[0] * b[1] - b[0] * a[1];
+  }
+  return Math.abs(area) / 2 / ((x1 - x0) * (y1 - y0));
+}
 function luminanceGrid(spec, opts = {}) {
   spec = resolveTimelineAt(spec, opts.t ?? 5e3);
   const scene = buildScene(spec, opts);
@@ -6051,6 +6082,7 @@ function luminanceGrid(spec, opts = {}) {
         let centerY = p.y;
         let halfX = sz / 2;
         let halfY = s.kind === "rect" ? (e.size2 ?? sz) * (e.size > 0 ? sz / e.size : 1) / 2 : sz / 2;
+        let boxRot = 0, boxHx = 0, boxHy = 0;
         if (s.kind === "text") {
           const box = textBox(s, e, p);
           centerX = box.cx;
@@ -6073,8 +6105,23 @@ function luminanceGrid(spec, opts = {}) {
           const sr = Math.sin(rot);
           centerX = p.x + box.cx * cr - box.cy * sr;
           centerY = p.y + box.cx * sr + box.cy * cr;
+          boxRot = rot;
+          boxHx = box.halfX;
+          boxHy = box.halfY;
           halfX = Math.abs(box.halfX * cr) + Math.abs(box.halfY * sr);
           halfY = Math.abs(box.halfX * sr) + Math.abs(box.halfY * cr);
+        } else if (s.kind === "rect") {
+          const rot = rotationAt(e, tPass);
+          if (rot) {
+            boxRot = rot;
+            boxHx = halfX;
+            boxHy = halfY;
+            const cr = Math.abs(Math.cos(rot));
+            const sr = Math.abs(Math.sin(rot));
+            const hx = halfX * cr + halfY * sr;
+            halfY = halfX * sr + halfY * cr;
+            halfX = hx;
+          }
         }
         const circular = s.kind === "circle" || s.kind === "ring" || s.kind === "polygon";
         const soft = (s.kind === "circle" || s.kind === "polygon") && !!s.soft;
@@ -6088,7 +6135,10 @@ function luminanceGrid(spec, opts = {}) {
         const r0 = Math.max(0, Math.floor((centerY - reachY) / cellH));
         const r1 = Math.min(rows - 1, Math.floor((centerY + reachY) / cellH));
         const inkWeight = (s.kind === "text" || s.kind === "emoji" || s.kind === "textBlock" ? 0.55 : 1) * (s.kind === "textBlock" ? textBlockRevealFraction(s, w, h, t) * (s.opacity ?? 1) : 1);
+        const byArea = s.kind === "rect" || s.kind === "bar";
         for (let r = r0; r <= r1; r++) {
+          const fy = byArea ? Math.max(0, Math.min((r + 1) * cellH, centerY + halfY) - Math.max(r * cellH, centerY - halfY)) / cellH : 1;
+          if (fy <= 0) continue;
           for (let c = c0; c <= c1; c++) {
             const dx = (c + 0.5) * cellW - centerX;
             const dy = (r + 0.5) * cellH - centerY;
@@ -6112,6 +6162,14 @@ function luminanceGrid(spec, opts = {}) {
                 wgt = soft ? Math.max(0.1, 1 - d / Math.max(halfX, 1e-6)) : 1;
               }
               compose(r * cols + c, lum, a * wgt * shapeWeight, layer.blend);
+            } else if (byArea) {
+              if (boxRot) {
+                const cov = rotatedBoxCoverage(centerX, centerY, boxHx, boxHy, boxRot, c * cellW, r * cellH, (c + 1) * cellW, (r + 1) * cellH);
+                if (cov > 0) compose(r * cols + c, lum, a * shapeWeight * cov, layer.blend);
+              } else {
+                const fx = Math.max(0, Math.min((c + 1) * cellW, centerX + halfX) - Math.max(c * cellW, centerX - halfX)) / cellW;
+                if (fx > 0) compose(r * cols + c, lum, a * shapeWeight * fx * fy, layer.blend);
+              }
             } else {
               compose(r * cols + c, lum, a * inkWeight * shapeWeight, layer.blend);
             }