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.

The graph is not interpreted step by step at showtime. 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 work happens on the graphics hardware, not in a per-fixture loop. 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. There is no clip, no per-effect start and end handle, and no timeline of separate takes inside a layer. One layer, 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 only ever affects the layers below it, never the ones above.

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, not a menu of modes.

Additive adds the layer's light on top of what is below. Nothing underneath is removed; the two just 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 rather than add to them.

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

There is no blend-mode menu beyond this choice. Multiply, screen, and the rest of a compositor's mode list do not exist here; the two equations above are the whole blend model.

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: it lands over the running show no matter how the timeline layers are stacked among themselves. Within each group the numbered order still decides who sits over whom; the group boundary just guarantees that any bump outranks any timeline layer.

How colors combine

Most layers you build author color in a device-independent way: you pick a color and the engine renders it onto each fixture's real emitters, so the same authored color looks right on a plain red-green-blue fixture and on one with amber and lime emitters too. Some effects instead drive a fixture's raw channel levels directly, writing the numbers that go out on the wire. See color for what device-independent color means and when each path is used.

Layers of the same kind blend among themselves in their own terms. Device-independent layers combine in a shared color space, so mixing a red wash with a blue one gives the violet you expect on every fixture regardless of its emitter set. Channel-authored layers combine as raw numeric levels. When a stack mixes both kinds, Spectralite reconciles them in stack order: at each point where the authoring kind changes, it resolves the accumulated device-independent color into actual emitter levels, then keeps combining upward from there.

Order matters, and a worked example shows why. Take one red-green-blue fixture with two layers.

Before, as authored. The bottom layer is a device-independent blue wash at full opacity. The top layer is channel-authored and additive, driving the fixture's red emitter to half. Read on their own, one wants the fixture blue, the other adds some raw red.

After, combined bottom to top. The engine first renders the blue wash onto the fixture's emitters, lighting the blue emitter. It then reaches the channel-authored layer, sees the authoring kind change, resolves the blue it has so far into real emitter levels, and adds the top layer's red on top. The fixture emits blue plus half red: a violet.

Now swap the two. With the channel-authored red on the bottom and the device-independent blue wash above it, the blue layer composites onto the raw red already sitting on the fixture, and the balance of the mix shifts. Same two layers, different stacking, different output, exactly as the paint metaphor predicts.

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.