Notes on Graphics_Demo.spin

Notes on Graphics_Demo.spin

First, note that the screen is divided up into 16x16 pixel "tiles". Each tile can have 4 different colors.

There are 3 arrays used to define the screen: Bitmap, Display, and Screen

Screen is the only formally declared array. It is an array of words, one for every 16x16 pixel tile. Each member in the array is a pointer to the actual pixel data as well as a pointer to 1 of the 64 sets of colors.

It is a bit complex how each word member of Screen can be a pointer (which is a word size, 16 bits) as well as hold the color info (6 bits). But, this has to do with alignment... The Display array that Screen points to is aligned so that the last 6 bits of each address are always 0. So, these 6 bits are used to also hold the color info.

The bitmap and display arrays are not declared, but just reserved memory. The base addresses are declared by these lines:

`bitmap_base = $2000 display_base = $5000`

	Note that the "display_base" address should end in "00" for reasons of alignment, discussed above.
	These arrays take up most of the 32kB of hub RAM. The bitmap array extends from $2000 up to $4FFF and the display array extends from $5000 up to $7FFF (the end of memory).
	Because there is so little room left for actual code, this compiler directive:

`_stack = ($3000 + $3000 + 100) >> 2 'accomodate display memory and stack`

Is used to reserve the space for these arrays, about 12kB each.

The Display array holds the actual pixel data for the graphics that is displayed on the screen. The Screen array is filled with pointers to the Display array.

The Bitmap array is just like the Display array, but it is the working buffer to draw on. After all the drawing is done for the next frame, the entire Bitmap array is copied to the Display array. Then, the Bitmap array is cleared and work begins on drawing the next frame into it. This gives a flicker-free display.

Each tile takes 16 longs (64 bytes or 512 bits) to represent it as each tile is 16x16 pixels by 2 bits of color (4 possible color values).

The screen is made up of 16x12 tiles. So, the total memory requirement is 16x12x16 = 3,072 longs = 12,288 Bytes. Note that 12,288 is $3000 in hex, which explains the size of Bitmap and Display arrays.

Each 16x16 pixel tile has a pre-defined set of 4 colors.

	There are 64 sets of 4 colors each stored in the Colors array that is passed to the Graphics driver. Each color is defined by 1 byte, so each set of 4 colors is a long, which is why the Colors array is an array of 64 longs.
	Find more info about the TV colors here.
	6 bits in every word of the Screen array hold the selection of color set for each tile.
	In this demo all tiles have 3 of the 4 colors the same (black, white, and blue).
	The 4th color varies from tile to tile. Each row is given the same 4th color. So, the 4th color is graded from top to bottom. At the top it is green and at the bottom it is purple.
	Note that only 12 of the 64 sets of colors are actually used by the demo since there are only 12 rows of tiles.