Information regarding a certain pixel of a SingleColorCharacter to be rendered.
        /// <summary>
        /// Renders a character on the display at the specified offset.
        /// </summary>
        /// <param name="display">The display to render to.</param>
        /// <param name="character">The character to render.</param>
        /// <param name="offsetX">The X-position of the left-most edge of the character.</param>
        /// <param name="offsetY">The Y-position of the top-most edge of the character.</param>
        public override void Render(ISenseHatDisplay display, SingleColorCharacter character, int offsetX, int offsetY)
        {
            int right  = offsetX + character.Columns.Length - 1;
            int bottom = offsetY + 7;

            if ((offsetY > 7) || (bottom < 0) || (offsetX > 7) || (right < 0))
            {
                return;
            }

            int columnIndex = 0;
            int maskInit    = 1;
            var pixelMap    = new SingleColorCharacterRendererPixelMap
            {
                Character      = character,
                DisplayOffsetX = offsetX,
                DisplayOffsetY = offsetY
            };

            int charPixelYInit = 0;

            if (offsetX < 0)
            {
                columnIndex         -= offsetX;
                pixelMap.CharPixelX -= offsetX;
                offsetX              = 0;
            }

            if (offsetY < 0)
            {
                maskInit      <<= -offsetY;
                charPixelYInit -= offsetY;
                offsetY         = 0;
            }

            if (right > 7)
            {
                right = 7;
            }

            if (bottom > 7)
            {
                bottom = 7;
            }

            pixelMap.DisplayPixelX = 0;
            for (int screenX = offsetX; screenX <= right; screenX++)
            {
                int mask = maskInit;

                byte column = character.Columns[columnIndex++];

                pixelMap.CharPixelY    = charPixelYInit;
                pixelMap.DisplayPixelY = 0;

                for (int screenY = offsetY; screenY <= bottom; screenY++)
                {
                    if ((column & mask) == mask)
                    {
                        display.Screen[screenX, screenY] = _getColor(pixelMap);
                    }

                    mask <<= 1;
                    pixelMap.CharPixelY++;
                    pixelMap.DisplayPixelY++;
                }

                pixelMap.CharPixelX++;
                pixelMap.DisplayPixelX++;
            }
        }
		private Color GetCharacterColor(SingleColorCharacterRendererPixelMap pixelMap)
		{
			switch (_currentMode)
			{
				case RenderMode.YellowOnBlue:
					return Colors.Yellow;

				case RenderMode.BlackOnStaticRainbow:
					return Colors.Black;

				case RenderMode.BlackOnMovingRainbow:
					return Colors.Black;

				case RenderMode.StaticRainbowOnBlack:
					// Let the rainbow colors be "pinned" to the display.
					return _rainbowColors[pixelMap.DisplayPixelX, pixelMap.DisplayPixelY];

				case RenderMode.MovingRainbowOnBlack:
					// Let the rainbow colors move with the characters ("restarting" on each character).
					return _rainbowColors[pixelMap.CharPixelX, pixelMap.CharPixelY];

				default:
					throw new ArgumentOutOfRangeException();
			}
		}