Effects and layers

An effect is a small program you build by wiring nodes together. A layer runs one effect on one set of fixtures. Stack a few layers, give each an opacity, and Spectralite combines them bottom to top into the single picture your rig plays. This page is the model that everything else in the app hangs off: learn it once and the Timeline, the Bumps panel, and layer settings all read the same way.

What an effect is

An effect is a graph of nodes. Each node does one job, reading a fixture's position, making a wave, comparing two numbers, mixing a color, and you connect a node's output to the next node's input to describe the look you want. You build effects in the Node Editor; the nodes reference lists every node by category.

When you finish wiring, Spectralite compiles the whole graph into one program that runs on the GPU, evaluating every fixture in parallel every frame. That is why an effect that lights ten fixtures costs about the same as one lighting ten thousand: the graphics hardware does the work for every fixture at once. You author the effect once as a graph, and the engine turns it into fast native code for you.

An effect on its own renders nothing. It has no fixtures and no place in your show until a layer gives it both.

What a layer is

A layer binds one effect to one position map, the spatial layout that says which fixtures the effect covers and where each one sits. That pairing is the whole job of a layer: this effect, on these fixtures. Change the effect and the same fixtures play something new; change the map and the same effect lands on a different part of the rig.

Alongside the effect and the map, a layer carries the controls that decide how strongly it plays and how it sits over the layers beneath it: an Opacity, a blend behavior, and a schedule on the beat grid that turns it on and off in time (see beat and time). A layer holds exactly one effect, gated in time by the beat grid.

The stack

Picture the stack as paint on a canvas. The canvas starts black. The bottom layer is the first coat of paint, the next layer goes on over it, and so on to the top. Each layer reads what is already on the canvas, adds or replaces some of it, and passes the result up. The order is the whole point: a layer affects only what is below it.

Two controls decide what each coat does to the one beneath: its opacity and its blend behavior.

Opacity

Opacity is a linear brightness scalar from 0 to 1. At 1 the layer contributes its full brightness; at 0 it contributes nothing, which is how you switch a layer off (there is no separate mute). Halfway is halfway: opacity 0.5 scales the layer's light to half before it combines with the stack. Because the scale is linear, dragging opacity from 0.4 to 0.8 doubles the light the layer adds.

Blend

Blend is a single choice per layer between two behaviors.

Additive adds the layer's light on top of what is below. The two sum. Stack several additive layers and their brightness piles up, which is what you want for washes and glows, and also why a tall additive stack can climb toward white if you leave every layer at full.

Override replaces what is below, in proportion to opacity. At full opacity the layer wins outright and you see only it. At 0.5 you see an even mix of the layer and the stack beneath. Reach for override when a look needs to sit in front of the others.

In plain arithmetic, with below as the picture so far and layer as this layer's contribution:

additive:  output = below + opacity * layer
override:  output = (1 - opacity) * below + opacity * layer

The two equations above are the whole blend model; there is no multiply, screen, or the rest of a compositor's list.

Bumps sit above the timeline

Layers belong to one of two groups. Timeline layers are your running show, the chasers and moving looks that play against the beat grid in the Timeline. Bump layers are momentary hits you fire by hand from the Bumps panel.

Bump layers always composite above every timeline layer, whatever their numbered order. A bump is a top coat you slap over the whole painting for as long as you hold it. Within each group the numbered order still decides who sits over whom.

How colors combine

Most layers author color the portable way: you pick a color, and the engine renders it onto each fixture's real emitters. Some layers use Channels colors instead, naming a level for each emitter. The color page owns the model. In short, the stack adds up every layer's request per fixture and works out one recipe at the end.

Portable layers add as light, and when the sum passes what a fixture can make, the mix dims as a whole and stays on hue. Channels layers add per emitter and stop at full. The two kinds meet at the end: each emitter gets the two shares added together and capped at full. Take one red-green-blue fixture with two layers, a portable blue wash at the bottom at full opacity and an additive Channels layer above it driving red to half. The wash lights the blue emitter, the Channels layer adds half red, and the fixture shows a violet. Swap the two layers and the result is the same, because additive layers sum whatever their order. See stacking layers for what happens when the total passes a fixture's ceiling.

Where to go next

• Beat and time explains the grid that schedules each layer.
• Color covers device-independent color and how it lands on real fixtures.
• The Node Editor is where you build the effect a layer runs.
• The concepts overview links the rest of the model.