Ben Stull
cbb7c9f53d
Replace the pre-baked SD restyle variants (too fluid — the painting re-rolled every keyframe and the flow-warp melted frames) with a deterministic, real-time dream that holds STILL across the loop; only the footage's own motion moves. Design: docs/superpowers/specs/2026-06-22-right-axis-deterministic-dream-design.md Engine (player/alteration.py): Restyle(variant) -> Dream(strength, intensity); Calibration.right_variant_map -> dream_gain. player/state.py: a Right change is a LIVE_UPDATE now, not a crossfade (only a clip swap crossfades). Plan dict restyle -> dream. Tests migrated; 233 green. (No new Python behavior for the client-render swap below.) Renderer (simulator front-end): the Right dream is a WebGL2 Kuwahara shader on a <canvas> over the live video — edge-preserving, so motion/structure stay crisp; the dream is the same footage, just stylized (no blur). Ramped by the knob; max goes "trippy" (vivid saturation + ~45deg hue drift + posterize, concentrated near max via t=intensity^2). Phase-1 luminous-haze (CSS+bloom) was built then retired by eye (blur read as out-of-focus video). Mood grade rides as a CSS filter on the canvas; bloom layer removed. Dev ergonomics that fell out of the iteration: - /dev/version + a 1s client poll = live-reload (open tab never runs stale renderer code; reloads on my edits AND server restarts). - no-cache on the dev server; an on-screen error banner + crash-proof render so a silent throw can't masquerade as "nothing is changing". Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
123 lines
4.0 KiB
Python
123 lines
4.0 KiB
Python
"""The player state machine: a stream of Controls -> playback transitions.
|
|
|
|
Pure decision logic — no mpv, no audio, no serial. Each update() resolves the
|
|
desired Playback (which neutral base clip, how it is altered, what audio plays,
|
|
at what levels) and returns the Transition from the previous Playback. The
|
|
transition KIND encodes design §4.3: the Dark/Light grade, the Left overlay AND
|
|
the Right dream (a deterministic, live luminous haze since session 0013) are all
|
|
continuous runtime ops (LIVE_UPDATE); only swapping the clip needs a CROSSFADE,
|
|
and toggling video on/off fades to/from black.
|
|
|
|
Knobs no longer *select* a clip (the base library is neutral by construction);
|
|
they *transform* it. Which neutral base to show is an injected policy
|
|
(`choose_base`), defaulting to the first clip; richer rotation is a later slice.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from dataclasses import dataclass
|
|
from typing import Callable, Optional
|
|
|
|
from hef.selection import Coordinate
|
|
from player.alteration import RenderPlan, plan_alteration
|
|
from player.content import ContentResolution, resolve_content
|
|
from player.controls import Controls
|
|
|
|
|
|
class TransitionKind:
|
|
NONE = "none"
|
|
LIVE_UPDATE = "live_update"
|
|
CROSSFADE = "crossfade"
|
|
FADE_TO_BLACK = "fade_to_black"
|
|
FADE_FROM_BLACK = "fade_from_black"
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class Playback:
|
|
"""What should currently be playing."""
|
|
|
|
clip_id: Optional[str] # None = black walls
|
|
plan: Optional[RenderPlan] # None when black
|
|
content: ContentResolution
|
|
volume: int
|
|
brightness: int
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class Transition:
|
|
kind: str
|
|
playback: Playback
|
|
|
|
|
|
def _first(library):
|
|
if not library:
|
|
raise ValueError("no base clips available to play video")
|
|
return library[0]
|
|
|
|
|
|
_BLACK = Playback(
|
|
clip_id=None,
|
|
plan=None,
|
|
content=ContentResolution("none", False),
|
|
volume=0,
|
|
brightness=0,
|
|
)
|
|
|
|
|
|
class Player:
|
|
def __init__(
|
|
self,
|
|
base_library,
|
|
*,
|
|
choose_base: Callable = _first,
|
|
approved_only: bool = False,
|
|
):
|
|
self._library = list(base_library)
|
|
self._choose_base = choose_base
|
|
self._approved_only = approved_only # reserved for catalog-backed libs
|
|
self._current = _BLACK
|
|
|
|
def _resolve(self, controls: Controls) -> Playback:
|
|
content = resolve_content(controls.content)
|
|
if not content.video:
|
|
return Playback(
|
|
clip_id=None,
|
|
plan=None,
|
|
content=content,
|
|
volume=controls.volume,
|
|
brightness=controls.brightness,
|
|
)
|
|
clip = self._choose_base(self._library)
|
|
coord = Coordinate(controls.left, controls.right, controls.dark, controls.light)
|
|
return Playback(
|
|
clip_id=clip.id,
|
|
plan=plan_alteration(coord),
|
|
content=content,
|
|
volume=controls.volume,
|
|
brightness=controls.brightness,
|
|
)
|
|
|
|
def _classify(self, prev: Playback, nxt: Playback) -> str:
|
|
prev_video = prev.clip_id is not None
|
|
next_video = nxt.clip_id is not None
|
|
if prev == nxt:
|
|
return TransitionKind.NONE
|
|
if prev_video and not next_video:
|
|
return TransitionKind.FADE_TO_BLACK
|
|
if next_video and not prev_video:
|
|
return TransitionKind.FADE_FROM_BLACK
|
|
if next_video and prev_video:
|
|
# The Right dream is a live filter now (not a substrate swap), so it
|
|
# no longer forces a crossfade — only a clip (scale) change does.
|
|
if nxt.clip_id != prev.clip_id:
|
|
return TransitionKind.CROSSFADE
|
|
return TransitionKind.LIVE_UPDATE
|
|
# both black: only audio/levels could have changed
|
|
return TransitionKind.LIVE_UPDATE
|
|
|
|
def update(self, controls: Controls) -> Transition:
|
|
nxt = self._resolve(controls)
|
|
kind = self._classify(self._current, nxt)
|
|
self._current = nxt
|
|
return Transition(kind=kind, playback=nxt)
|