pouët.net

AntDude: the mod should be on the disk image ;)

Sure. The effect indeed runs in dual playfield mode, displaying two 6-layer checkerboard effects on top of each other, using 3 bitplanes each. The occasional 13th layer consists of sprites. In the following, I will describe how to cram 6 layers into 3 bitplanes (using less than half a frame of time with 6 bitplanes of DMA load).

As a precalculation, I generate bitmaps describing what the rows and columns of a checkerboard layer look like for each depth. The demo uses 512 different depths, and for each depth there is a 1024-pixel row and a 512-pixel column. A checkerboard layer is conceptually a (suitably shifted and cropped) per-pixel xor between a row from the row map and the corresponding column from the column map.

The row map looks like this (red lines indicate the center 320 pixels):



The column map looks like this (red lines indicate the center 256 pixels):



As you can see, only the lower 8 bits of each 16-bit word in the column map are used. I will get back to why that is.


For each layer, a suitable section of a row in the row map is extracted, using the blitter. The row is chosen based on the depth of the layer, and the section to extract within that row is based on the X offset of the layer. Similarly, the depth also selects a column from the column map, and the Y offset of the layer speficies which bit in that column corresponds to which scanline of the display.

On each scanline, each layer will either show the extracted section or the bitwise inverse of it (selected by the corresponding bit in the selected column from the column map). Any combination can potentially occur. With 6 layers, this means there are 64 different possible scanlines. The basic strategy for the effect is thus:

1. For each of the 64 combinations, produce a 3 bitplanes deep scanline corresponding to that combination by logically combining the extracted sections using the blitter.

2. At each scanline of the display, using the copper, set the bitplane pointers to point to the appropriate combination.

The combination operation must be such that, with a suitable palette, closer layers appear in front of farther layers. To achieve this, it is not necessary to produce all 64*3 bitplane lines, as some of them can be shared. The redundancy in the palette (there are 7 colors available, but only 6 layers) is key here. This figure illustrates how the combination is done:

The block on the top shows all 64 combinations of bit values from the layer sections along the horizontal axis. Colored means 1 (opaque), black means 0 (transparent). The next block shows the computed logical combinations of the layers. The first two rows (T1 and T2) are temprary values needed in the computation, and the last three (P3, P2 and P1) are the resulting bitplane contents. The formulas for each row are written to the right. Note that each formula has at most 3 inputs, which means it can be computed using the blitter.

The bottom block shows the resulting color (as indexed by the bit values in the 3 bitplanes). Each layer has its own entry in the palette, except for layer 5, which occupies both color 2 and color 3. The resulting color corresponds to the front-most layer, as desired.

With these formulas, bitplane 3 only depends on the first 4 layers, so only 16 combinations need to be computed. Bitplanes 2 and 1 each depend on 5 layers, so they need 32 combinations each.

Some of the blits can be combined to save a bit of overhead. Instead of 4+8+16+32+32 = 92 blits, it is done using 4+8+4+8+4 = 28 blits. Furthermore, the front 6 and back 6 layers can share the same blits (with twice the width).


The bitplane pointers are constructed by blitting the appropriate sections of the selcted columns from the column map into the copperlist. To facilitate this, the constructed scanlines are placed with a stride of 128 bytes. All lines are placed within a 64k-aligned block, at these line indices (lower 16 bits of address divided by 128):

With this layout, the state (original or inverse) of each layer corresponds to individual bits in the bitplane pointers. The upper 16 bits of the pointers are fixed (for a particular frame). The lower 16 bits look like this:

Where the states of layers 1-6 are denoted by A-F, and the x's are an offset into the scanline (different for the front 6 and back 6 layers).

Each blitted column must be extracted from the column map (all other bits in the word masked out), shifted from its bit position in the column map to its designated destination bit in the bitplane pointer, and then combined with the other columns. Since the columns are placed at bit positions 0-7 of each word in the column map and must end up at bit positions 7-11 in the bitplane pointer, the shift is always to the left (0 to 11 places), so the extraction blits always use descending mode.

First, layers 1-4 are combined in pairs into a temporary space, and then the pairs are combined with the fixed bits into the bitplane 3 pointers. In the pairwise combination blits, the columns are sourced on A and B, so they can be independently shifted (which is possible since the shifts are always in the same direction). The A channel is masked by the first word mask, and the B channel is masked by constant data on the C channel. Bitplanes 2 and 1 are each a combination of bitplane 3, another layer (masked and shifted), and constant data.


So that is how the effect works. To script it, I include a huge (but very compressible) block of explicit scripting data, specifying, for each frame, how many layers are shown, and the position, depth and color of each layer. Where possible, I store the values as deltas from the previous frame. The script is generated by a Lua program, using a custom tool.