``````(*
> Anyone who can describe the use of bitplanes in mode 12h to me?

There are 4 bitplanes, each holding a bit of the color number. Each bit in a
plane is a pixel. The pixel at (0,0) is at offset 0, bit 7. Each line is 640
pixels=640 bits=80 bytes. So (0,1) is at offset 80, bit 7.
If you have a line from (2,0)-(6,0) (bits 00111110) in color 10, (1010), the
first byte of the bitplanes would look like this:
bit      76543210

Plane 0: 00000000
Plane 1: 00111110
Plane 2: 00000000
Plane 3: 00111110

Now, what whould happen if we put a white pixel at (0,0)?
Exactly. Bit 7 of all the planes becomes 1.

Now how to access the bitplanes. The VGA card has a 64k window at \$A000:0, so
not enough for each (64k) plane. Here the ports come in use. All ports we need
are in the VGA card a sort of array. To access an element, you first send the
index, then the data, or send the index and read the data. For most ports the
data port is at the address of the index port +1.
Example:
The index port of the Graphics Controller (part of the VGA interface) is at
\$3CE. The data port is at (index+1), so \$3CF. If we want to write a 4 to index
2, we do: Port[\$3CE]:=2; { index } Port[\$3CF]:=4; { data }
But there is a way to do it with one Port[]. There's also a PortW[] 'array',
and if the addressed port isn't a 16-bit one, it sends the lo byte to
<address>, and the high byte to <address>+1. Just what we need. The example
becomes: PortW[\$3CE]:=\$0402; { index in low byte, data in high byte }

Back to the bitplanes. To select which bitplanes are accessed by memory writes
(not reads!), you can write to index 2 of the sequencer (at \$3C4).
If we want to put the line in the first example (from (2,0)-(6,0), color 10),
we can do:
Port[\$3C4]:=\$0A02; { Index 2 of the sequencer: select bitplanes 1,3 }
Mem[\$A000:0]:=\$3E;
But everything at (0,0),(1,0) and (7,0) will be destroied, and, worser, if
there was already something at, say (2,0), in bitplane 0 or 2 (the ones we
didn't select), the values remain there, creating some ugly color or so.

The VGA card has 4 internal 8 bit latches, one for each plane. If you do a
read, no matter what will be returned to the processor, these latches are

Also there're so called write modes. These are the way the VGA card interprets
the byte written to the VGA memory. You set the write mode with the Mode
register, index 5 from the Graphics Controller (\$3CE).
There are four modes:

Write mode 0
The is the default mode. With the bitmask register, index 8 form the Graphics
Controller (\$3CE), you can select the bits used from the byte, the other bits
are from the registers. Each byte you write will go to all bitplanes, unless
you put a 1 in the correspondening bit in the Enable Set/Reset register, index
1 at the Graphics Controller (\$3CE). If you've put a 1 in that register, that
plane will have the bit of the correspondening bit in Set/Reset register, index
0 at \$3CE, and the CPU byte doesn't matter.So if you put \$F (all planes) in the
Enable Set/Reset register, the desired color in the Set/Reset register, and the
desired bits in the bitmask register, you can put pixels in that color,
preserving other pixels in that byte.Example (again the same line):
*)
PortW[\$3CE]:=\$0005; { Index 5 of the Graph Contr., set write mode 0 }
PortW[\$3CE]:=\$0F01; { Index 1 of the Graph Contr., Enable Set/Reset }
{ for all planes }
PortW[\$3CE]:=\$0A00; { Index 0 of the Graph Contr., set with color 10 }
PortW[\$3CE]:=\$3E08; { Index 8 of the Graph Contr., set only bits 2-6 }
Mem[\$a000:0]:=Dummy; { Byte doesn't matter }
(*
Write mode 1
Nothing is done with the registers or the CPU byte. All the latches are
directly copied to the addressed byte. Usefull for screen to screen copy (e.g.
scrolling)
Example to copy (0,0)-(7,0) to (8,0)-(15,0):
*)
PortW[\$3CE]:=\$0105;  { Set write mode 1 }
Dummy:=Mem[\$a000:0]; { Load latches with pixels (0,0)-(7,0) }
Mem[\$a000:1]:=Dummy; { Write latches to pixel (8,0)-(15,0) }
(*
Write mode 2
The lower 4 bits of the CPU byte are the bits for each plane. If set for a
plane, all bits selected with the Bitmask register are set, if clear, they're
cleared.
So you can do the same as in the example from mode 0, but with fewer
instructions:
*)
PortW[\$3CE]:=\$0205;  { Set write mode 2 }
PortW[\$3CE]:=\$3E08;  { Select bits 2-6 }
Mem[\$a000:0]:=10;    { Set that bits to color 10 }
(*
Write mode 3
If a bit from the CPU byte is set, that bit will get the color in the Set/Reset
register (index 0, \$3CE), otherwise value from the latches is taken.
I find this mode the most usefull for drawing lines, circles etc. where the
bitmask changes, but the color not. Again the same line:
*)
PortW[\$3CE]:=\$0305;  { Set write mode 3 }
PortW[\$3CE]:=\$0A00;  { Set color 10 }
Mem[\$a000:0]:=\$3E;   { Set bits 2-6 }
(*
There's also a Function Select register (index 3, \$3CE).
bits 3,4 indicate the way the bits that you want to change (selected by Bitmask
register (write mode 0,2) or CPU byte (write mode 3)) are modified.
00 Not modified
01 ANDed with latches
02 ORed with latches
03 XOR with latches
For write mode 0 and 3 bits 0-2 indicate how many times the bits you want to
change are shifted to right. Bits rolling out the byte appear on the left.

There are two read modes, for the byte returned to the CPU on a memory read.
You select them with the same register as the write modes (index 5, \$3CE), but
in bit 3.