framerudiments 0.4.4__tar.gz → 0.4.6__tar.gz

{framerudiments-0.4.4/src/framerudiments.egg-info → framerudiments-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: framerudiments
-Version: 0.4.4
+Version: 0.4.6
 Summary: Deterministic Shorts and lyric visualisers using DanceRudiments and StemLab evidence.
 Author: Kieran Simkin
 License-Expression: MIT
@@ -31,6 +31,31 @@ Dynamic: license-file
 
 # FrameRudiments
 
+## Complete x264 preset range
+
+Version 0.4.6 accepts every named libx264 preset from `ultrafast` through
+`placebo`, including the previously rejected `slower` and `veryslow` delivery
+profiles. The selected preset and CRF remain explicit render arguments and are
+retained in the encode command and manifest evidence. A stronger preset can
+improve compression efficiency; it does not raise project resolution, mesh
+density, frame rate or source sampling on its own.
+
+The existing encoded demonstrations below remain representative because this
+change alters compression controls rather than composition or motion. No new
+image or video was generated solely to illustrate byte-level encoder effort.
+
+## Palette-controlled high-detail feedback
+
+Version 0.4.4 adds optional Butterchurn mesh dimensions and a deterministic
+multi-stop palette grade after each full-frame visualiser stage. This lets a
+1080p visualiser retain more spatial detail and conform feedback colours to a
+campaign palette while clean routed overlays keep their authored appearance.
+See [full-frame visualisers](docs/visualisers.md).
+
+![Generated test illustration comparing ungraded and palette-graded output](docs/media/palette-grade-comparison.png)
+
+Generated test illustration; no private campaign media is included.
+
 ## Five fire methods and ice
 
 Version 0.4.3 adds evidence-recorded three-stop fire palettes, an optional
@@ -204,6 +229,8 @@ text. Existing plain text remains untouched unless configured. Set `word_indicat
 native 1-dimensional DanceRudiment-driven bouncing sprite that tracks the active word of
 the full line. Its particle field can be continuous, word/cue-triggered, or hybrid;
 trigger windows independently change colour, density, size, glow and burst count.
+An optional between-word travel arc rises before the next timestamp and lands
+exactly on its encoded word frame.
 See [rich lyric reference](docs/rich-lyric-effects.md) and the
 [CI-generated demo](https://kieransimkin.github.io/FrameRudiments/rich-lyrics/).
 

{framerudiments-0.4.4 → framerudiments-0.4.6}/README.md

@@ -1,5 +1,30 @@
 # FrameRudiments
 
+## Complete x264 preset range
+
+Version 0.4.6 accepts every named libx264 preset from `ultrafast` through
+`placebo`, including the previously rejected `slower` and `veryslow` delivery
+profiles. The selected preset and CRF remain explicit render arguments and are
+retained in the encode command and manifest evidence. A stronger preset can
+improve compression efficiency; it does not raise project resolution, mesh
+density, frame rate or source sampling on its own.
+
+The existing encoded demonstrations below remain representative because this
+change alters compression controls rather than composition or motion. No new
+image or video was generated solely to illustrate byte-level encoder effort.
+
+## Palette-controlled high-detail feedback
+
+Version 0.4.4 adds optional Butterchurn mesh dimensions and a deterministic
+multi-stop palette grade after each full-frame visualiser stage. This lets a
+1080p visualiser retain more spatial detail and conform feedback colours to a
+campaign palette while clean routed overlays keep their authored appearance.
+See [full-frame visualisers](docs/visualisers.md).
+
+![Generated test illustration comparing ungraded and palette-graded output](docs/media/palette-grade-comparison.png)
+
+Generated test illustration; no private campaign media is included.
+
 ## Five fire methods and ice
 
 Version 0.4.3 adds evidence-recorded three-stop fire palettes, an optional
@@ -173,6 +198,8 @@ text. Existing plain text remains untouched unless configured. Set `word_indicat
 native 1-dimensional DanceRudiment-driven bouncing sprite that tracks the active word of
 the full line. Its particle field can be continuous, word/cue-triggered, or hybrid;
 trigger windows independently change colour, density, size, glow and burst count.
+An optional between-word travel arc rises before the next timestamp and lands
+exactly on its encoded word frame.
 See [rich lyric reference](docs/rich-lyric-effects.md) and the
 [CI-generated demo](https://kieransimkin.github.io/FrameRudiments/rich-lyrics/).
 

{framerudiments-0.4.4 → framerudiments-0.4.6}/RELEASE_NOTES.md

@@ -1,3 +1,53 @@
+# FrameRudiments 0.4.6
+
+- Encoding now accepts the complete named libx264 preset range: `ultrafast`,
+  `superfast`, `veryfast`, `faster`, `fast`, `medium`, `slow`, `slower`,
+  `veryslow` and `placebo`.
+- Focused regression coverage verifies every accepted preset reaches the exact
+  FFmpeg command and that unknown values still fail closed.
+- Linux CI, gallery and release jobs now pin Ubuntu 24.04 so runner-image
+  migrations cannot silently change the release environment mid-validation.
+- Linux render dependencies use one shared installer with bounded timeouts and
+  retries, preventing a stalled package mirror from hanging a release forever.
+- Preset strength remains separate from composition resolution, visualiser
+  mesh density, frame rate and source sampling. Existing public demonstration
+  media therefore remains applicable; no new visual was generated for this
+  command-validation-only change.
+
+# FrameRudiments 0.4.5
+
+- Word indicators can now travel between encoded word hits with a configurable
+  arc and land on the next word's authoritative frame, while retaining the
+  existing after-hit mode.
+- projectM stages accept source-time preset timelines and perform bounded soft
+  transitions on the existing feedback instance, with every switch recorded in
+  render evidence.
+- Lyric layers can feed the visualiser only during their final bounded pips when
+  a real blank gap follows, allowing the departing line to dissolve into the
+  background without contaminating immediate line-to-line changes.
+- Project-format and visualiser documentation describe the new contracts;
+  focused regression coverage preserves clock, preset trust, routing and
+  evidence behaviour. Private campaign artwork and audio remain outside the
+  distribution.
+
+## High-detail, palette-controlled visualiser output
+
+- Butterchurn stages accept bounded `mesh_width` and `mesh_height` values. The
+  existing 64×48 mesh remains the default; projects can request additional
+  spatial detail without changing their encoded dimensions or frame rate.
+- Any Butterchurn or projectM stage can apply `output_palette_grade` after the
+  engine output and before the next stage or clean routing overlay. Two to
+  sixteen ordered CSS colours define a deterministic luminance palette; alpha,
+  PCM, feedback state and the source clock remain unchanged.
+- The exact mesh and grade configuration is retained in plan and manifest
+  evidence. Focused validation covers schema bounds, deterministic pixels,
+  alpha preservation, stage order and routed overlays.
+
+![Generated comparison of ungraded and palette-graded synthetic output](docs/media/palette-grade-comparison.png)
+
+Generated test illustration; no private campaign media. A video is omitted
+because this stateless grade adds no temporal behaviour to demonstrate.
+
 # FrameRudiments 0.4.4
 
 - Spectrum views accept a validated `style.grid` boolean. Set it to `false` to remove the three fixed dB guide lines while retaining calibrated bars and moving peak holds; label visibility remains independent.

{framerudiments-0.4.4 → framerudiments-0.4.6}/docs/project-format.md

@@ -23,6 +23,7 @@ the inputs are checked again before and after a render.
 | `layers` | Ordered sprite, legacy bar and modular rudiment layers described below. |
 | Native radial petals | Use `type: "rudiment", renderer: "rangoli"` with independent scale/spin/lift axes; see [rangoli configuration and actual demo](rangoli.md). |
 | `visualiser_routing` | Optional per-element GPU input/overlay policies. Feed continuously, only for first N native pips after visibility onset, or never; see [routing](visualiser-routing.md). |
+| `effects` | Ordered Butterchurn/projectM stages. Butterchurn may set a denser `mesh_width`/`mesh_height`; any stage may set a multi-stop `output_palette_grade` applied before the next stage or clean routing overlay. projectM stages may use `preset_timeline` for ordered changes at canonical source seconds through the native soft transition on one retained feedback instance. See [visualisers](visualisers.md). |
 | `lyric_art` | `{items: [{text, asset}], placement: <sprite fields>, fallback: "text" or "error"}`. Exact text lookup preserves canonical lyric association. `error` requires every visible lyric to have an asset. |
 | `stemlab_loop` | `{file: <pinned loops report>, id: <accepted loop id>}`; imports native bounds/rate, verifies source SHA, rejects conflicting explicit audio values. Does not approve a seam. |
 
@@ -148,7 +149,9 @@ Set `effects` and optional checksum-pinned `font` on any `captions`, `word_capti
 emboss, inner/outer glow and drop shadow. `word_indicator` needs both line and word LRC,
 a full-line captions block and a selected native one-axis Rudiment bounce driver. Its
 particle options support constant emission, timed word/cue bursts and trigger-driven
-appearance changes; see [full schema and examples](rich-lyric-effects.md).
+appearance changes. `travel_mode: "between_words"` can use the pinned next-word
+timestamp to follow a smooth pre-hit arc and land exactly on the word frame;
+see [full schema and examples](rich-lyric-effects.md).
 
 ## Optional full-frame effects
 

{framerudiments-0.4.4 → framerudiments-0.4.6}/docs/rich-lyric-effects.md

@@ -92,6 +92,8 @@ DanceRudiment axis to the y-coordinate. The cursor may use a `spark`, `orb`,
     "glow": 5,
     "opacity": 1,
     "travel_frames": 10,
+    "travel_mode": "between_words",
+    "travel_arc": 24,
     "offset_x": 0,
     "offset_y": 14,
     "bounce": {
@@ -123,7 +125,13 @@ The `sprite` field is optional. For custom files, the supplied SHA-256 is
 mandatory; changing images requires changing the project reference. The same
 built-in transparent glyphs work without external assets. `position` accepts
 `above`, `below` or `on`. `travel_frames` (0–120) determines the smoothstep
-movement to the next word. Selecting `bounce.axis` projects one native
+movement window. The default `travel_mode: "after_hit"` preserves the original
+behaviour, moving from the preceding word after the new timestamp. Use
+`travel_mode: "between_words"` to move during the final `travel_frames` before
+the next encoded word timestamp; `travel_arc` (0–250 pixels) adds a sine-shaped
+lift that is zero at both ends, so the sprite lands exactly on the next word
+frame. This uses only the pinned word ledger and does not infer timing from the
+audio. Selecting `bounce.axis` projects one native
 DanceRudiment dimension only; captured recordings retain their own source
 clock, and rhythmic named/table motions use the corrected BPM map if enabled.
 

{framerudiments-0.4.4 → framerudiments-0.4.6}/docs/visualiser-routing.md

@@ -55,6 +55,7 @@ misspellings are errors rather than silent omissions.
 | --- | --- |
 | `continuous` | Inject this element on every output frame where it has visible alpha pixels |
 | `first_pips` | Inject from the first visible frame until `duration_pips` source-clock pips have elapsed, using the half-open interval `[appearance_pip, appearance_pip + duration_pips)` |
+| `last_pips` | With `retrigger: lyric`, inject the visible lyric element for the final `duration_pips` before the next effective lyric state becomes blank. A same-frame clear followed by a new nonblank line is an immediate handoff and does not trigger this window. |
 | `never` | No pixels from this element enter the first GPU stage; it can still be overlaid |
 
 `duration_pips` must be a finite number between 0 and 65,536. One beat is
@@ -64,6 +65,13 @@ beat count over repeated audio excerpts. Therefore a 64-pip window may be
 shorter or longer than half a second as the music accelerates or slows.
 A zero-pip window never injects the element.
 
+`last_pips` is designed for lyric tails that should enter feedback only before
+a genuine silent display gap. It requires `retrigger: lyric`, an active nonblank
+lyric, and a known next effective lyric event. The route report records
+`remaining_pips` and `lyric_gap_exit` so the decision is auditable. With
+`overlay: true`, the readable original remains visible while its copy enters the
+feedback pipeline; at the blank event both disappear from the clean layer.
+
 `retrigger` controls how the window starts:
 
 - `reappearance` (default): reset the window when an element becomes visible

{framerudiments-0.4.4 → framerudiments-0.4.6}/docs/visualisers.md

@@ -22,9 +22,71 @@ Original paired presets are `feedback` (audio-reactive swirl/echo),
 distortion of the frame's texture coordinates). They are examples, not a claim
 that two independent MilkDrop implementations produce identical pixels.
 
+Butterchurn stages may set `mesh_width` (16–256) and `mesh_height` (12–256).
+The default remains 64×48 for pixel compatibility. A denser mesh such as
+128×72 gives the warp field more spatial detail at 1920×1080, but it does not
+change the encoded dimensions or frame rate and can increase GPU cost.
+
+Each stage may also apply a deterministic multi-stop `output_palette_grade`
+after its visualiser output and before the next stage or the clean routing
+overlay:
+
+```json
+{
+  "id": "clay-feedback",
+  "engine": "butterchurn",
+  "preset": "feedback",
+  "mesh_width": 128,
+  "mesh_height": 72,
+  "output_palette_grade": {
+    "stops": ["#100b19", "#171b37", "#572417", "#8a3c25", "#c49986"],
+    "amount": 0.85
+  }
+}
+```
+
+The grade maps output luminance through 2–16 ordered CSS colours in
+sRGB, blends that result with the original by `amount` (0–1), and preserves
+alpha. It does not change PCM, motion, feedback state or the source clock.
+When `visualiser_routing` keeps lyrics or sprites as a clean overlay, that
+overlay is composited after the grade and retains its authored colours.
+
+![Generated test illustration comparing ungraded and multi-stop graded output](media/palette-grade-comparison.png)
+
+Generated test illustration; it demonstrates the colour transform rather than
+evidence from a private campaign. A video is omitted because the grade is a
+stateless per-frame colour operation with no temporal behaviour.
+
 ## Per-element feed and clean overlay routing
 
 FrameRudiments supports an optional project-level `visualiser_routing` object.
+
+## Source-timed projectM preset changes
+
+A projectM stage may retain one feedback instance while changing presets at
+canonical source-audio times. The native projectM soft transition blends the
+old and new preset; no frame is skipped and the existing PCM/output clock stays
+authoritative.
+
+```json
+{
+  "id": "section-visualiser",
+  "engine": "projectm",
+  "preset": "feedback",
+  "preset_timeline": [
+    {"at_source_seconds": 62.46, "preset": "kaleidoscope", "transition_seconds": 0.42},
+    {"at_source_seconds": 128.60, "preset": "julia", "transition_seconds": 0.42}
+  ]
+}
+```
+
+Times are measured in the unchanged source recording. Entries must be strictly
+increasing. Built-in names retain their package hashes; external `.milk` files
+still require `trusted_preset: true` on the individual timeline entry. Timeline
+switches currently use projectM because its pinned native API provides an
+auditable soft-cut transition on the same renderer instance. The manifest
+records the scheduled boundary, actual frame/source time, preset hash and blend
+duration.
 It controls the **input RGBA texture** entering the first Butterchurn or
 projectM stage and independently decides which original layers are composited
 cleanly above the **last** visualiser result. The subsequent stages remain

{framerudiments-0.4.4 → framerudiments-0.4.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "framerudiments"
-version = "0.4.4"
+version = "0.4.6"
 description = "Deterministic Shorts and lyric visualisers using DanceRudiments and StemLab evidence."
 requires-python = ">=3.11"
 readme = "README.md"

{framerudiments-0.4.4 → framerudiments-0.4.6}/src/framerudiments/__init__.py

@@ -1,6 +1,6 @@
 """Offline frame composition on a traceable musical clock."""
 
-__version__ = "0.4.4"
+__version__ = "0.4.6"
 
 from .project import Project
 from .render import render, preflight

{framerudiments-0.4.4 → framerudiments-0.4.6}/src/framerudiments/compositor.py

@@ -33,6 +33,8 @@ class FrameContext:
     lyric: dict | None
     cue: dict | None
     word: dict | None = None
+    lyric_next: dict | None = None
+    lyric_next_beat: float | None = None
 
 
 class TextBlock:
@@ -413,6 +415,7 @@ class Compositor:
     def context(self, frame):
         p = self.project
         lyric = self.lyrics.at(frame)
+        lyric_next = self.lyrics.next_effective(frame)
         word = self.words.at(frame, lyric if p.lyrics else None) if self.words else None
         return FrameContext(
             frame,
@@ -422,6 +425,8 @@ class Compositor:
             lyric,
             self.cues.at(frame),
             word,
+            lyric_next,
+            p.continuous_beat(lyric_next["frame"]) if lyric_next is not None else None,
         )
 
     def _caption_draw(self, image, text, ctx):

{framerudiments-0.4.4 → framerudiments-0.4.6}/src/framerudiments/encoding.py

@@ -8,6 +8,20 @@ import shutil
 import subprocess
 
 
+X264_PRESETS = (
+    "ultrafast",
+    "superfast",
+    "veryfast",
+    "faster",
+    "fast",
+    "medium",
+    "slow",
+    "slower",
+    "veryslow",
+    "placebo",
+)
+
+
 def binaries(ffmpeg=None, ffprobe=None):
     ffmpeg = ffmpeg or os.environ.get("FRAMERUDIMENTS_FFMPEG") or shutil.which("ffmpeg")
     if not ffmpeg:
@@ -56,7 +70,7 @@ def audio_filters(project):
 
 
 def command(project, output, ffmpeg, *, preset="fast", crf=20):
-    if preset not in {"ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow"}:
+    if preset not in X264_PRESETS:
         raise ValueError("Unsupported encoder preset")
     if not isinstance(crf, int) or not 0 <= crf <= 51:
         raise ValueError("CRF must be an integer in [0,51]")

{framerudiments-0.4.4 → framerudiments-0.4.6}/src/framerudiments/lyric_indicator.py

@@ -107,6 +107,8 @@ class WordIndicator:
                 "offset_x",
                 "offset_y",
                 "travel_frames",
+                "travel_mode",
+                "travel_arc",
                 "bounce",
                 "rotation",
                 "particles",
@@ -142,6 +144,25 @@ class WordIndicator:
         self.travel = integer(
             config.get("travel_frames", 8), "indicator transition frames", maximum=120 * time_factor
         )
+        self.travel_mode = config.get("travel_mode", "after_hit")
+        if self.travel_mode not in {"after_hit", "between_words"}:
+            raise ValueError("Indicator travel_mode must be after_hit or between_words")
+        self.travel_arc = number(
+            config.get("travel_arc", 0), "indicator travel arc", minimum=0, maximum=250
+        )
+        self._next_words = {}
+        timed_words = [
+            row for row in project.words if row.get("text") and row.get("word_index") is not None
+        ]
+        for current, following in zip(timed_words, timed_words[1:]):
+            if (
+                current.get("cycle") == following.get("cycle")
+                and current.get("line_frame") == following.get("line_frame")
+                and current.get("line_order") == following.get("line_order")
+                and following["frame"] > current["frame"]
+            ):
+                key = (current["frame"], current.get("source_order"), current.get("cycle"))
+                self._next_words[key] = following
         self.style = dict(
             indicator_size=number(config.get("size", 18), "indicator size", minimum=2, maximum=128),
             indicator_glow=number(config.get("glow", 4), "indicator glow", minimum=0, maximum=24),
@@ -282,7 +303,13 @@ class WordIndicator:
             font=self.font_ref,
             glyph=self.glyph,
             mode=self.particle_mode,
-            source_clock="encoded words/cues + native bounce axis",
+            source_clock="encoded words/cues + optional native bounce axis",
+            travel={
+                "mode": self.travel_mode,
+                "frames": self.travel,
+                "arc_pixels": self.travel_arc,
+                "landing_authority": "next encoded word frame" if self.travel_mode == "between_words" else None,
+            },
             bounce=self.bounce.evidence if self.bounce else None,
             modulations=self.modulations.evidence,
             cue_file=self.cue_ref,
@@ -323,7 +350,21 @@ class WordIndicator:
         if not 0 <= i < len(positions):
             return None
         x, y = positions[i]
-        if self.travel and i:
+        arc = 0.0
+        if self.travel_mode == "between_words" and self.travel:
+            key = (word["frame"], word.get("source_order"), word.get("cycle"))
+            following = self._next_words.get(key)
+            if following is not None:
+                target_index = following["word_index"]
+                start = max(word["frame"], following["frame"] - self.travel)
+                if frame >= start and 0 <= target_index < len(positions):
+                    u = _unit((frame - start) / max(1, following["frame"] - start))
+                    smooth = u * u * (3 - 2 * u)
+                    target = positions[target_index]
+                    x = x + (target[0] - x) * smooth
+                    y = y + (target[1] - y) * smooth
+                    arc = math.sin(math.pi * u) * self.travel_arc
+        elif self.travel and i:
             u = _unit((frame - word["frame"]) / self.travel)
             smooth = u * u * (3 - 2 * u)
             before = positions[i - 1]
@@ -337,6 +378,7 @@ class WordIndicator:
             y -= h / 2 + style["offset_y"]
         else:
             y += self.block.maximum * 0.5
+        y -= arc
         if self.bounce:
             values = self.bounce.sample(ctx.source_seconds, continuous_beat=ctx.beat)
             y -= values[self.bounce_axis] * style["bounce_amplitude"]
@@ -543,5 +585,7 @@ class WordIndicator:
             particles_active=active,
             cue_trigger=ctx.frame in self._events["cue"],
             word_trigger=ctx.frame in self._events["word"],
+            travel_mode=self.travel_mode,
+            landed=ctx.frame == ctx.word["frame"],
         )
         return layer.getchannel("A").getbbox()

{framerudiments-0.4.4 → framerudiments-0.4.6}/src/framerudiments/projectm_backend.py

@@ -169,6 +169,7 @@ class ProjectMBackend:
             "set_preset_locked": (None, [h, C.c_bool]),
             "set_hard_cut_enabled": (None, [h, C.c_bool]),
             "set_preset_start_clean": (None, [h, C.c_bool]),
+            "set_soft_cut_duration": (None, [h, C.c_double]),
             "load_preset_file": (None, [h, C.c_char_p, C.c_bool]),
             "set_preset_switch_failed_event_callback": (None, [h, C.c_void_p, h]),
             "pcm_add_float": (None, [h, C.POINTER(C.c_float), C.c_uint, C.c_int]),
@@ -202,6 +203,24 @@ class ProjectMBackend:
     def advance(self, image, context, pcm, *, capture=False):
         return self.process(image, context, pcm, capture=capture)
 
+    def switch_preset(self, preset, transition_seconds):
+        """Change preset on the existing feedback instance with projectM's soft transition."""
+        self.glfw.make_context_current(self.window)
+        self.lib.projectm_set_soft_cut_duration(self.handle, float(transition_seconds))
+        self.lib.projectm_load_preset_file(
+            self.handle,
+            os.fsencode(preset),
+            bool(transition_seconds),
+        )
+        self._check()
+        self.evidence.setdefault("preset_switches", []).append(
+            dict(
+                preset_path=str(Path(preset).resolve()),
+                preset_sha256=sha256(preset),
+                transition_seconds=float(transition_seconds),
+            )
+        )
+
     def process(self, image, context, pcm, *, capture=True):
         gl = self.gl
         self.glfw.make_context_current(self.window)

{framerudiments-0.4.4 → framerudiments-0.4.6}/src/framerudiments/timeline.py

@@ -111,6 +111,21 @@ class EventTrack:
         index = bisect_right(self.frames, frame) - 1
         return self.events[index] if index >= 0 else None
 
+    def next_effective(self, frame):
+        """Return the rendered state at the next distinct event frame.
+
+        Several lyric ledgers deliberately write a blank clear followed by the
+        next line at the same frame.  The last event at that frame is the state
+        a viewer actually sees, so a same-frame clear must not be mistaken for
+        a real lyric gap.
+        """
+        index = bisect_right(self.frames, frame)
+        if index >= len(self.events):
+            return None
+        next_frame = self.events[index]["frame"]
+        end = bisect_right(self.frames, next_frame)
+        return self.events[end - 1]
+
     def neighbours(self, frame):
         index = bisect_right(self.frames, frame) - 1
         current = self.events[index] if index >= 0 else None

{framerudiments-0.4.4 → framerudiments-0.4.6}/src/framerudiments/visualiser_assets/butterchurn-page.js

@@ -8,7 +8,7 @@ async function initialise(config) {
   const engine = window.butterchurn.default || window.butterchurn;
   const viz = engine.createVisualizer(null, canvas, {
     width: config.width, height: config.height, pixelRatio: 1, textureRatio: 1,
-    meshWidth: 64, meshHeight: 48,
+    meshWidth: config.mesh_width, meshHeight: config.mesh_height,
   });
   const r = viz.renderer, gl = r.gl;
   for (const name of ['targetFrameBuffer', 'targetTexture', 'calcTimeAndFPS']) {
@@ -114,5 +114,6 @@ async function initialise(config) {
   return {engine: 'butterchurn', version: '2.6.7', opengl: gl.getParameter(gl.VERSION),
     renderer: info ? gl.getParameter(info.UNMASKED_RENDERER_WEBGL) : gl.getParameter(gl.RENDERER),
     input: 'full composed RGBA injected into feedback before real MilkDrop warp/composite',
-    clock: 'pinned calcTimeAndFPS bridge: output frame / fps; fixed fps', seed: config.seed};
+    clock: 'pinned calcTimeAndFPS bridge: output frame / fps; fixed fps', seed: config.seed,
+    mesh_width: config.mesh_width, mesh_height: config.mesh_height};
 }

{framerudiments-0.4.4 → framerudiments-0.4.6}/src/framerudiments/visualiser_routing.py

@@ -13,7 +13,7 @@ from PIL import Image
 from .io import fields, number
 
 MAX_TARGETS = 256
-MODES = frozenset({"continuous", "first_pips", "never"})
+MODES = frozenset({"continuous", "first_pips", "last_pips", "never"})
 RETRIGGERS = frozenset({"reappearance", "once", "lyric", "cue"})
 
 
@@ -27,12 +27,12 @@ def _policy(config, label, inherited=None):
     fields(feed, {"mode", "duration_pips"}, label + ".feed")
     mode = feed.get("mode")
     if mode not in MODES:
-        raise ValueError(f"{label}.feed.mode must be continuous, first_pips or never")
-    if mode == "first_pips":
+        raise ValueError(f"{label}.feed.mode must be continuous, first_pips, last_pips or never")
+    if mode in {"first_pips", "last_pips"}:
         duration = number(feed.get("duration_pips"), label + ".feed.duration_pips", minimum=0, maximum=65536)
         feed = dict(mode=mode, duration_pips=duration)
     elif "duration_pips" in feed:
-        raise ValueError(f"{label}.feed.duration_pips requires first_pips")
+        raise ValueError(f"{label}.feed.duration_pips requires first_pips or last_pips")
     else:
         feed = dict(mode=mode)
     overlay = config.get("overlay", parent["overlay"])
@@ -41,6 +41,8 @@ def _policy(config, label, inherited=None):
     retrigger = config.get("retrigger", parent["retrigger"])
     if retrigger not in RETRIGGERS:
         raise ValueError(f"{label}.retrigger must be reappearance, once, lyric or cue")
+    if feed["mode"] == "last_pips" and retrigger != "lyric":
+        raise ValueError(f"{label}.feed.mode last_pips requires retrigger=lyric")
     return dict(feed=feed, overlay=overlay, retrigger=retrigger)
 
 
@@ -128,6 +130,20 @@ class VisualiserLayerRouting:
             state["lyric"], state["cue"] = lyric, cue
             mode = policy["feed"]["mode"]
             elapsed = max(0.0, pip - state["onset"]) if state["onset"] is not None else None
+            lyric_next = getattr(context, "lyric_next", None)
+            lyric_next_beat = getattr(context, "lyric_next_beat", None)
+            remaining = (
+                max(0.0, float(lyric_next_beat) * 64.0 - pip)
+                if lyric_next_beat is not None and math.isfinite(float(lyric_next_beat))
+                else None
+            )
+            lyric_gap_exit = bool(
+                trigger == "lyric"
+                and getattr(context, "lyric", None)
+                and getattr(context, "lyric", {}).get("text")
+                and lyric_next is not None
+                and not lyric_next.get("text")
+            )
             feeding = bool(
                 visible
                 and (
@@ -135,6 +151,10 @@ class VisualiserLayerRouting:
                     or mode == "first_pips"
                     and elapsed is not None
                     and elapsed < policy["feed"]["duration_pips"]
+                    or mode == "last_pips"
+                    and lyric_gap_exit
+                    and remaining is not None
+                    and 0.0 < remaining <= policy["feed"]["duration_pips"]
                 )
             )
             on_top = bool(visible and policy["overlay"])
@@ -149,6 +169,8 @@ class VisualiserLayerRouting:
                     overlay=on_top,
                     first_pip=state["onset"],
                     elapsed_pips=elapsed,
+                    remaining_pips=remaining,
+                    lyric_gap_exit=lyric_gap_exit,
                     policy=policy["feed"]["mode"],
                 )
         self.next_frame += 1