Video plugins

The signal path

Old Cathode

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

An analogue television signal path rather than the look of one. It encodes the picture onto a colour subcarrier the way a broadcast encoder would have, damages the composite waveform as a single signal, and decodes it again with no more information than a real receiver had — then paints the result onto a phosphor screen behind curved glass.

• Dot crawl, cross-colour and coloured noise arrive as consequences of that path, not as things drawn on top of the picture
• NTSC or PAL, from broadcast or three grades of VHS, each with its own bandwidths and colour-under delay
• Four dot masks — delta shadow mask, aperture grille with its damper wires, slot mask and hard RGB stripe — living on the glass, so they foreshorten with the tube
• The controls interact the way the hardware did: losing signal costs the colour before it costs the picture

The lens

Porthole

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

A variable fisheye and defish warp that re-photographs the picture through a different lens instead of bending it until it looks about right. The Projection control is which lens rather than how much: one continuous family passing exactly through rectilinear, stereographic, equidistant, equisolid and orthographic.

• Rectilinear does nothing at all, at any field of view — a flat picture re-photographed through a flat lens is the same picture, and the maths says so without being told
• Defish exactly undoes fish, because it is the same formula with source and destination swapped rather than a similar-looking inverse curve
• The frame always stays full, so strength changes the character of the warp instead of shrinking the picture into a black field
• Lateral chromatic aberration modelled separately from distortion, since a lens can have one without the other

The character renderer

Asciify

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

A character renderer rather than a brightness ramp. A cell is a small picture, and the glyph that stands in for it is the one whose ink is distributed most like it — how much ink there is and where it sits, measured on the same grid for the cell and for every character in the set.

• Tone is matched absolutely and shape only as a direction, because a glyph's ink is hard-edged and a cell's is soft — comparing their lengths would reject every directional glyph and collapse the effect back into a ramp
• Structure at zero is exactly the classic ASCII ramp, with no separate code path, and flat areas of the picture ignore the control on their own because a cell with no direction has nothing to be wrong about
• Every character set uses its whole range: tone maps into the measured minimum and maximum ink of whatever is selected, which is the only reason the box-drawing set responds to Structure at all
• The ramp is measured off the font rather than written down, so the traditional set comes out in this font's own order — with the hyphen outweighing the colon

The measurement

Scopes

FFGL effect · Resolume 7.3.1+ · deliberately not ported

Waveform, vectorscope, histogram and picture assist in one effect, either replacing the picture on a monitor layer or sitting over it in a corner. It measures what is arriving at that point in the layer's chain, which is a different question from what the clip file contains — and the plugin is careful to say so.

• Matrix, range and unpremultiply are explicit settings rather than heuristics, because none of the three is recoverable from the pixels once the engine has the texture — and each one guessed wrong is plausibly wrong rather than obviously wrong
• The vectorscope's target boxes are computed from the matrix the shader plots with, so choosing a matrix moves the boxes and the trace together instead of quietly making a mismatched clip look correct
• Histogram bins accumulate in 32-bit float, because in half float the tallest bins stop counting first — which are exactly the clipped whites and crushed blacks the histogram was opened to find
• Picture assist is the picture itself recoloured — false colour, zebras and focus peaking — rather than a fifth panel to read
• The one plugin without an OpenFX build, on purpose: Resolve’s own scopes are better than anything an effect can draw, and a port that exists only to be worse than the built-in tool is not worth shipping

The keyer

Resolume Luma Keyer

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron · After Effects, Premiere Pro

A luminance keyer. It measures the perceptual Rec. 709 luminance of each pixel and drives that pixel's alpha from it, so dark — or bright — areas of a clip go transparent and let lower layers show through, with no dedicated key colour to pick.

• Threshold and Softness, from a hard cut to a gradual falloff across the key edge
• Invert, to take out the bright pixels instead of the dark ones
• Straight colour internally, premultiplied and clamped to LDR on the way out, matching Resolume's own pipeline
• The quick answer to a black background, add-blend-style content, or a shadow or highlight matte

The lights

Tinsel

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

Finds the outlines in whatever is on the layer, hangs a string of virtual lamps along them, and runs the sort of pattern an LED controller runs — chases, comets, twinkles, fire, a scanner, a wipe. Point it at a logo and it becomes a neon sign, a theatre marquee or a Christmas tree.

• An effect never chooses a colour — it says where in the palette a lamp sits and how bright it is, which is how an LED controller is built and why twenty patterns and sixteen palettes are worth more than thirty-six of either
• A lamp is a fixed size in pixels, not in strip units — the difference between lamps and streaks
• The temporal filter is asymmetric on purpose: edges appear at once and are given a few frames to come back when they vanish, because what goes wrong on footage is dropout, not movement
• Randomness is an integer hash, identical on every GPU and in the offline harness

The console

NESolume

FFGL · Resolume · OpenFX · Resolve, Vegas, Nuke, Natron

A retro games console between your content and your output: a real machine's raster, palette and attribute cells, and the ways all three fail. Nine machines from the Game Boy to the PlayStation, with dither, attribute clash and a glitch section that corrupts indices rather than pixels.

• Nothing a failing machine shows is ever outside its palette — corruption happens to the indices, before colour choice, and a harness checks every rendered pixel to hold it to that
• Attribute clash falls out of enforcing the cells: the NES's 16×16 areas bleed chunky, the Spectrum's 8×8 cells argue per character
• Displacement is scroll-register damage in whole pixels and whole tiles, wrapping at the edges, so heavy settings read as a machine failing rather than an effect succeeding
• At Glitch Rate zero the corruption is a still — a crashed machine, not a screensaver

The generator

Downpour

FFGL source and effect · Resolume 7.3.1+ · OpenFX pair · Resolve, Vegas, Nuke, Natron

Digital rain: columns of characters falling at their own speeds, each with a bright leading glyph and a trail fading out behind it. Ships as two plugins — a source that draws over its own background, and an effect that draws the same rain over the clip it sits on.

• Junk characters, generated code, four public domain books, your own text or any file you point it at — a loaded document plays out in order rather than being sampled from
• Any installed font, rasterised into the glyph atlas, with a per-character fallback to the plugin's own drawn face so a typeface with no katakana still renders the katakana
• Every cell is a closed-form function of its column, its row and the clock — no simulation state, so the rain cannot slow down when the host's frame rate does
• Separate colours and opacities for the text, the leading glyph and the background, so it composites over footage without a second layer

The shapes

Orrery

FFGL source and mask · Resolume 7.3.1+ · OpenFX pair · Resolve, Vegas, Nuke, Natron

Primitive shapes moving on deterministic paths — for a quick animated mask, and for driving a pixel map. Ships as two plugins: a source that draws shapes over its own background, and a mask effect that draws them over the clip, or cuts them into it.

• Every shape's position is a closed-form function of its index and one phase number — a bounce is a triangle wave, not a collision test — so a chase cannot slow down when the host's frame rate does, which is the thing that matters when the output is driving lights rather than a screen
• Because phase is just a number, locking to the track costs no separate code path: Sync swaps the host clock for the host's own bar position, or hands the whole thing to a keyframe or a MIDI fader
• Eight primitives with outline, roundness, stretch and edge softness — and softness at zero gives a hard edge, because a feathered one means a fixture on the boundary reads a half-brightness colour that was never in the design
• Five paths, and Spread distributes the set along one in phase — which is what turns a clump into a chase that arrives in order, while Scatter takes the same set from metronome to swarm

The screensavers

Idler

FFGL source and mask · Resolume Arena and Avenue · OpenFX pair · Resolve, Vegas, Nuke, Natron

The eleven screensavers that shipped with Windows 95 and 98 — Mystify, 3D Pipes, 3D Maze, Flying Windows and the rest — as a source that draws over its own background and a mask effect that draws the saver over the clip. One dropdown for the eleven, with a factory preset per saver that sets it up the way it actually ran.

• Every saver is a pure function of time and a seed — nothing integrates a velocity and nothing remembers the previous frame, so a Mystify polygon bounces off a triangle wave rather than a collision test and none of it comes apart from the music when the host's frame rate drops
• 3D Pipes and 3D Maze genuinely grow, so they cannot be closed-form: rather than give those two an exception they are made deterministic by replaying from the seed, which keeps them scrubbable and grows the same plumbing on the show laptop and the rack machine
• The eleven share seven scene controls, each mapped to whatever that saver has that is analogous — and Colour Mode is the one worth knowing, because it puts the whole set under one tint, spread or cycle instead of eleven period palettes
• Some of it the originals could not do at all: streaks on the starfield, wireframe on the FlowerBox, and all eleven over transparency
• Not affiliated with Microsoft, and no Microsoft code, artwork or assets are included — the Flying Windows logo is a four-quad gesture toward the mark, and the teapot is generated from a profile curve rather than being Newell's dataset

The arcade

Coinop

FFGL source and effect · Resolume Arena and Avenue · no OpenFX build yet

Snake, Bricks, Marchers, Rally and Drift, playing inside the composition as a source and a matching effect. Drive them from a MIDI pad or an OSC fader, or leave the autopilot to play and lose on its own — and in the effect the brick field is built out of the clip, so breaking a brick punches a hole through to the layer below.

• FFGL has no keyboard and no gamepad, it has parameters — so every control is one, and Resolume will MIDI- or OSC-map any of them: a fader for the paddle, four pads to steer, one to fire, and Rally's two players out of a single instance
• Presses are latched on the edge the host delivers them rather than polled at render time, because a press that starts and ends between two frames is invisible to a poll, and at 50fps that is a 20ms window a drummer hits constantly
• The autopilot has to lose, which makes it a feature rather than a quality bar: a perfect Snake AI never dies and leaves the layer showing the same slowly-lengthening snake all night, so Skill governs deliberate incompetence — tracking error, reaction lag, and a flat chance of ignoring its own survivability analysis
• Everything is drawn as cells rather than geometry, including Drift's vectors, because the second job is pixel mapping — and a one-pixel antialiased line sampled onto a 30mm pitch wall lands between fixtures and disappears

The sprite sheet player

Flipbook

FFGL source and effect · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

A page of stills, cut into a grid and played as an animation — VFX sheets, game sprite rows, pixel art kept as pixel art, or an animated GIF that brings its own frame count. The effect can take the clip it sits on as the sheet, so Resolume's own media management does the file handling.

• The frame on screen is a closed-form function of the clock rather than a counter that gets advanced — a player that ticked once per rendered frame would run at whatever rate the host managed that night, land a quarter of a frame short per bar, and be visibly adrift by the end of the track
• Start Frame and Frame Count cut any contiguous run out of a sheet and wrap past the last cell, so a four-frame idle and an eight-frame run are two parameter sets on the same sheet rather than two files
• Up to sixty-four copies in a grid, a ring or a scatter, and Stagger offsets each copy's position in the run — which is what turns a wallpaper of sprites all doing the same thing into one animation travelling through the field
• Nearest-neighbour sampling and a half-texel inset, so a 32px sprite scales to a metre of LED wall with its edges intact and no cell ever bleeds into its neighbour

The synthwave engine

Outrun

FFGL effect · Resolume · live WebGL2 demo

Two engines behind one dropdown: trace the clip's outlines as neon tubes that break away from the real geometry, or generate the perspective grid, tunnels, circuits and an audio oscilloscope outright. Sixteen authored palettes, beat and bar sync, and the same GLSL running live in the browser.

The console

Cartridge

FFGL source · Resolume Arena and Avenue · macOS · no OpenFX build

A libretro frontend as a source layer: point it at an emulator core and a game and the console becomes a layer you can composite, key and run through everything else in the rig — with the joypad MIDI-mapped onto whatever controller is already on the desk. It was built as a companion to Old Cathode, because a 240p frame through a real composite encoder is the thing it exists to make possible.

• Ships as two builds of one frontend, differing only in which process the core runs in: in process the picture arrives the same frame it was produced and a crashing core takes Resolume with it; out of process it arrives a frame later and a crash kills only the helper
• The pad is twelve ordinary boolean parameters, so Resolume MIDI-maps, keyboard-maps and automates them with no help from the plugin — a hardware controller becomes a joypad, and a game can be keyframed as a visual
• Hardware-rendered cores are refused deliberately and with a log line, because giving them a half-kept promise makes them render into Resolume's own framebuffer. Software cores only
• No emulator core, BIOS image or game is included and none ever will be — several cores worth using carry non-commercial terms, and shipping one would take this repository's MIT licence with it