Pokitto Community Team / Pokitto_

PokittoLib with changes to lcd refresh etc.

Dependents:   Pokittris

Fork of Pokitto by Pokitto Community Team

This is a fork by user @Spinal, and is used in Pokittris for testing. Do not import this to your own program.

POKITTO_CORE/PokittoDisplay.cpp@9:570fdd653f1d, 2017-10-15 (annotated)

Committer:
spinal
Date:
Sun Oct 15 16:13:07 2017 +0000
Revision:
9:570fdd653f1d
Parent:
2:968589ca3484
Child:
10:8cde5d0bafad
test

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Pokitto 0:e8b8f36b4505 1 /**************************************************************************/
Pokitto 0:e8b8f36b4505 2 /*!
Pokitto 0:e8b8f36b4505 3 @file PokittoDisplay.cpp
Pokitto 0:e8b8f36b4505 4 @author Jonne Valola
Pokitto 0:e8b8f36b4505 5
Pokitto 0:e8b8f36b4505 6 @section LICENSE
Pokitto 0:e8b8f36b4505 7
Pokitto 0:e8b8f36b4505 8 Software License Agreement (BSD License)
Pokitto 0:e8b8f36b4505 9
Pokitto 0:e8b8f36b4505 10 Copyright (c) 2016, Jonne Valola
Pokitto 0:e8b8f36b4505 11 All rights reserved.
Pokitto 0:e8b8f36b4505 12
Pokitto 0:e8b8f36b4505 13 Redistribution and use in source and binary forms, with or without
Pokitto 0:e8b8f36b4505 14 modification, are permitted provided that the following conditions are met:
Pokitto 0:e8b8f36b4505 15 1. Redistributions of source code must retain the above copyright
Pokitto 0:e8b8f36b4505 16 notice, this list of conditions and the following disclaimer.
Pokitto 0:e8b8f36b4505 17 2. Redistributions in binary form must reproduce the above copyright
Pokitto 0:e8b8f36b4505 18 notice, this list of conditions and the following disclaimer in the
Pokitto 0:e8b8f36b4505 19 documentation and/or other materials provided with the distribution.
Pokitto 0:e8b8f36b4505 20 3. Neither the name of the copyright holders nor the
Pokitto 0:e8b8f36b4505 21 names of its contributors may be used to endorse or promote products
Pokitto 0:e8b8f36b4505 22 derived from this software without specific prior written permission.
Pokitto 0:e8b8f36b4505 23
Pokitto 0:e8b8f36b4505 24 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
Pokitto 0:e8b8f36b4505 25 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
Pokitto 0:e8b8f36b4505 26 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
Pokitto 0:e8b8f36b4505 27 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
Pokitto 0:e8b8f36b4505 28 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
Pokitto 0:e8b8f36b4505 29 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
Pokitto 0:e8b8f36b4505 30 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
Pokitto 0:e8b8f36b4505 31 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
Pokitto 0:e8b8f36b4505 32 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
Pokitto 0:e8b8f36b4505 33 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Pokitto 0:e8b8f36b4505 34 */
Pokitto 0:e8b8f36b4505 35 /**************************************************************************/
Pokitto 0:e8b8f36b4505 36
Pokitto 0:e8b8f36b4505 37
Pokitto 0:e8b8f36b4505 38 /* THE SEGMENT BELOW PERTAINS TO CIRCLE DRAWING FUNCTIONS ONLY
Pokitto 0:e8b8f36b4505 39 *
Pokitto 0:e8b8f36b4505 40 This is the core graphics library for all our displays, providing a common
Pokitto 0:e8b8f36b4505 41 set of graphics primitives (points, lines, circles, etc.). It needs to be
Pokitto 0:e8b8f36b4505 42 paired with a hardware-specific library for each display device we carry
Pokitto 0:e8b8f36b4505 43 (to handle the lower-level functions).
Pokitto 0:e8b8f36b4505 44 Adafruit invests time and resources providing this open source code, please
Pokitto 0:e8b8f36b4505 45 support Adafruit & open-source hardware by purchasing products from Adafruit!
Pokitto 0:e8b8f36b4505 46 Copyright (c) 2013 Adafruit Industries. All rights reserved.
Pokitto 0:e8b8f36b4505 47 Redistribution and use in source and binary forms, with or without
Pokitto 0:e8b8f36b4505 48 modification, are permitted provided that the following conditions are met:
Pokitto 0:e8b8f36b4505 49 - Redistributions of source code must retain the above copyright notice,
Pokitto 0:e8b8f36b4505 50 this list of conditions and the following disclaimer.
Pokitto 0:e8b8f36b4505 51 - Redistributions in binary form must reproduce the above copyright notice,
Pokitto 0:e8b8f36b4505 52 this list of conditions and the following disclaimer in the documentation
Pokitto 0:e8b8f36b4505 53 and/or other materials provided with the distribution.
Pokitto 0:e8b8f36b4505 54 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
Pokitto 0:e8b8f36b4505 55 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
Pokitto 0:e8b8f36b4505 56 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
Pokitto 0:e8b8f36b4505 57 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
Pokitto 0:e8b8f36b4505 58 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
Pokitto 0:e8b8f36b4505 59 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
Pokitto 0:e8b8f36b4505 60 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
Pokitto 0:e8b8f36b4505 61 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
Pokitto 0:e8b8f36b4505 62 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
Pokitto 0:e8b8f36b4505 63 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
Pokitto 0:e8b8f36b4505 64 POSSIBILITY OF SUCH DAMAGE.
Pokitto 0:e8b8f36b4505 65 */
Pokitto 0:e8b8f36b4505 66
Pokitto 0:e8b8f36b4505 67 #include "PokittoDisplay.h"
Pokitto 0:e8b8f36b4505 68 #include "Pokitto_settings.h"
Pokitto 0:e8b8f36b4505 69 #include "GBcompatibility.h"
Pokitto 0:e8b8f36b4505 70 #include "PokittoCore.h"
Pokitto 0:e8b8f36b4505 71 #include "PokittoSound.h"
Pokitto 0:e8b8f36b4505 72 #include <stdio.h>
Pokitto 0:e8b8f36b4505 73 #include <string.h>
Pokitto 0:e8b8f36b4505 74
Pokitto 0:e8b8f36b4505 75 #ifndef POK_SIM
Pokitto 0:e8b8f36b4505 76 #include "HWLCD.h"
Pokitto 0:e8b8f36b4505 77 #else
Pokitto 0:e8b8f36b4505 78 #include "SimLCD.h"
Pokitto 0:e8b8f36b4505 79 #endif
Pokitto 0:e8b8f36b4505 80
Pokitto 0:e8b8f36b4505 81 Pokitto::Core core;
Pokitto 0:e8b8f36b4505 82 Pokitto::Sound sound;
Pokitto 0:e8b8f36b4505 83
Pokitto 0:e8b8f36b4505 84 using namespace Pokitto;
Pokitto 0:e8b8f36b4505 85
Pokitto 0:e8b8f36b4505 86
Pokitto 0:e8b8f36b4505 87
Pokitto 0:e8b8f36b4505 88 uint8_t* Display::m_scrbuf;
Pokitto 0:e8b8f36b4505 89 uint8_t* Display::m_tileset;
Pokitto 0:e8b8f36b4505 90 uint8_t* Display::m_tilebuf;
Pokitto 0:e8b8f36b4505 91 uint8_t* Display::m_tilecolorbuf;
Pokitto 0:e8b8f36b4505 92 uint8_t Display::m_mode, Display::m_colordepth;
Pokitto 0:e8b8f36b4505 93 uint8_t Display::fontSize=1;
Pokitto 0:e8b8f36b4505 94 int16_t Display::cursorX,Display::cursorY;
Pokitto 0:e8b8f36b4505 95 uint16_t Display::m_w,Display::m_h;
Pokitto 0:e8b8f36b4505 96 uint8_t Display::fontWidth, Display::fontHeight;
Pokitto 0:e8b8f36b4505 97 bool Display::textWrap=true;
Pokitto 0:e8b8f36b4505 98
Pokitto 0:e8b8f36b4505 99 uint8_t Display::persistence = 0;
Pokitto 0:e8b8f36b4505 100 uint16_t Display::color = 1;
Pokitto 0:e8b8f36b4505 101 uint16_t Display::bgcolor = 0;
Pokitto 0:e8b8f36b4505 102 uint16_t Display::invisiblecolor = 17;
Pokitto 0:e8b8f36b4505 103 uint16_t Display::directcolor=0xFFFF;
Pokitto 0:e8b8f36b4505 104 uint16_t Display::directbgcolor=0x0;
Pokitto 0:e8b8f36b4505 105
Pokitto 0:e8b8f36b4505 106 uint16_t* Display::paletteptr;
Pokitto 0:e8b8f36b4505 107 uint16_t Display::palette[PALETTE_SIZE];
Pokitto 0:e8b8f36b4505 108 const unsigned char* Display::font;
Pokitto 0:e8b8f36b4505 109 int8_t Display::adjustCharStep = 1;
Pokitto 0:e8b8f36b4505 110 int8_t Display::adjustLineStep = 1;
Pokitto 0:e8b8f36b4505 111 bool Display::fixedWidthFont = false;
Pokitto 0:e8b8f36b4505 112
Pokitto 0:e8b8f36b4505 113 /** drawing canvas **/
Pokitto 0:e8b8f36b4505 114 //uint8_t* Display::canvas; // points to the active buffer. if null, draw direct to screen
Pokitto 0:e8b8f36b4505 115
Pokitto 0:e8b8f36b4505 116 /** screenbuffer **/
Pokitto 0:e8b8f36b4505 117 uint8_t Display::bpp = POK_COLORDEPTH;
Pokitto 0:e8b8f36b4505 118 #ifndef POK_TILEDMODE
Pokitto 0:e8b8f36b4505 119 #if (POK_SCREENMODE == MODE_HI_MONOCHROME)
Pokitto 0:e8b8f36b4505 120 uint8_t Display::width = POK_LCD_W;
Pokitto 0:e8b8f36b4505 121 uint8_t Display::height = POK_LCD_H;
Pokitto 0:e8b8f36b4505 122 uint8_t Display::screenbuffer[((POK_LCD_H+1)*POK_LCD_W)*POK_COLORDEPTH/8]; // maximum resolution
Pokitto 0:e8b8f36b4505 123 #elif (POK_SCREENMODE == MODE_HI_4COLOR)
Pokitto 0:e8b8f36b4505 124 uint8_t Display::width = POK_LCD_W;
Pokitto 0:e8b8f36b4505 125 uint8_t Display::height = POK_LCD_H;
Pokitto 0:e8b8f36b4505 126 uint8_t __attribute__((section (".bss"))) Display::screenbuffer[((POK_LCD_H)*POK_LCD_W)/4]; // maximum resolution
Pokitto 0:e8b8f36b4505 127 #elif (POK_SCREENMODE == MODE_FAST_16COLOR)
Pokitto 0:e8b8f36b4505 128 uint8_t Display::width = POK_LCD_W/2;
Pokitto 0:e8b8f36b4505 129 uint8_t Display::height = POK_LCD_H/2;
Pokitto 0:e8b8f36b4505 130 uint8_t Display::screenbuffer[(((POK_LCD_H/2)+1)*POK_LCD_W/2)*POK_COLORDEPTH/8]; // half resolution
Pokitto 0:e8b8f36b4505 131 #elif (POK_SCREENMODE == MODE_HI_16COLOR)
Pokitto 0:e8b8f36b4505 132 uint8_t Display::width = POK_LCD_W;
Pokitto 0:e8b8f36b4505 133 uint8_t Display::height = POK_LCD_H;
Pokitto 0:e8b8f36b4505 134 uint8_t Display::screenbuffer[POK_LCD_H*POK_LCD_W/2]; // 4 bits per pixel
Pokitto 0:e8b8f36b4505 135 #elif (POK_SCREENMODE == MODE_LAMENES)
Pokitto 0:e8b8f36b4505 136 uint8_t Display::width = 128;
Pokitto 0:e8b8f36b4505 137 uint8_t Display::height = 120;
Pokitto 0:e8b8f36b4505 138 uint8_t Display::screenbuffer[((121)*128)*POK_COLORDEPTH/8]; // half resolution
Pokitto 0:e8b8f36b4505 139 #elif (POK_SCREENMODE == MODE_GAMEBOY)
Pokitto 0:e8b8f36b4505 140 uint8_t Display::width = 160;
Pokitto 0:e8b8f36b4505 141 uint8_t Display::height = 144;
Pokitto 0:e8b8f36b4505 142 uint8_t Display::screenbuffer[160*144/4];
Pokitto 0:e8b8f36b4505 143 #else
Pokitto 0:e8b8f36b4505 144 uint8_t Display::width = 84;
Pokitto 0:e8b8f36b4505 145 uint8_t Display::height = 48;
Pokitto 0:e8b8f36b4505 146 uint8_t Display::screenbuffer[128*64]; // not needed because Gamebuino and Arduboy have their own buffer
Pokitto 0:e8b8f36b4505 147 #endif
Pokitto 0:e8b8f36b4505 148 #else //Tiledmode
Pokitto 0:e8b8f36b4505 149 #if (POK_SCREENMODE == MODE_TILED_1BIT)
Pokitto 0:e8b8f36b4505 150 uint8_t Display::width = POK_LCD_W;
Pokitto 0:e8b8f36b4505 151 uint8_t Display::height = POK_LCD_H;
Pokitto 0:e8b8f36b4505 152 uint8_t Display::screenbuffer[0];
Pokitto 0:e8b8f36b4505 153 #else
Pokitto 0:e8b8f36b4505 154 uint8_t Display::width = POK_LCD_W;
Pokitto 0:e8b8f36b4505 155 uint8_t Display::height = POK_LCD_H;
Pokitto 0:e8b8f36b4505 156 uint8_t Display::screenbuffer[0];
Pokitto 0:e8b8f36b4505 157 #endif
Pokitto 0:e8b8f36b4505 158 #endif //tiledmode
Pokitto 0:e8b8f36b4505 159
Pokitto 0:e8b8f36b4505 160 // RLE decoding
Pokitto 0:e8b8f36b4505 161 #define RLE_ESC_EOL 0
Pokitto 0:e8b8f36b4505 162 #define RLE_ESC_EOB 1
Pokitto 0:e8b8f36b4505 163 #define RLE_ESC_OFFSET 2
Pokitto 0:e8b8f36b4505 164
Pokitto 0:e8b8f36b4505 165 Display::Display() {
Pokitto 0:e8b8f36b4505 166 m_scrbuf = screenbuffer;
Pokitto 0:e8b8f36b4505 167 setDefaultPalette();
Pokitto 0:e8b8f36b4505 168 m_mode = 1; // direct printing on by default
Pokitto 0:e8b8f36b4505 169 m_w = POK_LCD_W;
Pokitto 0:e8b8f36b4505 170 m_h = POK_LCD_H;
Pokitto 0:e8b8f36b4505 171 setFont(DEFAULT_FONT);
Pokitto 0:e8b8f36b4505 172 invisiblecolor=17;
Pokitto 0:e8b8f36b4505 173 bgcolor=0;
Pokitto 0:e8b8f36b4505 174 if (POK_COLORDEPTH) m_colordepth = POK_COLORDEPTH;
Pokitto 0:e8b8f36b4505 175 else m_colordepth = 4;
Pokitto 0:e8b8f36b4505 176 #if POK_GAMEBUINO_SUPPORT
Pokitto 0:e8b8f36b4505 177 setColorDepth(1);
Pokitto 0:e8b8f36b4505 178 #endif // POK_GAMEBUINO_SUPPORT
Pokitto 0:e8b8f36b4505 179 }
Pokitto 0:e8b8f36b4505 180
Pokitto 0:e8b8f36b4505 181 uint16_t Display::getWidth() {
Pokitto 0:e8b8f36b4505 182 return width;
Pokitto 0:e8b8f36b4505 183 }
Pokitto 0:e8b8f36b4505 184
Pokitto 0:e8b8f36b4505 185 uint8_t Display::getNumberOfColors() {
Pokitto 0:e8b8f36b4505 186 return 1<<POK_COLORDEPTH;
Pokitto 0:e8b8f36b4505 187 }
Pokitto 0:e8b8f36b4505 188
Pokitto 0:e8b8f36b4505 189 uint16_t Display::getHeight() {
Pokitto 0:e8b8f36b4505 190 return height;
Pokitto 0:e8b8f36b4505 191 }
Pokitto 0:e8b8f36b4505 192
Pokitto 0:e8b8f36b4505 193 uint8_t Display::getColorDepth() {
Pokitto 0:e8b8f36b4505 194 return m_colordepth;
Pokitto 0:e8b8f36b4505 195 }
Pokitto 0:e8b8f36b4505 196
Pokitto 0:e8b8f36b4505 197 void Display::setColorDepth(uint8_t v) {
Pokitto 0:e8b8f36b4505 198 if (v > POK_COLORDEPTH) v=POK_COLORDEPTH;
Pokitto 0:e8b8f36b4505 199 m_colordepth = v;
Pokitto 0:e8b8f36b4505 200 }
Pokitto 0:e8b8f36b4505 201
Pokitto 0:e8b8f36b4505 202 void Display::clearLCD() {
Pokitto 0:e8b8f36b4505 203 lcdFillSurface(0);
Pokitto 0:e8b8f36b4505 204 setCursor(0,0); // old basic computer style
Pokitto 0:e8b8f36b4505 205 }
Pokitto 0:e8b8f36b4505 206
Pokitto 0:e8b8f36b4505 207 void Display::fillLCD(uint16_t c) {
Pokitto 0:e8b8f36b4505 208 lcdFillSurface(c);
Pokitto 0:e8b8f36b4505 209 }
Pokitto 0:e8b8f36b4505 210
Pokitto 0:e8b8f36b4505 211 void Display::directPixel(int16_t x, int16_t y, uint16_t color) {
Pokitto 0:e8b8f36b4505 212 lcdPixel(x,y,color);
Pokitto 0:e8b8f36b4505 213 }
Pokitto 0:e8b8f36b4505 214
spinal 9:570fdd653f1d 215 void Display::directTile(int16_t x, int16_t y, int16_t x2, int16_t y2, uint16_t* gfx) {
spinal 9:570fdd653f1d 216 lcdTile(x,y,x2,y2,gfx);
spinal 9:570fdd653f1d 217 }
spinal 9:570fdd653f1d 218
Pokitto 0:e8b8f36b4505 219 void Display::directRectangle(int16_t x, int16_t y,int16_t x2, int16_t y2, uint16_t color) {
Pokitto 0:e8b8f36b4505 220 lcdRectangle(x,y,x2,y2,color);
Pokitto 0:e8b8f36b4505 221 }
Pokitto 0:e8b8f36b4505 222
Pokitto 0:e8b8f36b4505 223 void Display::begin() {
Pokitto 0:e8b8f36b4505 224 lcdInit();
Pokitto 0:e8b8f36b4505 225 }
Pokitto 0:e8b8f36b4505 226
Pokitto 0:e8b8f36b4505 227 void Display::setCursor(int16_t x,int16_t y) {
Pokitto 0:e8b8f36b4505 228 cursorX = x;
Pokitto 0:e8b8f36b4505 229 cursorY = y;
Pokitto 0:e8b8f36b4505 230 }
Pokitto 0:e8b8f36b4505 231
Pokitto 0:e8b8f36b4505 232 void Display::update() {
Pokitto 0:e8b8f36b4505 233
Pokitto 0:e8b8f36b4505 234 #if POK_SCREENMODE == MODE_GAMEBOY
Pokitto 0:e8b8f36b4505 235 lcdRefreshModeGBC(m_scrbuf, paletteptr);
Pokitto 0:e8b8f36b4505 236 #endif
Pokitto 0:e8b8f36b4505 237
Pokitto 0:e8b8f36b4505 238 #if POK_SCREENMODE == MODE_HI_4COLOR
Pokitto 0:e8b8f36b4505 239 lcdRefreshMode1(m_scrbuf, paletteptr);
Pokitto 0:e8b8f36b4505 240 #endif
Pokitto 0:e8b8f36b4505 241
Pokitto 0:e8b8f36b4505 242 #if POK_SCREENMODE == MODE_HI_16COLOR
Pokitto 0:e8b8f36b4505 243 lcdRefreshMode3(m_scrbuf, paletteptr);
Pokitto 0:e8b8f36b4505 244 #endif
Pokitto 0:e8b8f36b4505 245
Pokitto 0:e8b8f36b4505 246 #if POK_SCREENMODE == MODE_FAST_16COLOR
Pokitto 0:e8b8f36b4505 247 lcdRefreshMode2(m_scrbuf, paletteptr);
Pokitto 0:e8b8f36b4505 248 #endif
Pokitto 0:e8b8f36b4505 249
Pokitto 0:e8b8f36b4505 250 #if POK_SCREENMODE == MODE_GAMEBUINO_16COLOR
Pokitto 0:e8b8f36b4505 251 lcdRefreshGB(m_scrbuf, paletteptr);
Pokitto 0:e8b8f36b4505 252 #endif
Pokitto 0:e8b8f36b4505 253
Pokitto 0:e8b8f36b4505 254 #if POK_SCREENMODE == MODE_ARDUBOY_16COLOR
Pokitto 0:e8b8f36b4505 255 lcdRefreshAB(m_scrbuf, paletteptr);
Pokitto 0:e8b8f36b4505 256 #endif
Pokitto 0:e8b8f36b4505 257
Pokitto 0:e8b8f36b4505 258 #if POK_SCREENMODE == MODE_TILED_1BIT
Pokitto 0:e8b8f36b4505 259 lcdRefreshT1(m_tilebuf, m_tilecolorbuf, m_tileset, paletteptr);
Pokitto 0:e8b8f36b4505 260 #endif
Pokitto 0:e8b8f36b4505 261
Pokitto 0:e8b8f36b4505 262 if (!persistence) clear();
Pokitto 0:e8b8f36b4505 263
Pokitto 0:e8b8f36b4505 264 /** draw volume bar if visible **/
Pokitto 0:e8b8f36b4505 265 #if POK_SHOW_VOLUME > 0
Pokitto 0:e8b8f36b4505 266 if (core.volbar_visible) {
Pokitto 0:e8b8f36b4505 267 core.drawvolbar(4,20,sound.getVolume(),true);
Pokitto 0:e8b8f36b4505 268 core.volbar_visible--;
Pokitto 0:e8b8f36b4505 269 }
Pokitto 0:e8b8f36b4505 270 #endif // POK_SHOW_VOLUME
Pokitto 0:e8b8f36b4505 271
Pokitto 0:e8b8f36b4505 272 }
Pokitto 0:e8b8f36b4505 273
Pokitto 0:e8b8f36b4505 274 void Display::directBitmap(int16_t x, int16_t y, const uint8_t *bitmap, uint8_t depth, uint8_t scale) {
Pokitto 0:e8b8f36b4505 275 uint8_t w = *bitmap;
Pokitto 0:e8b8f36b4505 276 uint8_t h = *(bitmap + 1);
Pokitto 0:e8b8f36b4505 277 bitmap = bitmap + 2; //add an offset to the pointer to start after the width and height
Pokitto 0:e8b8f36b4505 278 int16_t i, j;
Pokitto 0:e8b8f36b4505 279 int8_t byteNum, bitNum, byteWidth = (w + 7) >> 3;
Pokitto 0:e8b8f36b4505 280
Pokitto 0:e8b8f36b4505 281 if (depth == 1) {
Pokitto 0:e8b8f36b4505 282 for (i = 0; i < w; i++) {
Pokitto 0:e8b8f36b4505 283 byteNum = i / 8;
Pokitto 0:e8b8f36b4505 284 bitNum = i % 8;
Pokitto 0:e8b8f36b4505 285 for (j = 0; j < h; j++) {
Pokitto 0:e8b8f36b4505 286 if (*(bitmap + j * byteWidth + byteNum) & (0x80 >> bitNum)) { //0x80 = B10000000
Pokitto 0:e8b8f36b4505 287 if (scale==1) directPixel(x + i, y + j,directcolor);
Pokitto 0:e8b8f36b4505 288 else {
Pokitto 0:e8b8f36b4505 289 directPixel(x + i + i, y + j + j,directcolor);
Pokitto 0:e8b8f36b4505 290 directPixel(x + 1 + i + i, y + j + j,directcolor);
Pokitto 0:e8b8f36b4505 291 directPixel(x + i + i, y + j + j + 1,directcolor);
Pokitto 0:e8b8f36b4505 292 directPixel(x + i + i + 1 , y + j + j + 1,directcolor);
Pokitto 0:e8b8f36b4505 293 }
Pokitto 0:e8b8f36b4505 294 }
Pokitto 0:e8b8f36b4505 295 }
Pokitto 0:e8b8f36b4505 296 }
Pokitto 0:e8b8f36b4505 297 } else if (depth == 4) {
Pokitto 0:e8b8f36b4505 298 for (j = 0; j < h; j+=1) {
Pokitto 0:e8b8f36b4505 299 for (i = 0; i < w; i+=2) {
Pokitto 0:e8b8f36b4505 300 uint16_t col = paletteptr[*bitmap>>4]; //higher nibble
Pokitto 0:e8b8f36b4505 301 if (scale==2) {
Pokitto 0:e8b8f36b4505 302 directPixel(x + (i<<1), y + (j<<1),col);
Pokitto 0:e8b8f36b4505 303 directPixel(x + (i<<1) + 1, y + (j<<1),col);
Pokitto 0:e8b8f36b4505 304 directPixel(x + (i<<1) + 1, y + (j<<1) + 1,col);
Pokitto 0:e8b8f36b4505 305 directPixel(x + (i<<1), y + (j<<1) + 1,col);
Pokitto 0:e8b8f36b4505 306 } else directPixel(x + i, y + j,col);
Pokitto 0:e8b8f36b4505 307 col = paletteptr[*bitmap&0xF]; // lower nibble
Pokitto 0:e8b8f36b4505 308 if (scale==2) {
Pokitto 0:e8b8f36b4505 309 directPixel(x + (i<<1) + 2, y + (j<<1),col);
Pokitto 0:e8b8f36b4505 310 directPixel(x + (i<<1) + 1 + 2, y + (j<<1),col);
Pokitto 0:e8b8f36b4505 311 directPixel(x + (i<<1) + 1 + 2, y + (j<<1) + 1,col);
Pokitto 0:e8b8f36b4505 312 directPixel(x + (i<<1) + 2 , y + (j<<1) + 1,col);
Pokitto 0:e8b8f36b4505 313 } else directPixel(x + i + 1, y + j,col);
Pokitto 0:e8b8f36b4505 314 bitmap++;
Pokitto 0:e8b8f36b4505 315 }
Pokitto 0:e8b8f36b4505 316 }
Pokitto 0:e8b8f36b4505 317 }
Pokitto 0:e8b8f36b4505 318
Pokitto 0:e8b8f36b4505 319 }
Pokitto 0:e8b8f36b4505 320
Pokitto 0:e8b8f36b4505 321 int Display::directChar(int16_t x, int16_t y, uint16_t index){
Pokitto 0:e8b8f36b4505 322 const uint8_t* bitmap = font;
Pokitto 0:e8b8f36b4505 323 uint8_t w = *bitmap;
Pokitto 0:e8b8f36b4505 324 uint8_t h = *(bitmap + 1);
Pokitto 0:e8b8f36b4505 325 uint8_t hbytes=0, xtra=1;
Pokitto 0:e8b8f36b4505 326 if (h==8 || h==16) xtra=0; //don't add if exactly on byte limit
Pokitto 0:e8b8f36b4505 327 hbytes=(h>>3)+xtra; //GLCD fonts are arranged w+1 times h/8 bytes
Pokitto 0:e8b8f36b4505 328 //bitmap = bitmap + 3 + index * h * ((w>>3)+xtra); //add an offset to the pointer (fonts !)
Pokitto 0:e8b8f36b4505 329 bitmap = bitmap + 4 + index * (w * hbytes + 1); //add an offset to the pointer (fonts !)
Pokitto 0:e8b8f36b4505 330 //int8_t i, j, byteNum, bitNum, byteWidth = (w + 7) >> 3;
Pokitto 0:e8b8f36b4505 331 int8_t i, j, numBytes;
Pokitto 0:e8b8f36b4505 332 numBytes = *bitmap++; //first byte of char is the width in bytes
Pokitto 0:e8b8f36b4505 333 // GLCD fonts are arranged LSB = topmost pixel of char, so its easy to just shift through the column
Pokitto 0:e8b8f36b4505 334 uint16_t bitcolumn; //16 bits for 2x8 bit high characters
Pokitto 0:e8b8f36b4505 335
Pokitto 0:e8b8f36b4505 336 for (i = 0; i < numBytes; i++) {
Pokitto 0:e8b8f36b4505 337 bitcolumn = *bitmap++;
Pokitto 0:e8b8f36b4505 338 if (hbytes == 2) bitcolumn |= (*bitmap++)<<8; // add second byte for 16 bit high fonts
Pokitto 0:e8b8f36b4505 339 for (j = 0; j < h; j++) {
Pokitto 0:e8b8f36b4505 340 if (bitcolumn&0x1) {
Pokitto 0:e8b8f36b4505 341 if (fontSize==2) {
Pokitto 0:e8b8f36b4505 342 directPixel(x + (i<<1) , y + (j<<1),directcolor);
Pokitto 0:e8b8f36b4505 343 directPixel(x + (i<<1)+1, y + (j<<1),directcolor);
Pokitto 0:e8b8f36b4505 344 directPixel(x + (i<<1) , y + (j<<1)+1,directcolor);
Pokitto 0:e8b8f36b4505 345 directPixel(x + (i<<1)+1, y + (j<<1)+1,directcolor);
Pokitto 0:e8b8f36b4505 346 } else directPixel(x + i, y + j,directcolor);
Pokitto 0:e8b8f36b4505 347 } else if (directbgcolor != invisiblecolor) {
Pokitto 0:e8b8f36b4505 348 if (fontSize==2) {
Pokitto 0:e8b8f36b4505 349 directPixel(x + (i<<1) , y + (j<<1),directbgcolor);
Pokitto 0:e8b8f36b4505 350 directPixel(x + (i<<1)+1, y + (j<<1),directbgcolor);
Pokitto 0:e8b8f36b4505 351 directPixel(x + (i<<1) , y + (j<<1)+1,directbgcolor);
Pokitto 0:e8b8f36b4505 352 directPixel(x + (i<<1)+1, y + (j<<1)+1,directbgcolor);
Pokitto 0:e8b8f36b4505 353 } else directPixel(x + i, y + j,directbgcolor);
Pokitto 0:e8b8f36b4505 354 }
Pokitto 0:e8b8f36b4505 355 bitcolumn>>=1;
Pokitto 0:e8b8f36b4505 356 }
Pokitto 0:e8b8f36b4505 357 }
Pokitto 0:e8b8f36b4505 358 return (numBytes+adjustCharStep)*fontSize; // for character stepping
Pokitto 0:e8b8f36b4505 359 }
Pokitto 0:e8b8f36b4505 360
Pokitto 0:e8b8f36b4505 361 int Display::bufferChar(int16_t x, int16_t y, uint16_t index){
Pokitto 0:e8b8f36b4505 362 const uint8_t* bitmap = font;
Pokitto 0:e8b8f36b4505 363 uint8_t w = *bitmap;
Pokitto 0:e8b8f36b4505 364 uint8_t h = *(bitmap + 1);
Pokitto 0:e8b8f36b4505 365 uint8_t hbytes=0, xtra=1;
Pokitto 0:e8b8f36b4505 366 if (h==8 || h==16) xtra=0; //don't add if exactly on byte limit
Pokitto 0:e8b8f36b4505 367 hbytes=(h>>3)+xtra; //GLCD fonts are arranged w+1 times h/8 bytes
Pokitto 0:e8b8f36b4505 368 //bitmap = bitmap + 3 + index * h * ((w>>3)+xtra); //add an offset to the pointer (fonts !)
Pokitto 0:e8b8f36b4505 369 bitmap = bitmap + 4 + index * (w * hbytes + 1); //add an offset to the pointer (fonts !)
Pokitto 0:e8b8f36b4505 370 //int8_t i, j, byteNum, bitNum, byteWidth = (w + 7) >> 3;
Pokitto 0:e8b8f36b4505 371 int8_t i, j, numBytes;
Pokitto 0:e8b8f36b4505 372 numBytes = *bitmap++; //first byte of char is the width in bytes
Pokitto 0:e8b8f36b4505 373 // GLCD fonts are arranged LSB = topmost pixel of char, so its easy to just shift through the column
Pokitto 0:e8b8f36b4505 374 uint16_t bitcolumn; //16 bits for 2x8 bit high characters
Pokitto 0:e8b8f36b4505 375
Pokitto 0:e8b8f36b4505 376 for (i = 0; i < numBytes; i++) {
Pokitto 0:e8b8f36b4505 377 bitcolumn = *bitmap++;
Pokitto 0:e8b8f36b4505 378 if (hbytes == 2) bitcolumn |= (*bitmap++)<<8; // add second byte for 16 bit high fonts
Pokitto 0:e8b8f36b4505 379 for (j = 0; j <= h; j++) { // was j<=h
Pokitto 0:e8b8f36b4505 380 #if PROJ_ARDUBOY > 0
Pokitto 0:e8b8f36b4505 381 if (bitcolumn&0x1) {
Pokitto 0:e8b8f36b4505 382 drawPixel(x + i, y + 7 - j,color);
Pokitto 0:e8b8f36b4505 383 } else drawPixel(x + i, y + 7 - j,bgcolor);
Pokitto 0:e8b8f36b4505 384 bitcolumn>>=1;
Pokitto 0:e8b8f36b4505 385 #else
Pokitto 0:e8b8f36b4505 386 if (bitcolumn&0x1) {
Pokitto 0:e8b8f36b4505 387 drawPixel(x + i, y + j,color);
Pokitto 0:e8b8f36b4505 388 } else drawPixel(x + i, y + j,bgcolor);
Pokitto 0:e8b8f36b4505 389 bitcolumn>>=1;
Pokitto 0:e8b8f36b4505 390 #endif // PROJ_ARDUBOY
Pokitto 0:e8b8f36b4505 391
Pokitto 0:e8b8f36b4505 392 }
Pokitto 0:e8b8f36b4505 393 }
Pokitto 0:e8b8f36b4505 394
Pokitto 0:e8b8f36b4505 395 return numBytes+adjustCharStep; // for character stepping
Pokitto 0:e8b8f36b4505 396 }
Pokitto 0:e8b8f36b4505 397
Pokitto 0:e8b8f36b4505 398 void Display::clear() {
Pokitto 0:e8b8f36b4505 399
Pokitto 0:e8b8f36b4505 400 uint8_t c=0;
Pokitto 0:e8b8f36b4505 401 c = bgcolor & (PALETTE_SIZE-1) ; //don't let palette go out of bounds
Pokitto 0:e8b8f36b4505 402 if (bpp==1 && bgcolor) c=0xFF; // bgcolor !=0, set all pixels
Pokitto 0:e8b8f36b4505 403 else if (bpp==2) {
Pokitto 0:e8b8f36b4505 404 c = bgcolor & 0x3;
Pokitto 0:e8b8f36b4505 405 c = c | (c << 2);
Pokitto 0:e8b8f36b4505 406 c = c | (c << 4);
Pokitto 0:e8b8f36b4505 407 } else {
Pokitto 0:e8b8f36b4505 408 c = (c & 0x0F) | (c << 4);
Pokitto 0:e8b8f36b4505 409 }
Pokitto 0:e8b8f36b4505 410 uint16_t j = sizeof(screenbuffer);
Pokitto 0:e8b8f36b4505 411 memset((void*)m_scrbuf,c,j);
Pokitto 0:e8b8f36b4505 412
Pokitto 0:e8b8f36b4505 413 setCursor(0,0);
Pokitto 0:e8b8f36b4505 414
Pokitto 0:e8b8f36b4505 415 }
Pokitto 0:e8b8f36b4505 416
Pokitto 0:e8b8f36b4505 417 void Display::scroll(int16_t pixelrows) {
Pokitto 0:e8b8f36b4505 418 uint16_t index = 0, index2,oc;
Pokitto 0:e8b8f36b4505 419 if (pixelrows==0) return;
Pokitto 0:e8b8f36b4505 420 if (pixelrows >= height) pixelrows=height-1;
Pokitto 0:e8b8f36b4505 421 if (bpp == 4) index2 = pixelrows*width/2;
Pokitto 0:e8b8f36b4505 422 else if (bpp == 2) index2 = pixelrows*width/4;
Pokitto 0:e8b8f36b4505 423 else return;
Pokitto 0:e8b8f36b4505 424 oc = color;
Pokitto 0:e8b8f36b4505 425 color = bgcolor;
Pokitto 0:e8b8f36b4505 426 if (pixelrows>0) {
Pokitto 0:e8b8f36b4505 427 for (uint16_t y=0;y<height-pixelrows;y++) {
Pokitto 0:e8b8f36b4505 428 for (uint16_t x=0;x<(width/8)*bpp;x++) screenbuffer[index++]=screenbuffer[index2++];
Pokitto 0:e8b8f36b4505 429 }
Pokitto 0:e8b8f36b4505 430 fillRect(0,cursorY,width,height);
Pokitto 0:e8b8f36b4505 431 } else {
Pokitto 0:e8b8f36b4505 432 for (uint16_t y=pixelrows;y<height;y++) {
Pokitto 0:e8b8f36b4505 433 for (uint16_t x=0;x<(width*bpp)/8;x++) screenbuffer[index2++]=screenbuffer[index2];
Pokitto 0:e8b8f36b4505 434 }
Pokitto 0:e8b8f36b4505 435 fillRect(0,0,width,pixelrows);
Pokitto 0:e8b8f36b4505 436 }
Pokitto 0:e8b8f36b4505 437 color=oc;
Pokitto 0:e8b8f36b4505 438 }
Pokitto 0:e8b8f36b4505 439
Pokitto 0:e8b8f36b4505 440 void Display::fillScreen(uint16_t c) {
Pokitto 0:e8b8f36b4505 441 c = c & (PALETTE_SIZE-1) ; //don't let palette go out of bounds
Pokitto 0:e8b8f36b4505 442 if (bpp==1 && c) c=0xFF; // set all pixels
Pokitto 0:e8b8f36b4505 443 else if (bpp==2) {
Pokitto 0:e8b8f36b4505 444 c = bgcolor & 0x3;
Pokitto 0:e8b8f36b4505 445 c = c | (c << 2);
Pokitto 0:e8b8f36b4505 446 c = c | (c << 4);
Pokitto 0:e8b8f36b4505 447 } else {
Pokitto 0:e8b8f36b4505 448 c = (c & 0x0F) | (c << 4);
Pokitto 0:e8b8f36b4505 449 }
Pokitto 0:e8b8f36b4505 450 memset((void*)m_scrbuf,c,sizeof(screenbuffer));
Pokitto 0:e8b8f36b4505 451 }
Pokitto 0:e8b8f36b4505 452
Pokitto 0:e8b8f36b4505 453 void Display::setDefaultPalette() {
Pokitto 0:e8b8f36b4505 454 #if PICOPALETTE
Pokitto 0:e8b8f36b4505 455 loadRGBPalette(palettePico);
Pokitto 0:e8b8f36b4505 456 #else
Pokitto 0:e8b8f36b4505 457 loadRGBPalette(POK_DEFAULT_PALETTE);
Pokitto 0:e8b8f36b4505 458 #endif //PICOPALETTE
Pokitto 0:e8b8f36b4505 459 }
Pokitto 0:e8b8f36b4505 460
Pokitto 0:e8b8f36b4505 461 void Display::setColor(uint8_t c) {
Pokitto 0:e8b8f36b4505 462 color = c & ((1<<POK_COLORDEPTH)-1); // cut out colors that go above palette limit
Pokitto 0:e8b8f36b4505 463 }
Pokitto 0:e8b8f36b4505 464
Pokitto 0:e8b8f36b4505 465 void Display::setColor(uint8_t c,uint8_t bgc){
Pokitto 0:e8b8f36b4505 466 color = c & ((1<<POK_COLORDEPTH)-1); // cut out colors that go above palette limit
Pokitto 0:e8b8f36b4505 467 bgcolor = bgc & ((1<<POK_COLORDEPTH)-1); // cut out colors that go above palette limit
Pokitto 0:e8b8f36b4505 468 }
Pokitto 0:e8b8f36b4505 469
Pokitto 0:e8b8f36b4505 470 void Display::setInvisibleColor(uint16_t c){
Pokitto 0:e8b8f36b4505 471 invisiblecolor = c; // invisible color can have values beyond 255 for identification purposes
Pokitto 0:e8b8f36b4505 472 }
Pokitto 0:e8b8f36b4505 473
Pokitto 0:e8b8f36b4505 474 uint8_t Display::getColor() {
Pokitto 0:e8b8f36b4505 475 return color;
Pokitto 0:e8b8f36b4505 476 }
Pokitto 0:e8b8f36b4505 477
Pokitto 0:e8b8f36b4505 478 uint8_t Display::getBgColor() {
Pokitto 0:e8b8f36b4505 479 return bgcolor;
Pokitto 0:e8b8f36b4505 480 }
Pokitto 0:e8b8f36b4505 481
Pokitto 0:e8b8f36b4505 482 uint16_t Display::getInvisibleColor() {
Pokitto 0:e8b8f36b4505 483 return invisiblecolor;
Pokitto 0:e8b8f36b4505 484 }
Pokitto 0:e8b8f36b4505 485
Pokitto 0:e8b8f36b4505 486 void Display::drawPixel(int16_t x,int16_t y, uint8_t col) {
Pokitto 0:e8b8f36b4505 487 if (col==invisiblecolor) return; // do not draw transparent pixels
Pokitto 0:e8b8f36b4505 488 if ((uint16_t)x >= width || (uint16_t)y >= height) return;
Pokitto 0:e8b8f36b4505 489 col &= (PALETTE_SIZE-1);
Pokitto 0:e8b8f36b4505 490 #if POK_GAMEBUINO_SUPPORT >0
Pokitto 0:e8b8f36b4505 491
Pokitto 0:e8b8f36b4505 492 uint8_t c = col;
Pokitto 0:e8b8f36b4505 493 uint8_t ct = col;
Pokitto 0:e8b8f36b4505 494
Pokitto 0:e8b8f36b4505 495 uint16_t bitptr=0;
Pokitto 0:e8b8f36b4505 496 for (uint8_t cbit=0;cbit<POK_COLORDEPTH;cbit++) {
Pokitto 0:e8b8f36b4505 497 c = ct & 1; // take the lowest bit of the color index number
Pokitto 0:e8b8f36b4505 498 if(c == 0){ //white - or actually "Clear bit"
Pokitto 0:e8b8f36b4505 499 m_scrbuf[x + (y / 8) * LCDWIDTH + bitptr] &= ~_BV(y % 8);
Pokitto 0:e8b8f36b4505 500 } else { //black - or actually "Set bit"
Pokitto 0:e8b8f36b4505 501 m_scrbuf[x + (y / 8) * LCDWIDTH + bitptr] |= _BV(y % 8);
Pokitto 0:e8b8f36b4505 502 }
Pokitto 0:e8b8f36b4505 503 ct >>=1; // shift to get next bit
Pokitto 0:e8b8f36b4505 504 bitptr += POK_BITFRAME; // move one screen worth of buffer forward to get to the next color bit
Pokitto 0:e8b8f36b4505 505 } // POK_COLOURDEPTH
Pokitto 0:e8b8f36b4505 506
Pokitto 0:e8b8f36b4505 507 #else
Pokitto 0:e8b8f36b4505 508 #if POK_COLORDEPTH == 1
Pokitto 0:e8b8f36b4505 509 if (col) {m_scrbuf[(y >> 3) * width + x] |= (0x80 >> (y & 7)); return;}
Pokitto 0:e8b8f36b4505 510 m_scrbuf[(y >> 3) * width + x] &= ~(0x80 >> (y & 7));
Pokitto 0:e8b8f36b4505 511 #elif POK_COLORDEPTH == 2
Pokitto 0:e8b8f36b4505 512 if (col) {
Pokitto 0:e8b8f36b4505 513 col &= 3;
Pokitto 0:e8b8f36b4505 514 }
Pokitto 0:e8b8f36b4505 515 uint16_t i = y*(width>>2) + (x>>2);
Pokitto 0:e8b8f36b4505 516 uint8_t pixel = m_scrbuf[i];
Pokitto 0:e8b8f36b4505 517 uint8_t column = x&0x03;
Pokitto 0:e8b8f36b4505 518 if (column==3) pixel = (pixel&0xFC)|(col); // bits 0-1
Pokitto 0:e8b8f36b4505 519 else if (column==2) pixel = (pixel&0xF3)|(col<<2); // bits 2-3
Pokitto 0:e8b8f36b4505 520 else if (column==1) pixel = (pixel&0xCF)|(col<<4); // bits 4-5
Pokitto 0:e8b8f36b4505 521 else pixel = (pixel&0x3F)|(col<<6); // bits 6-7
Pokitto 0:e8b8f36b4505 522 m_scrbuf[i] = pixel;
Pokitto 0:e8b8f36b4505 523 #elif POK_COLORDEPTH == 3
Pokitto 0:e8b8f36b4505 524 #elif POK_COLORDEPTH == 4
Pokitto 0:e8b8f36b4505 525 uint16_t i = y*(width>>1) + (x>>1);
Pokitto 0:e8b8f36b4505 526 uint8_t pixel = m_scrbuf[i];
Pokitto 0:e8b8f36b4505 527 if (x&1) pixel = (pixel&0xF0)|(col);
Pokitto 0:e8b8f36b4505 528 else pixel = (pixel&0x0F) | (col<<4);
Pokitto 0:e8b8f36b4505 529 m_scrbuf[i] = pixel;
Pokitto 0:e8b8f36b4505 530 #endif // POK_COLORDEPTH
Pokitto 0:e8b8f36b4505 531 #endif // POK_GAMEBUINO_SUPPORT
Pokitto 0:e8b8f36b4505 532 }
Pokitto 0:e8b8f36b4505 533
Pokitto 0:e8b8f36b4505 534 void Display::drawPixel(int16_t x,int16_t y) {
Pokitto 0:e8b8f36b4505 535 if ((uint16_t)x >= width || (uint16_t)y >= height) return;
Pokitto 0:e8b8f36b4505 536
Pokitto 0:e8b8f36b4505 537 #if POK_GAMEBUINO_SUPPORT > 0
Pokitto 0:e8b8f36b4505 538
Pokitto 0:e8b8f36b4505 539 uint8_t c = color;
Pokitto 0:e8b8f36b4505 540 uint8_t ct = color;
Pokitto 0:e8b8f36b4505 541 if(ct == INVERT){
Pokitto 0:e8b8f36b4505 542 ct = !getPixel(x, y); //jonne - was c = !getP...
Pokitto 0:e8b8f36b4505 543 }
Pokitto 0:e8b8f36b4505 544
Pokitto 0:e8b8f36b4505 545 uint16_t bitptr=0;
Pokitto 0:e8b8f36b4505 546 for (uint8_t cbit=0;cbit<POK_COLORDEPTH;cbit++) {
Pokitto 0:e8b8f36b4505 547 c = ct & 1; // take the lowest bit of the color index number
Pokitto 0:e8b8f36b4505 548 if(c == 0){ //white - or actually "Clear bit"
Pokitto 0:e8b8f36b4505 549 #if DISPLAY_ROT == NOROT
Pokitto 0:e8b8f36b4505 550 m_scrbuf[x + (y / 8) * LCDWIDTH + bitptr] &= ~_BV(y % 8);
Pokitto 0:e8b8f36b4505 551 #elif DISPLAY_ROT == ROTCCW
Pokitto 0:e8b8f36b4505 552 m_scrbuf[LCDHEIGHT - y - 1 + (x / 8) * LCDWIDTH_NOROT + bitptr] &= ~_BV(x % 8);
Pokitto 0:e8b8f36b4505 553 #elif DISPLAY_ROT == ROT180
Pokitto 0:e8b8f36b4505 554 m_scrbuf[LCDWIDTH - x - 1 + ((LCDHEIGHT - y - 1) / 8) * LCDWIDTH_NOROT + bitptr] &= ~_BV((LCDHEIGHT - y - 1) % 8);
Pokitto 0:e8b8f36b4505 555 #elif DISPLAY_ROT == ROTCW
Pokitto 0:e8b8f36b4505 556 m_scrbuf[y + ((LCDWIDTH - x - 1) / 8) * LCDWIDTH_NOROT + bitbtr] &= ~_BV((LCDWIDTH - x - 1) % 8);
Pokitto 0:e8b8f36b4505 557 #endif
Pokitto 0:e8b8f36b4505 558 //return; //jonne
Pokitto 0:e8b8f36b4505 559 } else { //black - or actually "Set bit"
Pokitto 0:e8b8f36b4505 560 #if DISPLAY_ROT == NOROT
Pokitto 0:e8b8f36b4505 561 m_scrbuf[x + (y / 8) * LCDWIDTH + bitptr] |= _BV(y % 8);
Pokitto 0:e8b8f36b4505 562 #elif DISPLAY_ROT == ROTCCW
Pokitto 0:e8b8f36b4505 563 m_scrbuf[LCDHEIGHT - y - 1 + (x / 8) * LCDWIDTH_NOROT + bitptr] |= _BV(x % 8);
Pokitto 0:e8b8f36b4505 564 #elif DISPLAY_ROT == ROT180
Pokitto 0:e8b8f36b4505 565 m_scrbuf[LCDWIDTH - x - 1 + ((LCDHEIGHT - y - 1) / 8) * LCDWIDTH_NOROT + bitptr] |= _BV((LCDHEIGHT - y - 1) % 8);
Pokitto 0:e8b8f36b4505 566 #elif DISPLAY_ROT == ROTCW
Pokitto 0:e8b8f36b4505 567 m_scrbuf[y + ((LCDWIDTH - x - 1) / 8) * LCDWIDTH_NOROT + bitptr] |= _BV((LCDWIDTH - x -1) % 8);
Pokitto 0:e8b8f36b4505 568 #endif
Pokitto 0:e8b8f36b4505 569 //return; //jonne
Pokitto 0:e8b8f36b4505 570 }
Pokitto 0:e8b8f36b4505 571 ct >>=1; // shift to get next bit
Pokitto 0:e8b8f36b4505 572 bitptr += POK_BITFRAME; // move one screen worth of buffer forward to get to the next color bit
Pokitto 0:e8b8f36b4505 573 } // POK_COLOURDEPTH
Pokitto 0:e8b8f36b4505 574
Pokitto 0:e8b8f36b4505 575 #else
Pokitto 0:e8b8f36b4505 576
Pokitto 0:e8b8f36b4505 577 /** NOT Gamebuino */
Pokitto 0:e8b8f36b4505 578 #if POK_COLORDEPTH == 1
Pokitto 0:e8b8f36b4505 579 if (color) {m_scrbuf[(y >> 3) * width + x] |= (0x80 >> (y & 7)); return;}
Pokitto 0:e8b8f36b4505 580 m_scrbuf[(y >> 3) * width + x] &= ~(0x80 >> (y & 7));
Pokitto 0:e8b8f36b4505 581 #elif POK_COLORDEPTH == 2
Pokitto 0:e8b8f36b4505 582 uint16_t i = y*(width>>2) + (x>>2);
Pokitto 0:e8b8f36b4505 583 uint8_t pixel = m_scrbuf[i];
Pokitto 0:e8b8f36b4505 584 uint8_t column = x&0x03;
Pokitto 0:e8b8f36b4505 585 if (column==3) pixel = (pixel&0xFC)|(color); // bits 0-1
Pokitto 0:e8b8f36b4505 586 else if (column==2) pixel = (pixel&0xF3)|(color<<2); // bits 2-3
Pokitto 0:e8b8f36b4505 587 else if (column==1) pixel = (pixel&0xCF)|(color<<4); // bits 4-5
Pokitto 0:e8b8f36b4505 588 else pixel = (pixel&0x3F)|(color<<6); // bits 6-7
Pokitto 0:e8b8f36b4505 589 m_scrbuf[i] = pixel;
Pokitto 0:e8b8f36b4505 590 #elif POK_COLORDEPTH == 3
Pokitto 0:e8b8f36b4505 591 #elif POK_COLORDEPTH == 4
Pokitto 0:e8b8f36b4505 592 uint16_t i = y*(width>>1) + (x>>1);
Pokitto 0:e8b8f36b4505 593 uint8_t pixel = m_scrbuf[i];
Pokitto 0:e8b8f36b4505 594 if (x&1) pixel = (pixel&0xF0)|(color);
Pokitto 0:e8b8f36b4505 595 else pixel = (pixel&0x0F) | (color<<4);
Pokitto 0:e8b8f36b4505 596 m_scrbuf[i] = pixel;
Pokitto 0:e8b8f36b4505 597 #endif // POK_COLORDEPTH
Pokitto 0:e8b8f36b4505 598 #endif // POK_GAMEBUINO_SUPPORT
Pokitto 0:e8b8f36b4505 599 }
Pokitto 0:e8b8f36b4505 600
Pokitto 0:e8b8f36b4505 601 uint8_t Display::getPixel(int16_t x,int16_t y) {
Pokitto 0:e8b8f36b4505 602 if ((uint16_t)x >= width || (uint16_t)y >= height) return 0;
Pokitto 0:e8b8f36b4505 603 #if POK_GAMEBUINO_SUPPORT
Pokitto 0:e8b8f36b4505 604 uint8_t color=0; //jonne
Pokitto 0:e8b8f36b4505 605 for (uint8_t cbit=0; cbit<POK_COLORDEPTH;cbit++) {
Pokitto 0:e8b8f36b4505 606 color |= (m_scrbuf[x + (y / 8) * LCDWIDTH+POK_BITFRAME*cbit] >> (y % 8)) & 0x1 ; //jonne - added +504*cbit
Pokitto 0:e8b8f36b4505 607 }
Pokitto 0:e8b8f36b4505 608 return color;
Pokitto 0:e8b8f36b4505 609 #else
Pokitto 0:e8b8f36b4505 610 /** not gamebuino */
Pokitto 0:e8b8f36b4505 611 #if POK_COLORDEPTH == 1
Pokitto 0:e8b8f36b4505 612 return (m_scrbuf[(y >> 3) * width + x] & (0x80 >> (y & 7))) ? 1:0;
Pokitto 0:e8b8f36b4505 613 #elif POK_COLORDEPTH == 2
Pokitto 0:e8b8f36b4505 614 uint16_t i = y*(width>>2) + (x>>2);
Pokitto 0:e8b8f36b4505 615 uint8_t pixel = m_scrbuf[i];
Pokitto 0:e8b8f36b4505 616 uint8_t column = x&0x03;
Pokitto 0:e8b8f36b4505 617 if (column==0) return pixel & 0x03; // bits 0-1
Pokitto 0:e8b8f36b4505 618 else if (column==1) return (pixel & 0x0C)>>2; // bits 2-3
Pokitto 0:e8b8f36b4505 619 else if (column==2) return (pixel & 0x30)>>4; // bits 4-5
Pokitto 0:e8b8f36b4505 620 else return pixel>>6;; // bits 6-7
Pokitto 0:e8b8f36b4505 621 #elif POK_COLORDEPTH == 3
Pokitto 0:e8b8f36b4505 622 #elif POK_COLORDEPTH == 4
Pokitto 0:e8b8f36b4505 623 uint16_t i = y*(width>>1) + (x>>1);
Pokitto 0:e8b8f36b4505 624 uint8_t pixel = m_scrbuf[i];
Pokitto 0:e8b8f36b4505 625 if (x&1) return pixel & 0x0F;
Pokitto 0:e8b8f36b4505 626 else return pixel>>4;
Pokitto 0:e8b8f36b4505 627 #endif // POK_COLORDEPTH
Pokitto 0:e8b8f36b4505 628 #endif // POK_GAMEBUINO_SUPPORT
Pokitto 0:e8b8f36b4505 629 }
Pokitto 0:e8b8f36b4505 630
Pokitto 0:e8b8f36b4505 631 void Display::drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1) {
Pokitto 0:e8b8f36b4505 632 if ((uint16_t)x0 >= width || (uint16_t)y0 >= height || (uint16_t)x1 >= width || (uint16_t)y1 >= height ) {
Pokitto 0:e8b8f36b4505 633 if (clipLine (&x0,&y0,&x1,&y1)==0) return; // line out of bounds
Pokitto 0:e8b8f36b4505 634 }
Pokitto 0:e8b8f36b4505 635 if (x0 == x1)
Pokitto 0:e8b8f36b4505 636 drawColumn(x0,y0,y1);
Pokitto 0:e8b8f36b4505 637 else if (y0 == y1)
Pokitto 0:e8b8f36b4505 638 drawRow(x0,x1,y0);
Pokitto 0:e8b8f36b4505 639 else {
Pokitto 0:e8b8f36b4505 640 int e;
Pokitto 0:e8b8f36b4505 641 signed int dx,dy,j, temp;
Pokitto 0:e8b8f36b4505 642 signed char s1,s2, xchange;
Pokitto 0:e8b8f36b4505 643 signed int x,y;
Pokitto 0:e8b8f36b4505 644
Pokitto 0:e8b8f36b4505 645 x = x0;
Pokitto 0:e8b8f36b4505 646 y = y0;
Pokitto 0:e8b8f36b4505 647
Pokitto 0:e8b8f36b4505 648 //take absolute value
Pokitto 0:e8b8f36b4505 649 if (x1 < x0) {
Pokitto 0:e8b8f36b4505 650 dx = x0 - x1;
Pokitto 0:e8b8f36b4505 651 s1 = -1;
Pokitto 0:e8b8f36b4505 652 }
Pokitto 0:e8b8f36b4505 653 else if (x1 == x0) {
Pokitto 0:e8b8f36b4505 654 dx = 0;
Pokitto 0:e8b8f36b4505 655 s1 = 0;
Pokitto 0:e8b8f36b4505 656 }
Pokitto 0:e8b8f36b4505 657 else {
Pokitto 0:e8b8f36b4505 658 dx = x1 - x0;
Pokitto 0:e8b8f36b4505 659 s1 = 1;
Pokitto 0:e8b8f36b4505 660 }
Pokitto 0:e8b8f36b4505 661
Pokitto 0:e8b8f36b4505 662 if (y1 < y0) {
Pokitto 0:e8b8f36b4505 663 dy = y0 - y1;
Pokitto 0:e8b8f36b4505 664 s2 = -1;
Pokitto 0:e8b8f36b4505 665 }
Pokitto 0:e8b8f36b4505 666 else if (y1 == y0) {
Pokitto 0:e8b8f36b4505 667 dy = 0;
Pokitto 0:e8b8f36b4505 668 s2 = 0;
Pokitto 0:e8b8f36b4505 669 }
Pokitto 0:e8b8f36b4505 670 else {
Pokitto 0:e8b8f36b4505 671 dy = y1 - y0;
Pokitto 0:e8b8f36b4505 672 s2 = 1;
Pokitto 0:e8b8f36b4505 673 }
Pokitto 0:e8b8f36b4505 674
Pokitto 0:e8b8f36b4505 675 xchange = 0;
Pokitto 0:e8b8f36b4505 676
Pokitto 0:e8b8f36b4505 677 if (dy>dx) {
Pokitto 0:e8b8f36b4505 678 temp = dx;
Pokitto 0:e8b8f36b4505 679 dx = dy;
Pokitto 0:e8b8f36b4505 680 dy = temp;
Pokitto 0:e8b8f36b4505 681 xchange = 1;
Pokitto 0:e8b8f36b4505 682 }
Pokitto 0:e8b8f36b4505 683
Pokitto 0:e8b8f36b4505 684 e = ((int)dy<<1) - dx;
Pokitto 0:e8b8f36b4505 685
Pokitto 0:e8b8f36b4505 686 for (j=0; j<=dx; j++) {
Pokitto 0:e8b8f36b4505 687 drawPixel(x,y);
Pokitto 0:e8b8f36b4505 688
Pokitto 0:e8b8f36b4505 689 if (e>=0) {
Pokitto 0:e8b8f36b4505 690 if (xchange==1) x = x + s1;
Pokitto 0:e8b8f36b4505 691 else y = y + s2;
Pokitto 0:e8b8f36b4505 692 e = e - ((int)dx<<1);
Pokitto 0:e8b8f36b4505 693 }
Pokitto 0:e8b8f36b4505 694 if (xchange==1)
Pokitto 0:e8b8f36b4505 695 y = y + s2;
Pokitto 0:e8b8f36b4505 696 else
Pokitto 0:e8b8f36b4505 697 x = x + s1;
Pokitto 0:e8b8f36b4505 698 e = e + ((int)dy<<1);
Pokitto 0:e8b8f36b4505 699 }
Pokitto 0:e8b8f36b4505 700 }
Pokitto 0:e8b8f36b4505 701 }
Pokitto 0:e8b8f36b4505 702
Pokitto 0:e8b8f36b4505 703 uint8_t Display::clipLine(int16_t *x0, int16_t *y0, int16_t *x1, int16_t *y1){
Pokitto 0:e8b8f36b4505 704 // Check X bounds
Pokitto 0:e8b8f36b4505 705 if (*x1<*x0) {
Pokitto 0:e8b8f36b4505 706 //std::swap (*x1,*x0); // swap so that we dont have to check x1 also
Pokitto 0:e8b8f36b4505 707 swapWT(int16_t*,x1,x0);
Pokitto 0:e8b8f36b4505 708 //std::swap (*y1,*y0); // y needs to be swaaped also
Pokitto 0:e8b8f36b4505 709 swapWT(int16_t*,y1,y0);
Pokitto 0:e8b8f36b4505 710 }
Pokitto 0:e8b8f36b4505 711
Pokitto 0:e8b8f36b4505 712 if (*x0>=width) return 0; // whole line is out of bounds
Pokitto 0:e8b8f36b4505 713
Pokitto 0:e8b8f36b4505 714 // Clip against X0 = 0
Pokitto 0:e8b8f36b4505 715 if (*x0 < 0) {
Pokitto 0:e8b8f36b4505 716 if ( *x1 < 0) return 0; // nothing visible
Pokitto 0:e8b8f36b4505 717 int16_t dx = (*x1 - *x0);
Pokitto 0:e8b8f36b4505 718 int16_t dy = ((*y1 - *y0) << 8); // 8.8 fixed point calculation trick
Pokitto 0:e8b8f36b4505 719 int16_t m = dy/dx;
Pokitto 0:e8b8f36b4505 720 *y0 = *y0 + ((m*-*x0)>>8); // get y0 at boundary
Pokitto 0:e8b8f36b4505 721 *x0 = 0;
Pokitto 0:e8b8f36b4505 722 }
Pokitto 0:e8b8f36b4505 723
Pokitto 0:e8b8f36b4505 724 // Clip against x1 = 83
Pokitto 0:e8b8f36b4505 725 if (*x1 >= width) {
Pokitto 0:e8b8f36b4505 726 int16_t dx = (*x1 - *x0);
Pokitto 0:e8b8f36b4505 727 int16_t dy = ((*y1 - *y0) << 8); // 8.8 fixed point calculation trick
Pokitto 0:e8b8f36b4505 728 int16_t m = dy/dx;
Pokitto 0:e8b8f36b4505 729 //*y1 = *y1 + ((m*(*x1-XMAX))>>8); // get y0 at boundary
Pokitto 0:e8b8f36b4505 730 *y1 = *y1 + ((m*(width-1-*x1))>>8); // get y0 at boundary
Pokitto 0:e8b8f36b4505 731 *x1 = width-1;
Pokitto 0:e8b8f36b4505 732 }
Pokitto 0:e8b8f36b4505 733
Pokitto 0:e8b8f36b4505 734 // Check Y bounds
Pokitto 0:e8b8f36b4505 735 if (*y1<*y0) {
Pokitto 0:e8b8f36b4505 736 //std::swap (*x1,*x0); // swap so that we dont have to check x1 also
Pokitto 0:e8b8f36b4505 737 swapWT(int16_t*,x1,x0);
Pokitto 0:e8b8f36b4505 738 //std::swap (*y1,*y0); // y needs to be swaaped also
Pokitto 0:e8b8f36b4505 739 swapWT(int16_t*,y1,y0);
Pokitto 0:e8b8f36b4505 740 }
Pokitto 0:e8b8f36b4505 741
Pokitto 0:e8b8f36b4505 742 if (*y0>=height) return 0; // whole line is out of bounds
Pokitto 0:e8b8f36b4505 743
Pokitto 0:e8b8f36b4505 744 if (*y0 < 0) {
Pokitto 0:e8b8f36b4505 745 if ( *y1 < 0) return 0; // nothing visible
Pokitto 0:e8b8f36b4505 746 int16_t dx = (*x1 - *x0) << 8;
Pokitto 0:e8b8f36b4505 747 int16_t dy = (*y1 - *y0); // 8.8 fixed point calculation trick
Pokitto 0:e8b8f36b4505 748 int16_t m = dx/dy;
Pokitto 0:e8b8f36b4505 749 *x0 = *x0 + ((m*-*y0)>>8); // get x0 at boundary
Pokitto 0:e8b8f36b4505 750 *y0 = 0;
Pokitto 0:e8b8f36b4505 751 }
Pokitto 0:e8b8f36b4505 752
Pokitto 0:e8b8f36b4505 753 // Clip against y1 = 47
Pokitto 0:e8b8f36b4505 754 if (*y1 >= height) {
Pokitto 0:e8b8f36b4505 755 int16_t dx = (*x1 - *x0) << 8;
Pokitto 0:e8b8f36b4505 756 int16_t dy = (*y1 - *y0); // 8.8 fixed point calculation trick
Pokitto 0:e8b8f36b4505 757 int16_t m = dx/dy;
Pokitto 0:e8b8f36b4505 758 *x1 = *x1 + ((m*(height-1-*y1))>>8); // get y0 at boundary
Pokitto 0:e8b8f36b4505 759 //*x1 = *x1 + ((m*(*y1-YMAX))>>8); // get y0 at boundary
Pokitto 0:e8b8f36b4505 760 *y1 = height-1;
Pokitto 0:e8b8f36b4505 761 }
Pokitto 0:e8b8f36b4505 762 return 1; // clipped succesfully
Pokitto 0:e8b8f36b4505 763 }
Pokitto 0:e8b8f36b4505 764
Pokitto 0:e8b8f36b4505 765 void Display::map1BitColumn(int16_t x, int16_t sy, int16_t ey, const uint8_t* bitmap, uint16_t column){
Pokitto 0:e8b8f36b4505 766 if ((uint16_t)sy>=height && (uint16_t)ey>=height) return; //completely out of bounds
Pokitto 0:e8b8f36b4505 767 if ((uint16_t)x>=width) return; //completely out of bounds
Pokitto 0:e8b8f36b4505 768 if (sy>ey) {
Pokitto 0:e8b8f36b4505 769 int y=sy;
Pokitto 0:e8b8f36b4505 770 sy=ey;
Pokitto 0:e8b8f36b4505 771 ey=y; // swap around so that x0 is less than x1
Pokitto 0:e8b8f36b4505 772 }
Pokitto 0:e8b8f36b4505 773 uint16_t bmw,bmh;
Pokitto 0:e8b8f36b4505 774 float texelstep, texelindex;
Pokitto 0:e8b8f36b4505 775 bmw = *(bitmap);
Pokitto 0:e8b8f36b4505 776 bmh = *(bitmap+1);
Pokitto 0:e8b8f36b4505 777 if (column>bmw-1) column=bmw-1;
Pokitto 0:e8b8f36b4505 778 bitmap += 2;
Pokitto 0:e8b8f36b4505 779 bitmap += column;
Pokitto 0:e8b8f36b4505 780 texelstep = (float)bmh/((float)ey-(float)sy);
Pokitto 0:e8b8f36b4505 781 texelindex = 0;
Pokitto 0:e8b8f36b4505 782 for (int y=sy; y <= ey; y++, texelindex += texelstep) {
Pokitto 0:e8b8f36b4505 783 uint8_t texel;
Pokitto 0:e8b8f36b4505 784 uint8_t currbyte, bit;
Pokitto 0:e8b8f36b4505 785 currbyte = texelindex / 8;
Pokitto 0:e8b8f36b4505 786 bit = 7-((uint16_t) texelindex & 0x7);
Pokitto 0:e8b8f36b4505 787 texel=*(bitmap+currbyte*bmw);
Pokitto 0:e8b8f36b4505 788 if (texel & (1<<bit)) drawPixel(x,y);
Pokitto 0:e8b8f36b4505 789 else if (bgcolor != invisiblecolor) drawPixel(x,y,bgcolor);
Pokitto 0:e8b8f36b4505 790 }
Pokitto 0:e8b8f36b4505 791 };
Pokitto 0:e8b8f36b4505 792
Pokitto 0:e8b8f36b4505 793 void Display::drawColumn(int16_t x, int16_t sy, int16_t ey){
Pokitto 0:e8b8f36b4505 794 if ((uint16_t)sy>=height && (uint16_t)ey>=height) return; //completely out of bounds
Pokitto 0:e8b8f36b4505 795 if ((uint16_t)x>=width) return; //completely out of bounds
Pokitto 0:e8b8f36b4505 796 if (sy>ey) {
Pokitto 0:e8b8f36b4505 797 int y=sy;
Pokitto 0:e8b8f36b4505 798 sy=ey;
Pokitto 0:e8b8f36b4505 799 ey=y; // swap around so that x0 is less than x1
Pokitto 0:e8b8f36b4505 800 }
Pokitto 0:e8b8f36b4505 801 for (int y=sy; y <= ey; y++) {
Pokitto 0:e8b8f36b4505 802 drawPixel(x,y);
Pokitto 0:e8b8f36b4505 803 }
Pokitto 0:e8b8f36b4505 804 }
Pokitto 0:e8b8f36b4505 805
Pokitto 0:e8b8f36b4505 806 void Display::drawRow(int16_t x0, int16_t x1, int16_t y){
Pokitto 0:e8b8f36b4505 807 if ((uint16_t)x0>=width && (uint16_t)x1>=width) return; //completely out of bounds
Pokitto 0:e8b8f36b4505 808 if ((uint16_t)y>=height) return; //completely out of bounds
Pokitto 0:e8b8f36b4505 809
Pokitto 0:e8b8f36b4505 810 if (x0>x1) {
Pokitto 0:e8b8f36b4505 811 int x=x0;
Pokitto 0:e8b8f36b4505 812 x0=x1;
Pokitto 0:e8b8f36b4505 813 x1=x; // swap around so that x0 is less than x1
Pokitto 0:e8b8f36b4505 814 }
Pokitto 0:e8b8f36b4505 815 for (int x=x0; x <= x1; x++) {
Pokitto 0:e8b8f36b4505 816 drawPixel(x,y);
Pokitto 0:e8b8f36b4505 817 }
Pokitto 0:e8b8f36b4505 818 }
Pokitto 0:e8b8f36b4505 819
Pokitto 0:e8b8f36b4505 820 void Display::drawFastVLine(int16_t x, int16_t y, int16_t h){
Pokitto 0:e8b8f36b4505 821 if (h<0) {y += h; h = -h;}
Pokitto 0:e8b8f36b4505 822 drawColumn(x,y,y+h);
Pokitto 0:e8b8f36b4505 823 }
Pokitto 0:e8b8f36b4505 824
Pokitto 0:e8b8f36b4505 825 void Display::drawFastHLine(int16_t x, int16_t y, int16_t w){
Pokitto 0:e8b8f36b4505 826 if (w<0) {x += w; w = -w;}
Pokitto 0:e8b8f36b4505 827 drawRow(x,x+w-1,y);
Pokitto 0:e8b8f36b4505 828 }
Pokitto 0:e8b8f36b4505 829
Pokitto 0:e8b8f36b4505 830 void Display::drawRectangle(int16_t x0, int16_t y0, int16_t w, int16_t h) {
Pokitto 0:e8b8f36b4505 831 drawColumn(x0,y0,y0+h);
Pokitto 0:e8b8f36b4505 832 drawColumn(x0+w,y0,y0+h);
Pokitto 0:e8b8f36b4505 833 drawRow(x0,x0+w,y0);
Pokitto 0:e8b8f36b4505 834 drawRow(x0,x0+w,y0+h);
Pokitto 0:e8b8f36b4505 835 }
Pokitto 0:e8b8f36b4505 836
Pokitto 0:e8b8f36b4505 837 void Display::fillRectangle(int16_t x0,int16_t y0, int16_t w, int16_t h){
Pokitto 0:e8b8f36b4505 838 int16_t x,y,x1,y1;
Pokitto 0:e8b8f36b4505 839 x1=x0+w;y1=y0+h;
Pokitto 0:e8b8f36b4505 840 if ((x0<0 && x1<0) || (x0>=width && x1 >=width)) return; //completely out of bounds
Pokitto 0:e8b8f36b4505 841 if ((y0<0 && y1<0) || (y0>=height && y1 >=height)) return; //completely out of bounds
Pokitto 0:e8b8f36b4505 842 if (x0>x1) {x=x1;x1=x0;}
Pokitto 0:e8b8f36b4505 843 else x=x0;
Pokitto 0:e8b8f36b4505 844 if (y0>y1) {y=y1;y1=y0;}
Pokitto 0:e8b8f36b4505 845 else y=y0;
Pokitto 0:e8b8f36b4505 846 if (x<0) x=0;
Pokitto 0:e8b8f36b4505 847 if (y<0) y=0;
Pokitto 0:e8b8f36b4505 848 for (;x<x1;x++) drawColumn(x,y,y1);
Pokitto 0:e8b8f36b4505 849 }
Pokitto 0:e8b8f36b4505 850
Pokitto 0:e8b8f36b4505 851 void Display::fillRect(int16_t x, int16_t y, int16_t w, int16_t h) {
Pokitto 0:e8b8f36b4505 852 fillRectangle(x,y,w,h);
Pokitto 0:e8b8f36b4505 853 }
Pokitto 0:e8b8f36b4505 854
Pokitto 0:e8b8f36b4505 855 void Display::drawRect(int16_t x, int16_t y, int16_t w, int16_t h) {
Pokitto 0:e8b8f36b4505 856 drawRectangle(x,y,w,h);
Pokitto 0:e8b8f36b4505 857 }
Pokitto 0:e8b8f36b4505 858
Pokitto 0:e8b8f36b4505 859 void Display::drawCircle(int16_t x0, int16_t y0, int16_t r) {
Pokitto 0:e8b8f36b4505 860 int16_t f = 1 - r;
Pokitto 0:e8b8f36b4505 861 int16_t ddF_x = 1;
Pokitto 0:e8b8f36b4505 862 int16_t ddF_y = -2 * r;
Pokitto 0:e8b8f36b4505 863 int16_t x = 0;
Pokitto 0:e8b8f36b4505 864 int16_t y = r;
Pokitto 0:e8b8f36b4505 865
Pokitto 0:e8b8f36b4505 866 drawPixel(x0, y0 + r);
Pokitto 0:e8b8f36b4505 867 drawPixel(x0, y0 - r);
Pokitto 0:e8b8f36b4505 868 drawPixel(x0 + r, y0);
Pokitto 0:e8b8f36b4505 869 drawPixel(x0 - r, y0);
Pokitto 0:e8b8f36b4505 870
Pokitto 0:e8b8f36b4505 871 while (x < y) {
Pokitto 0:e8b8f36b4505 872 if (f >= 0) {
Pokitto 0:e8b8f36b4505 873
Pokitto 0:e8b8f36b4505 874 y--;
Pokitto 0:e8b8f36b4505 875 ddF_y += 2;
Pokitto 0:e8b8f36b4505 876 f += ddF_y;
Pokitto 0:e8b8f36b4505 877 }
Pokitto 0:e8b8f36b4505 878 x++;
Pokitto 0:e8b8f36b4505 879 ddF_x += 2;
Pokitto 0:e8b8f36b4505 880 f += ddF_x;
Pokitto 0:e8b8f36b4505 881
Pokitto 0:e8b8f36b4505 882 drawPixel(x0 + x, y0 + y);
Pokitto 0:e8b8f36b4505 883 drawPixel(x0 - x, y0 + y);
Pokitto 0:e8b8f36b4505 884 drawPixel(x0 + x, y0 - y);
Pokitto 0:e8b8f36b4505 885 drawPixel(x0 - x, y0 - y);
Pokitto 0:e8b8f36b4505 886 drawPixel(x0 + y, y0 + x);
Pokitto 0:e8b8f36b4505 887 drawPixel(x0 - y, y0 + x);
Pokitto 0:e8b8f36b4505 888 drawPixel(x0 + y, y0 - x);
Pokitto 0:e8b8f36b4505 889 drawPixel(x0 - y, y0 - x);
Pokitto 0:e8b8f36b4505 890
Pokitto 0:e8b8f36b4505 891 }
Pokitto 0:e8b8f36b4505 892 }
Pokitto 0:e8b8f36b4505 893
Pokitto 0:e8b8f36b4505 894 void Display::drawCircleHelper(int16_t x0, int16_t y0, int16_t r, uint16_t cornername) {
Pokitto 0:e8b8f36b4505 895 int16_t f = 1 - r;
Pokitto 0:e8b8f36b4505 896 int16_t ddF_x = 1;
Pokitto 0:e8b8f36b4505 897 int16_t ddF_y = -2 * r;
Pokitto 0:e8b8f36b4505 898 int16_t x = 0;
Pokitto 0:e8b8f36b4505 899 int16_t y = r;
Pokitto 0:e8b8f36b4505 900
Pokitto 0:e8b8f36b4505 901 while (x < y) {
Pokitto 0:e8b8f36b4505 902 if (f >= 0) {
Pokitto 0:e8b8f36b4505 903 y--;
Pokitto 0:e8b8f36b4505 904 ddF_y += 2;
Pokitto 0:e8b8f36b4505 905 f += ddF_y;
Pokitto 0:e8b8f36b4505 906 }
Pokitto 0:e8b8f36b4505 907 x++;
Pokitto 0:e8b8f36b4505 908 ddF_x += 2;
Pokitto 0:e8b8f36b4505 909 f += ddF_x;
Pokitto 0:e8b8f36b4505 910 if (cornername & 0x4) {
Pokitto 0:e8b8f36b4505 911 drawPixel(x0 + x, y0 + y);
Pokitto 0:e8b8f36b4505 912 drawPixel(x0 + y, y0 + x);
Pokitto 0:e8b8f36b4505 913 }
Pokitto 0:e8b8f36b4505 914 if (cornername & 0x2) {
Pokitto 0:e8b8f36b4505 915 drawPixel(x0 + x, y0 - y);
Pokitto 0:e8b8f36b4505 916 drawPixel(x0 + y, y0 - x);
Pokitto 0:e8b8f36b4505 917 }
Pokitto 0:e8b8f36b4505 918 if (cornername & 0x8) {
Pokitto 0:e8b8f36b4505 919 drawPixel(x0 - y, y0 + x);
Pokitto 0:e8b8f36b4505 920 drawPixel(x0 - x, y0 + y);
Pokitto 0:e8b8f36b4505 921 }
Pokitto 0:e8b8f36b4505 922 if (cornername & 0x1) {
Pokitto 0:e8b8f36b4505 923
Pokitto 0:e8b8f36b4505 924 drawPixel(x0 - y, y0 - x);
Pokitto 0:e8b8f36b4505 925 drawPixel(x0 - x, y0 - y);
Pokitto 0:e8b8f36b4505 926 }
Pokitto 0:e8b8f36b4505 927 }
Pokitto 0:e8b8f36b4505 928 }
Pokitto 0:e8b8f36b4505 929
Pokitto 0:e8b8f36b4505 930 void Display::fillCircle(int16_t x0, int16_t y0, int16_t r) {
Pokitto 0:e8b8f36b4505 931 drawFastVLine(x0, y0 - r, 2 * r );
Pokitto 0:e8b8f36b4505 932 fillCircleHelper(x0, y0, r, 3, 0);
Pokitto 0:e8b8f36b4505 933 }
Pokitto 0:e8b8f36b4505 934
Pokitto 0:e8b8f36b4505 935 void Display::fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint16_t cornername, int16_t delta) {
Pokitto 0:e8b8f36b4505 936 int16_t f = 1 - r;
Pokitto 0:e8b8f36b4505 937 int16_t ddF_x = 1;
Pokitto 0:e8b8f36b4505 938 int16_t ddF_y = -2 * r;
Pokitto 0:e8b8f36b4505 939 int16_t x = 0;
Pokitto 0:e8b8f36b4505 940 int16_t y = r;
Pokitto 0:e8b8f36b4505 941
Pokitto 0:e8b8f36b4505 942 while (x < y) {
Pokitto 0:e8b8f36b4505 943 if (f >= 0) {
Pokitto 0:e8b8f36b4505 944 y--;
Pokitto 0:e8b8f36b4505 945 ddF_y += 2;
Pokitto 0:e8b8f36b4505 946 f += ddF_y;
Pokitto 0:e8b8f36b4505 947 }
Pokitto 0:e8b8f36b4505 948 x++;
Pokitto 0:e8b8f36b4505 949 ddF_x += 2;
Pokitto 0:e8b8f36b4505 950 f += ddF_x;
Pokitto 0:e8b8f36b4505 951
Pokitto 0:e8b8f36b4505 952 if (cornername & 0x1) {
Pokitto 0:e8b8f36b4505 953 drawFastVLine(x0 + x, y0 - y, 2 * y + 1 + delta-1); //added -1 here, jonne
Pokitto 0:e8b8f36b4505 954 drawFastVLine(x0 + y, y0 - x, 2 * x + 1 + delta-1); //added -1 here, jonne
Pokitto 0:e8b8f36b4505 955 }
Pokitto 0:e8b8f36b4505 956 if (cornername & 0x2) {
Pokitto 0:e8b8f36b4505 957
Pokitto 0:e8b8f36b4505 958 drawFastVLine(x0 - x, y0 - y, 2 * y + 1 + delta-1); //added -1 here, jonne
Pokitto 0:e8b8f36b4505 959 drawFastVLine(x0 - y, y0 - x, 2 * x + 1 + delta-1); //added -1 here, jonne
Pokitto 0:e8b8f36b4505 960 }
Pokitto 0:e8b8f36b4505 961 }
Pokitto 0:e8b8f36b4505 962 }
Pokitto 0:e8b8f36b4505 963
Pokitto 0:e8b8f36b4505 964 void Display::drawRoundRect(int16_t x, int16_t y, int16_t w,int16_t h, int16_t r) {
Pokitto 0:e8b8f36b4505 965 if (r<2) {drawRectangle(x,y,w,h);return;}
Pokitto 0:e8b8f36b4505 966 // smarter version
Pokitto 0:e8b8f36b4505 967 drawFastHLine(x + r, y, w - 2 * r); // Top
Pokitto 0:e8b8f36b4505 968 drawFastHLine(x + r, y + h - 1, w - 2 * r); // Bottom
Pokitto 0:e8b8f36b4505 969 drawFastVLine(x, y + r, h - 2 * r); // Left
Pokitto 0:e8b8f36b4505 970 drawFastVLine(x + w - 1, y + r, h - 2 * r); // Right
Pokitto 0:e8b8f36b4505 971 // draw four corners
Pokitto 0:e8b8f36b4505 972 drawCircleHelper(x + r, y + r, r, 1);
Pokitto 0:e8b8f36b4505 973 drawCircleHelper(x + w - r - 1, y + r, r, 2);
Pokitto 0:e8b8f36b4505 974 drawCircleHelper(x + w - r - 1, y + h - r - 1, r, 4);
Pokitto 0:e8b8f36b4505 975 drawCircleHelper(x + r, y + h - r - 1, r, 8);
Pokitto 0:e8b8f36b4505 976 }
Pokitto 0:e8b8f36b4505 977
Pokitto 0:e8b8f36b4505 978 void Display::fillRoundRect(int16_t x, int16_t y, int16_t w,int16_t h, int16_t r) {
Pokitto 0:e8b8f36b4505 979 if (r<2) {fillRectangle(x,y,w,h);return;}
Pokitto 0:e8b8f36b4505 980 fillRectangle(x + r, y, w - 2 * r, h-1);
Pokitto 0:e8b8f36b4505 981 // draw four corners
Pokitto 0:e8b8f36b4505 982 fillCircleHelper(x + w - r - 1, y + r, r, 1, h - 2 * r - 1);
Pokitto 0:e8b8f36b4505 983 fillCircleHelper(x + r, y + r, r, 2, h - 2 * r - 1);
Pokitto 0:e8b8f36b4505 984 }
Pokitto 0:e8b8f36b4505 985
Pokitto 0:e8b8f36b4505 986 void Display::drawTriangle(int16_t x0, int16_t y0,
Pokitto 0:e8b8f36b4505 987 int16_t x1, int16_t y1,
Pokitto 0:e8b8f36b4505 988 int16_t x2, int16_t y2) {
Pokitto 0:e8b8f36b4505 989 drawLine(x0, y0, x1, y1);
Pokitto 0:e8b8f36b4505 990 drawLine(x1, y1, x2, y2);
Pokitto 0:e8b8f36b4505 991 drawLine(x2, y2, x0, y0);
Pokitto 0:e8b8f36b4505 992 }
Pokitto 0:e8b8f36b4505 993
Pokitto 0:e8b8f36b4505 994 void Display::fillTriangle(int16_t x0, int16_t y0,
Pokitto 0:e8b8f36b4505 995 int16_t x1, int16_t y1,
Pokitto 0:e8b8f36b4505 996 int16_t x2, int16_t y2) {
Pokitto 0:e8b8f36b4505 997 int16_t a, b, y, last;
Pokitto 0:e8b8f36b4505 998
Pokitto 0:e8b8f36b4505 999 // Sort coordinates by Y order (y2 >= y1 >= y0)
Pokitto 0:e8b8f36b4505 1000 if (y0 > y1) {
Pokitto 0:e8b8f36b4505 1001 swapWT(int16_t,y0, y1);
Pokitto 0:e8b8f36b4505 1002 swapWT(int16_t,x0, x1);
Pokitto 0:e8b8f36b4505 1003 }
Pokitto 0:e8b8f36b4505 1004 if (y1 > y2) {
Pokitto 0:e8b8f36b4505 1005 swapWT(int16_t,y2, y1);
Pokitto 0:e8b8f36b4505 1006 swapWT(int16_t,x2, x1);
Pokitto 0:e8b8f36b4505 1007 }
Pokitto 0:e8b8f36b4505 1008 if (y0 > y1) {
Pokitto 0:e8b8f36b4505 1009 swapWT(int16_t,y0, y1);
Pokitto 0:e8b8f36b4505 1010 swapWT(int16_t,x0, x1);
Pokitto 0:e8b8f36b4505 1011 }
Pokitto 0:e8b8f36b4505 1012
Pokitto 0:e8b8f36b4505 1013 if (y0 == y2) { // Handle awkward all-on-same-line case as its own thing
Pokitto 0:e8b8f36b4505 1014 a = b = x0;
Pokitto 0:e8b8f36b4505 1015 if (x1 < a) a = x1;
Pokitto 0:e8b8f36b4505 1016 else if (x1 > b) b = x1;
Pokitto 0:e8b8f36b4505 1017 if (x2 < a) a = x2;
Pokitto 0:e8b8f36b4505 1018 else if (x2 > b) b = x2;
Pokitto 0:e8b8f36b4505 1019 drawFastHLine(a, y0, b - a + 1);
Pokitto 0:e8b8f36b4505 1020 return;
Pokitto 0:e8b8f36b4505 1021 }
Pokitto 0:e8b8f36b4505 1022
Pokitto 0:e8b8f36b4505 1023 int16_t
Pokitto 0:e8b8f36b4505 1024 dx01 = x1 - x0,
Pokitto 0:e8b8f36b4505 1025 dy01 = y1 - y0,
Pokitto 0:e8b8f36b4505 1026 dx02 = x2 - x0,
Pokitto 0:e8b8f36b4505 1027 dy02 = y2 - y0,
Pokitto 0:e8b8f36b4505 1028 dx12 = x2 - x1,
Pokitto 0:e8b8f36b4505 1029 dy12 = y2 - y1,
Pokitto 0:e8b8f36b4505 1030 sa = 0,
Pokitto 0:e8b8f36b4505 1031 sb = 0;
Pokitto 0:e8b8f36b4505 1032
Pokitto 0:e8b8f36b4505 1033 // For upper part of triangle, find scanline crossings for segments
Pokitto 0:e8b8f36b4505 1034 // 0-1 and 0-2. If y1=y2 (flat-bottomed triangle), the scanline y1
Pokitto 0:e8b8f36b4505 1035 // is included here (and second loop will be skipped, avoiding a /0
Pokitto 0:e8b8f36b4505 1036 // error there), otherwise scanline y1 is skipped here and handled
Pokitto 0:e8b8f36b4505 1037 // in the second loop...which also avoids a /0 error here if y0=y1
Pokitto 0:e8b8f36b4505 1038 // (flat-topped triangle).
Pokitto 0:e8b8f36b4505 1039 if (y1 == y2) last = y1; // Include y1 scanline
Pokitto 0:e8b8f36b4505 1040 else last = y1 - 1; // Skip it
Pokitto 0:e8b8f36b4505 1041
Pokitto 0:e8b8f36b4505 1042 for (y = y0; y <= last; y++) {
Pokitto 0:e8b8f36b4505 1043 a = x0 + sa / dy01;
Pokitto 0:e8b8f36b4505 1044 b = x0 + sb / dy02;
Pokitto 0:e8b8f36b4505 1045 sa += dx01;
Pokitto 0:e8b8f36b4505 1046 sb += dx02;
Pokitto 0:e8b8f36b4505 1047 /* longhand:
Pokitto 0:e8b8f36b4505 1048 a = x0 + (x1 - x0) * (y - y0) / (y1 - y0);
Pokitto 0:e8b8f36b4505 1049 b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
Pokitto 0:e8b8f36b4505 1050 */
Pokitto 0:e8b8f36b4505 1051 if (a > b) swapWT(int16_t,a, b);
Pokitto 0:e8b8f36b4505 1052 drawFastHLine(a, y, b - a + 1);
Pokitto 0:e8b8f36b4505 1053 }
Pokitto 0:e8b8f36b4505 1054
Pokitto 0:e8b8f36b4505 1055 // For lower part of triangle, find scanline crossings for segments
Pokitto 0:e8b8f36b4505 1056 // 0-2 and 1-2. This loop is skipped if y1=y2.
Pokitto 0:e8b8f36b4505 1057 sa = dx12 * (y - y1);
Pokitto 0:e8b8f36b4505 1058 sb = dx02 * (y - y0);
Pokitto 0:e8b8f36b4505 1059 for (; y <= y2; y++) {
Pokitto 0:e8b8f36b4505 1060 a = x1 + sa / dy12;
Pokitto 0:e8b8f36b4505 1061 b = x0 + sb / dy02;
Pokitto 0:e8b8f36b4505 1062 sa += dx12;
Pokitto 0:e8b8f36b4505 1063 sb += dx02;
Pokitto 0:e8b8f36b4505 1064
Pokitto 0:e8b8f36b4505 1065 if (a > b) swapWT(int16_t,a, b);
Pokitto 0:e8b8f36b4505 1066 drawFastHLine(a, y, b - a + 1);
Pokitto 0:e8b8f36b4505 1067 }
Pokitto 0:e8b8f36b4505 1068 }
Pokitto 0:e8b8f36b4505 1069
Pokitto 0:e8b8f36b4505 1070 void Display::setFont(const unsigned char * f) {
Pokitto 0:e8b8f36b4505 1071 font = f;
Pokitto 0:e8b8f36b4505 1072 fontWidth = *(font)+1;
Pokitto 0:e8b8f36b4505 1073 fontHeight = *(font + 1)+1;
Pokitto 0:e8b8f36b4505 1074 }
Pokitto 0:e8b8f36b4505 1075
Pokitto 0:e8b8f36b4505 1076 void Display::drawMonoBitmap(int16_t x, int16_t y, const uint8_t* bitmap, uint8_t index) {
Pokitto 0:e8b8f36b4505 1077 uint8_t w = *bitmap;
Pokitto 0:e8b8f36b4505 1078 uint8_t h = *(bitmap + 1);
Pokitto 0:e8b8f36b4505 1079 uint8_t xtra=0;
Pokitto 0:e8b8f36b4505 1080 if (w&0x7) xtra=1;
Pokitto 0:e8b8f36b4505 1081 bitmap = bitmap + 3 + index * h * ((w>>3)+xtra); //add an offset to the pointer (fonts !)
Pokitto 0:e8b8f36b4505 1082 #if POK_GAMEBUINO_SUPPORT > 0
Pokitto 0:e8b8f36b4505 1083 int8_t i, j, byteNum, bitNum, byteWidth = (w + 7) >> 3;
Pokitto 0:e8b8f36b4505 1084 for (i = 0; i < w; i++) {
Pokitto 0:e8b8f36b4505 1085 byteNum = i / 8;
Pokitto 0:e8b8f36b4505 1086 bitNum = i % 8;
Pokitto 0:e8b8f36b4505 1087 for (j = 0; j < h; j++) {
Pokitto 0:e8b8f36b4505 1088 uint8_t source = *(bitmap + j * byteWidth + byteNum);
Pokitto 0:e8b8f36b4505 1089 if (source & (0x80 >> bitNum)) {
Pokitto 0:e8b8f36b4505 1090 drawPixel(x + i, y + j);
Pokitto 0:e8b8f36b4505 1091 }
Pokitto 0:e8b8f36b4505 1092 }
Pokitto 0:e8b8f36b4505 1093 }
Pokitto 0:e8b8f36b4505 1094 #else
Pokitto 0:e8b8f36b4505 1095 /** not gamebuino */
Pokitto 0:e8b8f36b4505 1096 int8_t scrx,scry;
Pokitto 0:e8b8f36b4505 1097 uint8_t* scrptr = m_scrbuf + (y*(width>>1) + (x>>1));
Pokitto 0:e8b8f36b4505 1098 int8_t bitptr;
Pokitto 0:e8b8f36b4505 1099 for (scry = y; scry < y+h; scry+=1) {
Pokitto 0:e8b8f36b4505 1100 if ((x&1)==0) { /** EVEN pixel starting line**/
Pokitto 0:e8b8f36b4505 1101 for (scrx = x, bitptr=7; scrx < w+x; scrx+=2) {
Pokitto 0:e8b8f36b4505 1102 uint8_t targetpixel = *scrptr;
Pokitto 0:e8b8f36b4505 1103 if (*bitmap & (1<<bitptr)) targetpixel = (targetpixel & 0xF) | color<<4; // upper nibble
Pokitto 0:e8b8f36b4505 1104 else if (bgcolor != invisiblecolor) targetpixel = (targetpixel & 0xF) | bgcolor<<4; // upper nibble
Pokitto 0:e8b8f36b4505 1105 bitptr--;
Pokitto 0:e8b8f36b4505 1106 if (*bitmap & (1<<bitptr)) targetpixel = (targetpixel & 0xF0) | color; // lower nibble
Pokitto 0:e8b8f36b4505 1107 else if (bgcolor != invisiblecolor) targetpixel = (targetpixel & 0xF0) | bgcolor; // lower nibble
Pokitto 0:e8b8f36b4505 1108 bitptr--;
Pokitto 0:e8b8f36b4505 1109 if (bitptr<0) { bitptr = 7; bitmap++; }
Pokitto 0:e8b8f36b4505 1110 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 1111 scrptr++;
Pokitto 0:e8b8f36b4505 1112 }
Pokitto 0:e8b8f36b4505 1113 } else { /** ODD pixel starting line **/
Pokitto 0:e8b8f36b4505 1114 for (scrx = x, bitptr=7; scrx < w+x; scrx+=2) {
Pokitto 0:e8b8f36b4505 1115 uint8_t targetpixel = *scrptr;
Pokitto 0:e8b8f36b4505 1116 // store higher nibble of source pixel in lower nibble of target
Pokitto 0:e8b8f36b4505 1117 if (*bitmap & (1<<bitptr)) targetpixel = (targetpixel & 0xF0) | color; // lower nibble
Pokitto 0:e8b8f36b4505 1118 else if (bgcolor != invisiblecolor) targetpixel = (targetpixel & 0xF0) | bgcolor; // lower nibble
Pokitto 0:e8b8f36b4505 1119 *scrptr = targetpixel; // store
Pokitto 0:e8b8f36b4505 1120 bitptr--;scrptr++;targetpixel = *scrptr;
Pokitto 0:e8b8f36b4505 1121 // store lower nibble of source pixel in higher nibble of target
Pokitto 0:e8b8f36b4505 1122 if (*bitmap & (1<<bitptr)) targetpixel = (targetpixel & 0xF) | color<<4; // higher nibble
Pokitto 0:e8b8f36b4505 1123 else if (bgcolor != invisiblecolor) targetpixel = (targetpixel & 0xF) | bgcolor<<4; // higher nibble
Pokitto 0:e8b8f36b4505 1124 *scrptr = targetpixel; // store
Pokitto 0:e8b8f36b4505 1125 bitptr--; // do not increment scrptr here !
Pokitto 0:e8b8f36b4505 1126 }
Pokitto 0:e8b8f36b4505 1127 }
Pokitto 0:e8b8f36b4505 1128 if (bitptr!=7) bitmap++; // force skip to next line
Pokitto 0:e8b8f36b4505 1129 // increment the y jump in the scrptr
Pokitto 0:e8b8f36b4505 1130 scrptr = scrptr + ((width - w)>>1);
Pokitto 0:e8b8f36b4505 1131 }
Pokitto 0:e8b8f36b4505 1132 #endif // POK_GAMEBUINO_SUPPORT
Pokitto 0:e8b8f36b4505 1133 }
Pokitto 0:e8b8f36b4505 1134
Pokitto 0:e8b8f36b4505 1135
Pokitto 0:e8b8f36b4505 1136 void Display::drawBitmap(int16_t x, int16_t y, const uint8_t* bitmap, uint8_t frame)
Pokitto 0:e8b8f36b4505 1137 {
Pokitto 0:e8b8f36b4505 1138 int16_t w = *bitmap;
Pokitto 0:e8b8f36b4505 1139 int16_t h = *(bitmap + 1);
Pokitto 0:e8b8f36b4505 1140 uint8_t framew = *(bitmap+2);
Pokitto 0:e8b8f36b4505 1141 bitmap = bitmap + 3; //add an offset to the pointer to start after the width and height
Pokitto 0:e8b8f36b4505 1142 /** visibility check */
Pokitto 0:e8b8f36b4505 1143 if (y<-h || y>height) return; //invisible
Pokitto 0:e8b8f36b4505 1144 if (x<-framew || x>width) return; //invisible
Pokitto 0:e8b8f36b4505 1145 /** 1 bpp mode */
Pokitto 0:e8b8f36b4505 1146 if (m_colordepth<2) {
Pokitto 0:e8b8f36b4505 1147 int16_t i, j, byteNum, bitNum, byteWidth = (w + 7) >> 3;
Pokitto 0:e8b8f36b4505 1148 for (i = 0; i < w; i++) {
Pokitto 0:e8b8f36b4505 1149 byteNum = i / 8;
Pokitto 0:e8b8f36b4505 1150 bitNum = i % 8;
Pokitto 0:e8b8f36b4505 1151 for (j = 0; j < h; j++) {
Pokitto 0:e8b8f36b4505 1152 uint8_t source = *(bitmap + j * byteWidth + byteNum);
Pokitto 0:e8b8f36b4505 1153 if (source & (0x80 >> bitNum)) {
Pokitto 0:e8b8f36b4505 1154 drawPixel(x + i, y + j);
Pokitto 0:e8b8f36b4505 1155 }
Pokitto 0:e8b8f36b4505 1156 }
Pokitto 0:e8b8f36b4505 1157 }
Pokitto 0:e8b8f36b4505 1158
Pokitto 0:e8b8f36b4505 1159 return;
Pokitto 0:e8b8f36b4505 1160 }
Pokitto 0:e8b8f36b4505 1161 /** 2 bpp mode */
Pokitto 0:e8b8f36b4505 1162 if (m_colordepth<4) {
Pokitto 0:e8b8f36b4505 1163 int16_t i, j, byteNum, bitNum, byteWidth = w >> 2;
Pokitto 0:e8b8f36b4505 1164 for (i = 0; i < w; i++) {
Pokitto 0:e8b8f36b4505 1165 byteNum = i / 4;
Pokitto 0:e8b8f36b4505 1166 bitNum = (i % 4)<<1;
Pokitto 0:e8b8f36b4505 1167 for (j = 0; j < h; j++) {
Pokitto 0:e8b8f36b4505 1168 uint8_t source = *(bitmap + j * byteWidth + byteNum);
Pokitto 0:e8b8f36b4505 1169 uint8_t output = (source & (0xC0 >> bitNum));
Pokitto 0:e8b8f36b4505 1170 output >>= (6-bitNum);
Pokitto 0:e8b8f36b4505 1171 if (output != invisiblecolor) {
Pokitto 0:e8b8f36b4505 1172 setColor(output);
Pokitto 0:e8b8f36b4505 1173 drawPixel(x + i, y + j);
Pokitto 0:e8b8f36b4505 1174 }
Pokitto 0:e8b8f36b4505 1175 }
Pokitto 0:e8b8f36b4505 1176 }
Pokitto 0:e8b8f36b4505 1177
Pokitto 0:e8b8f36b4505 1178 return;
Pokitto 0:e8b8f36b4505 1179 }
Pokitto 0:e8b8f36b4505 1180 /** 4bpp fast version */
Pokitto 0:e8b8f36b4505 1181 int16_t scrx,scry,xclip,xjump,scrxjump;
Pokitto 0:e8b8f36b4505 1182 xclip=xjump=scrxjump=0;
Pokitto 0:e8b8f36b4505 1183 bitmap += (framew*frame)>>1;
Pokitto 0:e8b8f36b4505 1184 /** y clipping */
Pokitto 0:e8b8f36b4505 1185 if (y<0) { h+=y; bitmap -= y*(w>>1); y=0;}
Pokitto 0:e8b8f36b4505 1186 else if (y+h>height) { h -=(y-height);}
Pokitto 0:e8b8f36b4505 1187 /** x clipping */
Pokitto 0:e8b8f36b4505 1188 xjump = (w-framew)>>1;
Pokitto 0:e8b8f36b4505 1189 if (x<0) { xclip=(x&1)<<1; framew+=x; xjump = ((-x)>>1); bitmap += xjump; x=0;}
Pokitto 0:e8b8f36b4505 1190 else if (x+framew>width) {
Pokitto 0:e8b8f36b4505 1191 xclip = (x&1)<<1;
Pokitto 0:e8b8f36b4505 1192 scrxjump = x&1;
Pokitto 0:e8b8f36b4505 1193 xjump=((x+framew-width)>>1)+scrxjump;
Pokitto 0:e8b8f36b4505 1194 framew = width-x;}
Pokitto 0:e8b8f36b4505 1195
Pokitto 0:e8b8f36b4505 1196 uint8_t* scrptr = m_scrbuf + (y*(width>>1) + (x>>1));
Pokitto 0:e8b8f36b4505 1197 /** ONLY 4-bit mode for time being **/
Pokitto 0:e8b8f36b4505 1198 for (scry = y; scry < y+h; scry+=1) {
Pokitto 0:e8b8f36b4505 1199 if (scry>=height) return;
Pokitto 0:e8b8f36b4505 1200 if ((x&1)==0) { /** EVEN pixel starting line, very simple, just copypaste **/
Pokitto 0:e8b8f36b4505 1201 for (scrx = x; scrx < framew+x-xclip; scrx+=2) {
Pokitto 0:e8b8f36b4505 1202 uint8_t sourcepixel = *bitmap;
Pokitto 0:e8b8f36b4505 1203 if (xclip) {
Pokitto 0:e8b8f36b4505 1204 sourcepixel <<=4;
Pokitto 0:e8b8f36b4505 1205 sourcepixel |= ((*(bitmap+1))>>4);
Pokitto 0:e8b8f36b4505 1206 }
Pokitto 0:e8b8f36b4505 1207 uint8_t targetpixel = *scrptr;
Pokitto 0:e8b8f36b4505 1208 if ((sourcepixel>>4) != invisiblecolor ) targetpixel = (targetpixel&0x0F) | (sourcepixel & 0xF0);
Pokitto 0:e8b8f36b4505 1209 if ((sourcepixel&0x0F) != invisiblecolor) targetpixel = (targetpixel & 0xF0) | (sourcepixel & 0x0F);
Pokitto 0:e8b8f36b4505 1210 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 1211 bitmap++;
Pokitto 0:e8b8f36b4505 1212 scrptr++;
Pokitto 0:e8b8f36b4505 1213 }
Pokitto 0:e8b8f36b4505 1214 if (xclip){
Pokitto 0:e8b8f36b4505 1215 if (framew&1) {
Pokitto 0:e8b8f36b4505 1216 /**last pixel is odd pixel due to clipping & odd width*/
Pokitto 0:e8b8f36b4505 1217 uint8_t sourcepixel = *bitmap;
Pokitto 0:e8b8f36b4505 1218 if ((sourcepixel&0x0F) != invisiblecolor) {
Pokitto 0:e8b8f36b4505 1219 sourcepixel <<=4;
Pokitto 0:e8b8f36b4505 1220 uint8_t targetpixel = *scrptr;// & 0x0F;
Pokitto 0:e8b8f36b4505 1221 targetpixel |= sourcepixel;
Pokitto 0:e8b8f36b4505 1222 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 1223 }
Pokitto 0:e8b8f36b4505 1224 //scrptr++;
Pokitto 0:e8b8f36b4505 1225 }
Pokitto 0:e8b8f36b4505 1226 bitmap++;
Pokitto 0:e8b8f36b4505 1227 scrptr++;
Pokitto 0:e8b8f36b4505 1228 }
Pokitto 0:e8b8f36b4505 1229 bitmap += xjump; // needed if x<0 clipping occurs
Pokitto 0:e8b8f36b4505 1230 } else { /** ODD pixel starting line **/
Pokitto 0:e8b8f36b4505 1231 for (scrx = x; scrx < framew+x-xclip; scrx+=2) {
Pokitto 0:e8b8f36b4505 1232 uint8_t sourcepixel = *bitmap;
Pokitto 0:e8b8f36b4505 1233 uint8_t targetpixel = *scrptr;
Pokitto 0:e8b8f36b4505 1234 // store higher nibble of source pixel in lower nibble of target
Pokitto 0:e8b8f36b4505 1235 if((sourcepixel>>4)!=invisiblecolor) targetpixel = (targetpixel & 0xF0) | (sourcepixel >> 4 );
Pokitto 0:e8b8f36b4505 1236 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 1237 scrptr++;
Pokitto 0:e8b8f36b4505 1238 targetpixel = *scrptr;
Pokitto 0:e8b8f36b4505 1239 // store lower nibble of source pixel in higher nibble of target
Pokitto 0:e8b8f36b4505 1240 if((sourcepixel&0x0F)!=invisiblecolor) targetpixel = (targetpixel & 0x0F) | (sourcepixel << 4);
Pokitto 0:e8b8f36b4505 1241 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 1242 bitmap++;
Pokitto 0:e8b8f36b4505 1243 }
Pokitto 0:e8b8f36b4505 1244 bitmap+=xjump;
Pokitto 0:e8b8f36b4505 1245 }
Pokitto 0:e8b8f36b4505 1246 // increment the y jump in the scrptr
Pokitto 0:e8b8f36b4505 1247 scrptr = scrptr + ((width - framew)>>1)+scrxjump;
Pokitto 0:e8b8f36b4505 1248 }
Pokitto 0:e8b8f36b4505 1249 }
Pokitto 0:e8b8f36b4505 1250
Pokitto 0:e8b8f36b4505 1251
Pokitto 0:e8b8f36b4505 1252 void Display::drawBitmap(int16_t x, int16_t y, const uint8_t* bitmap)
Pokitto 0:e8b8f36b4505 1253 {
Pokitto 0:e8b8f36b4505 1254 int16_t w = *bitmap;
Pokitto 0:e8b8f36b4505 1255 int16_t h = *(bitmap + 1);
Pokitto 0:e8b8f36b4505 1256 bitmap = bitmap + 2; //add an offset to the pointer to start after the width and height
Pokitto 0:e8b8f36b4505 1257 /** visibility check */
Pokitto 0:e8b8f36b4505 1258 if (y<-h || y>height) return; //invisible
Pokitto 0:e8b8f36b4505 1259 if (x<-w || x>width) return; //invisible
Pokitto 0:e8b8f36b4505 1260 /** 1 bpp mode */
Pokitto 0:e8b8f36b4505 1261 if (m_colordepth<2) {
Pokitto 0:e8b8f36b4505 1262 int16_t i, j, byteNum, bitNum, byteWidth = (w + 7) >> 3;
Pokitto 0:e8b8f36b4505 1263 for (i = 0; i < w; i++) {
Pokitto 0:e8b8f36b4505 1264 byteNum = i / 8;
Pokitto 0:e8b8f36b4505 1265 bitNum = i % 8;
Pokitto 0:e8b8f36b4505 1266 for (j = 0; j < h; j++) {
Pokitto 0:e8b8f36b4505 1267 uint8_t source = *(bitmap + j * byteWidth + byteNum);
Pokitto 0:e8b8f36b4505 1268 if (source & (0x80 >> bitNum)) {
Pokitto 0:e8b8f36b4505 1269 drawPixel(x + i, y + j);
Pokitto 0:e8b8f36b4505 1270 }
Pokitto 0:e8b8f36b4505 1271 }
Pokitto 0:e8b8f36b4505 1272 }
Pokitto 0:e8b8f36b4505 1273
Pokitto 0:e8b8f36b4505 1274 return;
Pokitto 0:e8b8f36b4505 1275 }
Pokitto 0:e8b8f36b4505 1276 /** 2 bpp mode */
Pokitto 0:e8b8f36b4505 1277 if (m_colordepth<4) {
Pokitto 0:e8b8f36b4505 1278 int16_t i, j, byteNum, bitNum, byteWidth = w >> 2;
Pokitto 0:e8b8f36b4505 1279 for (i = 0; i < w; i++) {
Pokitto 0:e8b8f36b4505 1280 byteNum = i / 4;
Pokitto 0:e8b8f36b4505 1281 bitNum = (i % 4)<<1;
Pokitto 0:e8b8f36b4505 1282 for (j = 0; j < h; j++) {
Pokitto 0:e8b8f36b4505 1283 uint8_t source = *(bitmap + j * byteWidth + byteNum);
Pokitto 0:e8b8f36b4505 1284 uint8_t output = (source & (0xC0 >> bitNum));
Pokitto 0:e8b8f36b4505 1285 output >>= (6-bitNum);
Pokitto 0:e8b8f36b4505 1286 if (output != invisiblecolor) {
Pokitto 0:e8b8f36b4505 1287 setColor(output);
Pokitto 0:e8b8f36b4505 1288 drawPixel(x + i, y + j);
Pokitto 0:e8b8f36b4505 1289 }
Pokitto 0:e8b8f36b4505 1290 }
Pokitto 0:e8b8f36b4505 1291 }
Pokitto 0:e8b8f36b4505 1292
Pokitto 0:e8b8f36b4505 1293 return;
Pokitto 0:e8b8f36b4505 1294 }
Pokitto 0:e8b8f36b4505 1295 /** 4bpp fast version */
Pokitto 0:e8b8f36b4505 1296 int16_t scrx,scry,xclip,xjump,scrxjump;
Pokitto 0:e8b8f36b4505 1297 xclip=xjump=scrxjump=0;
Pokitto 0:e8b8f36b4505 1298 /** y clipping */
Pokitto 0:e8b8f36b4505 1299 if (y<0) { h+=y; bitmap -= y*(w>>1); y=0;}
Pokitto 0:e8b8f36b4505 1300 else if (y+h>height) { h -=(y-height);}
Pokitto 0:e8b8f36b4505 1301 /** x clipping */
Pokitto 0:e8b8f36b4505 1302 if (x<0) { xclip=(x&1)<<1; w+=x; xjump = ((-x)>>1); bitmap += xjump; x=0;}
Pokitto 0:e8b8f36b4505 1303 else if (x+w>width) {
Pokitto 0:e8b8f36b4505 1304 xclip = (x&1)<<1;
Pokitto 0:e8b8f36b4505 1305 scrxjump = x&1;
Pokitto 0:e8b8f36b4505 1306 xjump=((x+w-width)>>1)+scrxjump;
Pokitto 0:e8b8f36b4505 1307 w = width-x;}
Pokitto 0:e8b8f36b4505 1308
Pokitto 0:e8b8f36b4505 1309 uint8_t* scrptr = m_scrbuf + (y*(width>>1) + (x>>1));
Pokitto 0:e8b8f36b4505 1310 /** ONLY 4-bit mode for time being **/
Pokitto 0:e8b8f36b4505 1311 for (scry = y; scry < y+h; scry+=1) {
Pokitto 0:e8b8f36b4505 1312 if (scry>=height) return;
Pokitto 0:e8b8f36b4505 1313 if ((x&1)==0) { /** EVEN pixel starting line, very simple, just copypaste **/
Pokitto 0:e8b8f36b4505 1314 for (scrx = x; scrx < w+x-xclip; scrx+=2) {
Pokitto 0:e8b8f36b4505 1315 uint8_t sourcepixel = *bitmap;
Pokitto 0:e8b8f36b4505 1316 if (xclip) {
Pokitto 0:e8b8f36b4505 1317 sourcepixel <<=4;
Pokitto 0:e8b8f36b4505 1318 sourcepixel |= ((*(bitmap+1))>>4);
Pokitto 0:e8b8f36b4505 1319 }
Pokitto 0:e8b8f36b4505 1320 uint8_t targetpixel = *scrptr;
Pokitto 0:e8b8f36b4505 1321 if ((sourcepixel>>4) != invisiblecolor ) targetpixel = (targetpixel&0x0F) | (sourcepixel & 0xF0);
Pokitto 0:e8b8f36b4505 1322 if ((sourcepixel&0x0F) != invisiblecolor) targetpixel = (targetpixel & 0xF0) | (sourcepixel & 0x0F);
Pokitto 0:e8b8f36b4505 1323 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 1324 bitmap++;
Pokitto 0:e8b8f36b4505 1325 scrptr++;
Pokitto 0:e8b8f36b4505 1326 }
Pokitto 0:e8b8f36b4505 1327 if (xclip){
Pokitto 0:e8b8f36b4505 1328 if (w&1) {
Pokitto 0:e8b8f36b4505 1329 /**last pixel is odd pixel due to clipping & odd width*/
Pokitto 0:e8b8f36b4505 1330 uint8_t sourcepixel = *bitmap;
Pokitto 0:e8b8f36b4505 1331 if ((sourcepixel&0x0F) != invisiblecolor) {
Pokitto 0:e8b8f36b4505 1332 sourcepixel <<=4;
Pokitto 0:e8b8f36b4505 1333 uint8_t targetpixel = *scrptr;// & 0x0F;
Pokitto 0:e8b8f36b4505 1334 targetpixel |= sourcepixel;
Pokitto 0:e8b8f36b4505 1335 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 1336 }
Pokitto 0:e8b8f36b4505 1337 //scrptr++;
Pokitto 0:e8b8f36b4505 1338 }
Pokitto 0:e8b8f36b4505 1339 bitmap++;
Pokitto 0:e8b8f36b4505 1340 scrptr++;
Pokitto 0:e8b8f36b4505 1341 }
Pokitto 0:e8b8f36b4505 1342 bitmap += xjump; // needed if x<0 clipping occurs
Pokitto 0:e8b8f36b4505 1343 } else { /** ODD pixel starting line **/
Pokitto 0:e8b8f36b4505 1344 for (scrx = x; scrx < w+x-xclip; scrx+=2) {
Pokitto 0:e8b8f36b4505 1345 uint8_t sourcepixel = *bitmap;
Pokitto 0:e8b8f36b4505 1346 uint8_t targetpixel = *scrptr;
Pokitto 0:e8b8f36b4505 1347 // store higher nibble of source pixel in lower nibble of target
Pokitto 0:e8b8f36b4505 1348 if((sourcepixel>>4)!=invisiblecolor) targetpixel = (targetpixel & 0xF0) | (sourcepixel >> 4 );
Pokitto 0:e8b8f36b4505 1349 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 1350 scrptr++;
Pokitto 0:e8b8f36b4505 1351 targetpixel = *scrptr;
Pokitto 0:e8b8f36b4505 1352 // store lower nibble of source pixel in higher nibble of target
Pokitto 0:e8b8f36b4505 1353 if((sourcepixel&0x0F)!=invisiblecolor) targetpixel = (targetpixel & 0x0F) | (sourcepixel << 4);
Pokitto 0:e8b8f36b4505 1354 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 1355 bitmap++;
Pokitto 0:e8b8f36b4505 1356 }
Pokitto 0:e8b8f36b4505 1357 bitmap+=xjump;
Pokitto 0:e8b8f36b4505 1358 }
Pokitto 0:e8b8f36b4505 1359 // increment the y jump in the scrptr
Pokitto 0:e8b8f36b4505 1360 scrptr = scrptr + ((width - w)>>1)+scrxjump;
Pokitto 0:e8b8f36b4505 1361 }
Pokitto 0:e8b8f36b4505 1362 }
Pokitto 0:e8b8f36b4505 1363
Pokitto 0:e8b8f36b4505 1364 void Display::drawRleBitmap(int16_t x, int16_t y, const uint8_t* rlebitmap)
Pokitto 0:e8b8f36b4505 1365 {
Pokitto 0:e8b8f36b4505 1366 // ONLY can copy 4-bit bitmap to 4-bit screen mode for time being
Pokitto 0:e8b8f36b4505 1367 #if (POK_SCREENMODE != MODE_FAST_16COLOR)
Pokitto 0:e8b8f36b4505 1368 return;
Pokitto 0:e8b8f36b4505 1369 #endif
Pokitto 0:e8b8f36b4505 1370
Pokitto 0:e8b8f36b4505 1371 int16_t w = *rlebitmap;
Pokitto 0:e8b8f36b4505 1372 int16_t h = *(rlebitmap + 1);
Pokitto 0:e8b8f36b4505 1373 rlebitmap = rlebitmap + 2; //add an offset to the pointer to start after the width and height
Pokitto 0:e8b8f36b4505 1374
Pokitto 0:e8b8f36b4505 1375 // visibility check
Pokitto 0:e8b8f36b4505 1376 if (y<-h || y>height) return; //invisible
Pokitto 0:e8b8f36b4505 1377 if (x<-w || x>width) return; //invisible
Pokitto 0:e8b8f36b4505 1378
Pokitto 0:e8b8f36b4505 1379 // Clipping is not supported
Pokitto 0:e8b8f36b4505 1380 if ((x < 0) || (x+w > width) || (y < 0) || (y+h > height)) return;
Pokitto 0:e8b8f36b4505 1381
Pokitto 0:e8b8f36b4505 1382 // Currently only support RLE bitmaps in 16 color mode.
Pokitto 0:e8b8f36b4505 1383 if (m_colordepth != 4) //
Pokitto 0:e8b8f36b4505 1384 return;
Pokitto 0:e8b8f36b4505 1385
Pokitto 0:e8b8f36b4505 1386 // Go through each line.
Pokitto 0:e8b8f36b4505 1387 uint8_t* scrptr = m_scrbuf + (y*(width>>1) + (x>>1));
Pokitto 0:e8b8f36b4505 1388 bool is_endofbitmap = false;
Pokitto 0:e8b8f36b4505 1389 for (int16_t scry = y; scry < y+h && !is_endofbitmap;) {
Pokitto 0:e8b8f36b4505 1390
Pokitto 0:e8b8f36b4505 1391 // Process one line. Go through each pixel run and escape command in RLE data.
Pokitto 0:e8b8f36b4505 1392 for (int16_t scrx = x;;) {
Pokitto 0:e8b8f36b4505 1393 uint8_t rle_count = *rlebitmap++;
Pokitto 0:e8b8f36b4505 1394
Pokitto 0:e8b8f36b4505 1395 if (rle_count == 0) {
Pokitto 0:e8b8f36b4505 1396
Pokitto 0:e8b8f36b4505 1397 /** Escape or absolute mode */
Pokitto 0:e8b8f36b4505 1398
Pokitto 0:e8b8f36b4505 1399 uint8_t rle_escape_or_runsize = *rlebitmap++;
Pokitto 0:e8b8f36b4505 1400 if ( rle_escape_or_runsize == RLE_ESC_EOL) {
Pokitto 0:e8b8f36b4505 1401 // End of line.
Pokitto 0:e8b8f36b4505 1402 break;
Pokitto 0:e8b8f36b4505 1403 }
Pokitto 0:e8b8f36b4505 1404 else if ( rle_escape_or_runsize == RLE_ESC_EOB) {
Pokitto 0:e8b8f36b4505 1405 // End of bitmap.
Pokitto 0:e8b8f36b4505 1406 is_endofbitmap = true;
Pokitto 0:e8b8f36b4505 1407 break;
Pokitto 0:e8b8f36b4505 1408 }
Pokitto 0:e8b8f36b4505 1409 else if ( rle_escape_or_runsize == RLE_ESC_OFFSET) {
Pokitto 0:e8b8f36b4505 1410 // Move position in target.
Pokitto 0:e8b8f36b4505 1411 // TODO: not tested yet.
Pokitto 0:e8b8f36b4505 1412 uint8_t xoffset = *rlebitmap++;
Pokitto 0:e8b8f36b4505 1413 uint8_t yoffset = *rlebitmap++;
Pokitto 0:e8b8f36b4505 1414 scrptr += (xoffset>1);
Pokitto 0:e8b8f36b4505 1415 scrx += xoffset;
Pokitto 0:e8b8f36b4505 1416 scrptr += yoffset*width;
Pokitto 0:e8b8f36b4505 1417 scry += yoffset;
Pokitto 0:e8b8f36b4505 1418 }
Pokitto 0:e8b8f36b4505 1419 else {
Pokitto 0:e8b8f36b4505 1420
Pokitto 0:e8b8f36b4505 1421 /** Absolute mode. Copy pixels from the source bitmap to the target screen. */
Pokitto 0:e8b8f36b4505 1422
Pokitto 0:e8b8f36b4505 1423 int16_t runsize = rle_escape_or_runsize;
Pokitto 0:e8b8f36b4505 1424 uint8_t targetpixel = *scrptr; // initial value
Pokitto 0:e8b8f36b4505 1425 uint8_t sourcepixel = *rlebitmap; // initial value
Pokitto 0:e8b8f36b4505 1426 for( int16_t runx = 0; runx < runsize; ) {
Pokitto 0:e8b8f36b4505 1427 if (scrx&0x1) { // screen pixel is in the low nibble
Pokitto 0:e8b8f36b4505 1428 if (runx&0x1) { // bitmap pixel is in the low nibble
Pokitto 0:e8b8f36b4505 1429 if ((sourcepixel&0x0F) != invisiblecolor)
Pokitto 0:e8b8f36b4505 1430 targetpixel = (targetpixel&0xF0) | (sourcepixel&0x0F); // Copy low to low nibble.
Pokitto 0:e8b8f36b4505 1431 rlebitmap++;
Pokitto 0:e8b8f36b4505 1432 }
Pokitto 0:e8b8f36b4505 1433 else // bitmap pixel is in the high nibble
Pokitto 0:e8b8f36b4505 1434 if ((sourcepixel>>4) != invisiblecolor)
Pokitto 0:e8b8f36b4505 1435 targetpixel = (targetpixel&0xF0) | (sourcepixel>>4); // Copy high to low nibble.
Pokitto 0:e8b8f36b4505 1436
Pokitto 0:e8b8f36b4505 1437 // Copy the byte to the target.
Pokitto 0:e8b8f36b4505 1438 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 1439 scrptr++;
Pokitto 0:e8b8f36b4505 1440 }
Pokitto 0:e8b8f36b4505 1441 else { // screen pixel is in the high nibble
Pokitto 0:e8b8f36b4505 1442 targetpixel = *scrptr;
Pokitto 0:e8b8f36b4505 1443 sourcepixel = *rlebitmap;
Pokitto 0:e8b8f36b4505 1444 if (runx&0x1) { // bitmap pixel is sourcepixel = *rlebitmapin the low nibble
Pokitto 0:e8b8f36b4505 1445 if ((sourcepixel&0x0F) != invisiblecolor )
Pokitto 0:e8b8f36b4505 1446 targetpixel = (targetpixel&0x0F) | ((sourcepixel<<4)&0xF0); // Copy low to high nibble.
Pokitto 0:e8b8f36b4505 1447 rlebitmap++; // read the new source byte
Pokitto 0:e8b8f36b4505 1448 }
Pokitto 0:e8b8f36b4505 1449 else // bitmap pixel is in the high nibble
Pokitto 0:e8b8f36b4505 1450 if ((sourcepixel>>4) != invisiblecolor )
Pokitto 0:e8b8f36b4505 1451 targetpixel = (targetpixel&0x0F) | (sourcepixel&0xF0); // Copy high to high nibble.
Pokitto 0:e8b8f36b4505 1452 }
Pokitto 0:e8b8f36b4505 1453 runx++;
Pokitto 0:e8b8f36b4505 1454 scrx++;
Pokitto 0:e8b8f36b4505 1455 } // end for
Pokitto 0:e8b8f36b4505 1456
Pokitto 0:e8b8f36b4505 1457 // If this is odd target index, copy the byte to the target.
Pokitto 0:e8b8f36b4505 1458 if (scrx&0x1) {
Pokitto 0:e8b8f36b4505 1459 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 1460 scrptr++;
Pokitto 0:e8b8f36b4505 1461 }
Pokitto 0:e8b8f36b4505 1462
Pokitto 0:e8b8f36b4505 1463 // In absolute mode the source size is always padded to the word boundary.
Pokitto 0:e8b8f36b4505 1464 if (runsize%4) {
Pokitto 0:e8b8f36b4505 1465 int16_t padpixcount = 4 - (runsize%4);
Pokitto 0:e8b8f36b4505 1466 rlebitmap += padpixcount>>1; // skip n padding bytes
Pokitto 0:e8b8f36b4505 1467 }
Pokitto 0:e8b8f36b4505 1468 }
Pokitto 0:e8b8f36b4505 1469 }
Pokitto 0:e8b8f36b4505 1470 else {
Pokitto 0:e8b8f36b4505 1471
Pokitto 0:e8b8f36b4505 1472 /** Encoded mode. Duplicate one pixel pair to the all required pixels on the target screen */
Pokitto 0:e8b8f36b4505 1473
Pokitto 0:e8b8f36b4505 1474 int16_t runsize = rle_count;
Pokitto 0:e8b8f36b4505 1475 uint8_t clonepixelpair = *rlebitmap++;
Pokitto 0:e8b8f36b4505 1476 uint8_t targetpixel = *scrptr; // initial value
Pokitto 0:e8b8f36b4505 1477 for( int16_t runx = 0; runx < runsize; ) {
Pokitto 0:e8b8f36b4505 1478 if (scrx&0x1) { // screen pixel is in the low nibble
Pokitto 0:e8b8f36b4505 1479 if (runx&0x1) { // bitmap pixel is in the low nibble
Pokitto 0:e8b8f36b4505 1480 if ((clonepixelpair&0x0F) != invisiblecolor)
Pokitto 0:e8b8f36b4505 1481 targetpixel = (targetpixel&0xF0) | (clonepixelpair&0x0F); // Copy low to low nibble.
Pokitto 0:e8b8f36b4505 1482 }
Pokitto 0:e8b8f36b4505 1483 else // bitmap pixel is in the high nibble
Pokitto 0:e8b8f36b4505 1484 if ((clonepixelpair>>4) != invisiblecolor)
Pokitto 0:e8b8f36b4505 1485 targetpixel = (targetpixel&0xF0) | (clonepixelpair>>4); // Copy high to low nibble.
Pokitto 0:e8b8f36b4505 1486
Pokitto 0:e8b8f36b4505 1487 // Copy the byte to the target.
Pokitto 0:e8b8f36b4505 1488 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 1489 scrptr++;
Pokitto 0:e8b8f36b4505 1490 }
Pokitto 0:e8b8f36b4505 1491 else { // screen pixel is in the high nibble
Pokitto 0:e8b8f36b4505 1492 targetpixel = *scrptr;
Pokitto 0:e8b8f36b4505 1493 if (runx&0x1) {// bitmap pixel is in the low nibble
Pokitto 0:e8b8f36b4505 1494 if ((clonepixelpair&0x0F) != invisiblecolor )
Pokitto 0:e8b8f36b4505 1495 targetpixel = (targetpixel&0x0F) | ((clonepixelpair<<4)&0xF0); // Copy low to high nibble.
Pokitto 0:e8b8f36b4505 1496 }
Pokitto 0:e8b8f36b4505 1497 else // bitmap pixel is in the high nibble
Pokitto 0:e8b8f36b4505 1498 if ((clonepixelpair>>4) != invisiblecolor )
Pokitto 0:e8b8f36b4505 1499 targetpixel = (targetpixel&0x0F) | (clonepixelpair&0xF0); // Copy high to high nibble.
Pokitto 0:e8b8f36b4505 1500 }
Pokitto 0:e8b8f36b4505 1501 runx++;
Pokitto 0:e8b8f36b4505 1502 scrx++;
Pokitto 0:e8b8f36b4505 1503
Pokitto 0:e8b8f36b4505 1504 } // end for
Pokitto 0:e8b8f36b4505 1505
Pokitto 0:e8b8f36b4505 1506 // If this is odd target index, copy the byte to the target.
Pokitto 0:e8b8f36b4505 1507 if (scrx&0x1) {
Pokitto 0:e8b8f36b4505 1508 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 1509 scrptr++;
Pokitto 0:e8b8f36b4505 1510 }
Pokitto 0:e8b8f36b4505 1511 } // end if
Pokitto 0:e8b8f36b4505 1512 } // end while
Pokitto 0:e8b8f36b4505 1513
Pokitto 0:e8b8f36b4505 1514 // Increment the target screen pointer and index.
Pokitto 0:e8b8f36b4505 1515 scrptr = scrptr + ((width - w)>>1);
Pokitto 0:e8b8f36b4505 1516 scry++;
Pokitto 0:e8b8f36b4505 1517 } // end for scry
Pokitto 0:e8b8f36b4505 1518 }
Pokitto 0:e8b8f36b4505 1519
Pokitto 0:e8b8f36b4505 1520 void Display::drawBitmapXFlipped(int16_t x, int16_t y, const uint8_t* bitmap)
Pokitto 0:e8b8f36b4505 1521 {
Pokitto 0:e8b8f36b4505 1522 int16_t w = *bitmap;
Pokitto 0:e8b8f36b4505 1523 int16_t h = *(bitmap + 1);
Pokitto 0:e8b8f36b4505 1524 bitmap = bitmap + 2; //add an offset to the pointer to start after the width and height
Pokitto 0:e8b8f36b4505 1525 /** visibility check */
Pokitto 0:e8b8f36b4505 1526 if (y<-h || y>height) return; //invisible
Pokitto 0:e8b8f36b4505 1527 if (x<-w || x>width) return; //invisible
Pokitto 0:e8b8f36b4505 1528 /** 1 bpp mode */
Pokitto 0:e8b8f36b4505 1529 if (m_colordepth<2) {
Pokitto 0:e8b8f36b4505 1530 int16_t i, j, byteNum, bitNum, byteWidth = (w + 7) >> 3;
Pokitto 0:e8b8f36b4505 1531 for (i = 0; i < w; i++) {
Pokitto 0:e8b8f36b4505 1532 byteNum = i / 8;
Pokitto 0:e8b8f36b4505 1533 bitNum = i % 8;
Pokitto 0:e8b8f36b4505 1534 for (j = 0; j < h; j++) {
Pokitto 0:e8b8f36b4505 1535 uint8_t source = *(bitmap + j * byteWidth + byteNum);
Pokitto 0:e8b8f36b4505 1536 if (source & (0x80 >> bitNum)) {
Pokitto 0:e8b8f36b4505 1537 drawPixel(x + w - i, y + j);
Pokitto 0:e8b8f36b4505 1538 }
Pokitto 0:e8b8f36b4505 1539 }
Pokitto 0:e8b8f36b4505 1540 }
Pokitto 0:e8b8f36b4505 1541
Pokitto 0:e8b8f36b4505 1542 return;
Pokitto 0:e8b8f36b4505 1543 }
Pokitto 0:e8b8f36b4505 1544 /** 2 bpp mode */
Pokitto 0:e8b8f36b4505 1545 if (m_colordepth<4) {
Pokitto 0:e8b8f36b4505 1546 int16_t i, j, byteNum, bitNum, byteWidth = w >> 2;
Pokitto 0:e8b8f36b4505 1547 for (i = 0; i < w; i++) {
Pokitto 0:e8b8f36b4505 1548 byteNum = i / 4;
Pokitto 0:e8b8f36b4505 1549 bitNum = (i % 4)<<1;
Pokitto 0:e8b8f36b4505 1550 for (j = 0; j < h; j++) {
Pokitto 0:e8b8f36b4505 1551 uint8_t source = *(bitmap + j * byteWidth + byteNum);
Pokitto 0:e8b8f36b4505 1552 uint8_t output = (source & (0xC0 >> bitNum));
Pokitto 0:e8b8f36b4505 1553 output >>= (6-bitNum);
Pokitto 0:e8b8f36b4505 1554 if (output != invisiblecolor) {
Pokitto 0:e8b8f36b4505 1555 setColor(output);
Pokitto 0:e8b8f36b4505 1556 drawPixel(x + i, y + j);
Pokitto 0:e8b8f36b4505 1557 }
Pokitto 0:e8b8f36b4505 1558 }
Pokitto 0:e8b8f36b4505 1559 }
Pokitto 0:e8b8f36b4505 1560
Pokitto 0:e8b8f36b4505 1561 return;
Pokitto 0:e8b8f36b4505 1562 }
Pokitto 0:e8b8f36b4505 1563 /** 4bpp fast version */
Pokitto 0:e8b8f36b4505 1564 int16_t scrx,scry,xclip,xjump,scrxjump;
Pokitto 0:e8b8f36b4505 1565 xclip=xjump=scrxjump=0;
Pokitto 0:e8b8f36b4505 1566 /** y clipping */
Pokitto 0:e8b8f36b4505 1567 if (y<0) { h+=y; bitmap -= y*(w>>1); y=0;}
Pokitto 0:e8b8f36b4505 1568 else if (y+h>height) { h -=(y-height);}
Pokitto 0:e8b8f36b4505 1569 /** x clipping */
Pokitto 0:e8b8f36b4505 1570 bitmap += ((w>>1)-1); //inverted!
Pokitto 0:e8b8f36b4505 1571 if (x<0) {
Pokitto 0:e8b8f36b4505 1572 xclip=(x&1)<<1;
Pokitto 0:e8b8f36b4505 1573 w+=x;
Pokitto 0:e8b8f36b4505 1574 xjump = ((-x)>>1);
Pokitto 0:e8b8f36b4505 1575 //bitmap += xjump; // do not clip left edge of source, as bitmap is inverted !
Pokitto 0:e8b8f36b4505 1576 x=0;
Pokitto 0:e8b8f36b4505 1577 }
Pokitto 0:e8b8f36b4505 1578 else if (x+w>width) {
Pokitto 0:e8b8f36b4505 1579 xclip = (x&1)<<1;
Pokitto 0:e8b8f36b4505 1580 scrxjump = x&1;
Pokitto 0:e8b8f36b4505 1581 xjump=((x+w-width)>>1)+scrxjump;
Pokitto 0:e8b8f36b4505 1582 w = width-x;}
Pokitto 0:e8b8f36b4505 1583
Pokitto 0:e8b8f36b4505 1584 //uint8_t* scrptr = m_scrbuf + (y*(width>>1) + ((x+width)>>1));
Pokitto 0:e8b8f36b4505 1585 uint8_t* scrptr = m_scrbuf + (y*(width>>1) + (x>>1));
Pokitto 0:e8b8f36b4505 1586 /** ONLY 4-bit mode for time being **/
Pokitto 0:e8b8f36b4505 1587 for (scry = y; scry < y+h; scry+=1) {
Pokitto 0:e8b8f36b4505 1588 // for (scry = y; scry < y+2; scry+=1) {
Pokitto 0:e8b8f36b4505 1589 if (scry>=height) return;
Pokitto 0:e8b8f36b4505 1590 if ((x&1)==0) { /** EVEN pixel starting line, very simple, just copypaste **/
Pokitto 0:e8b8f36b4505 1591 //for (scrx = w+x-xclip-1; scrx >= x; scrx-=2) {
Pokitto 0:e8b8f36b4505 1592 for (scrx = x; scrx < w+x-xclip; scrx+=2) {
Pokitto 0:e8b8f36b4505 1593 uint8_t sourcepixel = *(bitmap);
Pokitto 0:e8b8f36b4505 1594 if (xclip) {
Pokitto 0:e8b8f36b4505 1595 sourcepixel <<=4;
Pokitto 0:e8b8f36b4505 1596 sourcepixel |= ((*(bitmap-1))>>4);//inverted!
Pokitto 0:e8b8f36b4505 1597 }
Pokitto 0:e8b8f36b4505 1598 uint8_t targetpixel = *scrptr;
Pokitto 0:e8b8f36b4505 1599 // NIBBLES ARE INVERTED BECAUSE PICTURE IS FLIPPED !!!
Pokitto 0:e8b8f36b4505 1600 if ((sourcepixel>>4) != invisiblecolor ) targetpixel = (targetpixel&0xF0) | (sourcepixel>>4);
Pokitto 0:e8b8f36b4505 1601 if ((sourcepixel&0x0F) != invisiblecolor) targetpixel = (targetpixel & 0x0F) | (sourcepixel<<4);
Pokitto 0:e8b8f36b4505 1602 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 1603 bitmap--;
Pokitto 0:e8b8f36b4505 1604 scrptr++;
Pokitto 0:e8b8f36b4505 1605 }
Pokitto 0:e8b8f36b4505 1606 bitmap += w; // w*2 >> 1 because inverted and because 2 pixels per byte!!
Pokitto 0:e8b8f36b4505 1607 if (xclip){
Pokitto 0:e8b8f36b4505 1608 if (w&1) {
Pokitto 0:e8b8f36b4505 1609 /**last pixel is odd pixel due to clipping & odd width*/
Pokitto 0:e8b8f36b4505 1610 uint8_t sourcepixel = *bitmap;
Pokitto 0:e8b8f36b4505 1611 if ((sourcepixel&0x0F) != invisiblecolor) {
Pokitto 0:e8b8f36b4505 1612 sourcepixel <<=4;
Pokitto 0:e8b8f36b4505 1613 uint8_t targetpixel = *scrptr;// & 0x0F;
Pokitto 0:e8b8f36b4505 1614 targetpixel |= sourcepixel;
Pokitto 0:e8b8f36b4505 1615 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 1616 }
Pokitto 0:e8b8f36b4505 1617 //scrptr++;
Pokitto 0:e8b8f36b4505 1618 }
Pokitto 0:e8b8f36b4505 1619 bitmap++;
Pokitto 0:e8b8f36b4505 1620 scrptr++;
Pokitto 0:e8b8f36b4505 1621 }
Pokitto 0:e8b8f36b4505 1622 bitmap += xjump; // needed if x<0 clipping occurs
Pokitto 0:e8b8f36b4505 1623 } else { /** ODD pixel starting line **/
Pokitto 0:e8b8f36b4505 1624 for (scrx = x; scrx < w+x-xclip; scrx+=2 ) {
Pokitto 0:e8b8f36b4505 1625 uint8_t sourcepixel = *bitmap;
Pokitto 0:e8b8f36b4505 1626 uint8_t targetpixel = *scrptr;
Pokitto 0:e8b8f36b4505 1627 // inverted !!! store lower nibble of source pixel in lower nibble of target
Pokitto 0:e8b8f36b4505 1628 if((sourcepixel&0x0F)!=invisiblecolor) targetpixel = (targetpixel & 0xF0) | (sourcepixel & 0x0F );
Pokitto 0:e8b8f36b4505 1629 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 1630 scrptr++;
Pokitto 0:e8b8f36b4505 1631 targetpixel = *scrptr;
Pokitto 0:e8b8f36b4505 1632 // inverted ! store higher nibble of source pixel in higher nibble of target
Pokitto 0:e8b8f36b4505 1633 if((sourcepixel>>4)!=invisiblecolor) targetpixel = (targetpixel & 0x0F) | (sourcepixel & 0xF0);
Pokitto 0:e8b8f36b4505 1634 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 1635 bitmap--;
Pokitto 0:e8b8f36b4505 1636 }
Pokitto 0:e8b8f36b4505 1637 bitmap += w; // w*2 >> 1 because inverted and because 2 pixels per byte!!
Pokitto 0:e8b8f36b4505 1638 bitmap+=xjump;
Pokitto 0:e8b8f36b4505 1639 }
Pokitto 0:e8b8f36b4505 1640 // increment the y jump in the scrptr
Pokitto 0:e8b8f36b4505 1641 scrptr = scrptr + ((width - w)>>1)+scrxjump;
Pokitto 0:e8b8f36b4505 1642 }
Pokitto 0:e8b8f36b4505 1643 }
Pokitto 0:e8b8f36b4505 1644
Pokitto 0:e8b8f36b4505 1645 void Display::drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, uint8_t rotation, uint8_t flip) {
Pokitto 0:e8b8f36b4505 1646 #if PROJ_GAMEBUINO == 0
Pokitto 0:e8b8f36b4505 1647 if (!flip) drawBitmap(x,y,bitmap);
Pokitto 0:e8b8f36b4505 1648 else drawBitmapXFlipped(x,y,bitmap);
Pokitto 0:e8b8f36b4505 1649 #else
Pokitto 0:e8b8f36b4505 1650 if((rotation == NOROT) && (flip == NOFLIP)){
Pokitto 0:e8b8f36b4505 1651 drawBitmap(x,y,bitmap); //use the faster algorithm
Pokitto 0:e8b8f36b4505 1652 return;
Pokitto 0:e8b8f36b4505 1653 }
Pokitto 0:e8b8f36b4505 1654 uint8_t w = bitmap[0];
Pokitto 0:e8b8f36b4505 1655 uint8_t h = bitmap[1];
Pokitto 0:e8b8f36b4505 1656 bitmap = bitmap + 2; //add an offset to the pointer to start after the width and height
Pokitto 0:e8b8f36b4505 1657 int8_t i, j, //coordinates in the raw bitmap
Pokitto 0:e8b8f36b4505 1658 k, l, //coordinates in the rotated/flipped bitmap
Pokitto 0:e8b8f36b4505 1659 byteNum, bitNum, byteWidth = (w + 7) >> 3;
Pokitto 0:e8b8f36b4505 1660
Pokitto 0:e8b8f36b4505 1661 rotation %= 4;
Pokitto 0:e8b8f36b4505 1662
Pokitto 0:e8b8f36b4505 1663 for (i = 0; i < w; i++) {
Pokitto 0:e8b8f36b4505 1664 byteNum = i / 8;
Pokitto 0:e8b8f36b4505 1665 bitNum = i % 8;
Pokitto 0:e8b8f36b4505 1666 for (j = 0; j < h; j++) {
Pokitto 0:e8b8f36b4505 1667 if (bitmap[j * byteWidth + byteNum] & (B10000000 >> bitNum)) {
Pokitto 0:e8b8f36b4505 1668 switch (rotation) {
Pokitto 0:e8b8f36b4505 1669 case NOROT: //no rotation
Pokitto 0:e8b8f36b4505 1670 k = i;
Pokitto 0:e8b8f36b4505 1671 l = j;
Pokitto 0:e8b8f36b4505 1672 break;
Pokitto 2:968589ca3484 1673 case ROTCCW: //90� counter-clockwise
Pokitto 0:e8b8f36b4505 1674 k = j;
Pokitto 0:e8b8f36b4505 1675 l = w - i - 1;
Pokitto 0:e8b8f36b4505 1676 break;
Pokitto 2:968589ca3484 1677 case ROT180: //180�
Pokitto 0:e8b8f36b4505 1678 k = w - i - 1;
Pokitto 0:e8b8f36b4505 1679 l = h - j - 1;
Pokitto 0:e8b8f36b4505 1680 break;
Pokitto 2:968589ca3484 1681 case ROTCW: //90� clockwise
Pokitto 0:e8b8f36b4505 1682 k = h - j - 1;
Pokitto 0:e8b8f36b4505 1683 l = i;
Pokitto 0:e8b8f36b4505 1684 break;
Pokitto 0:e8b8f36b4505 1685 }
Pokitto 0:e8b8f36b4505 1686 if (flip) {
Pokitto 0:e8b8f36b4505 1687 flip %= 4;
Pokitto 0:e8b8f36b4505 1688 if (flip & B00000001) { //horizontal flip
Pokitto 0:e8b8f36b4505 1689 k = w - k;
Pokitto 0:e8b8f36b4505 1690 }
Pokitto 0:e8b8f36b4505 1691 if (flip & B00000010) { //vertical flip
Pokitto 0:e8b8f36b4505 1692 l = h - l;
Pokitto 0:e8b8f36b4505 1693 }
Pokitto 0:e8b8f36b4505 1694 }
Pokitto 0:e8b8f36b4505 1695 k += x; //place the bitmap on the screen
Pokitto 0:e8b8f36b4505 1696 l += y;
Pokitto 0:e8b8f36b4505 1697 drawPixel(k, l);
Pokitto 0:e8b8f36b4505 1698 }
Pokitto 0:e8b8f36b4505 1699 }
Pokitto 0:e8b8f36b4505 1700 }
Pokitto 0:e8b8f36b4505 1701 #endif //PROJ_GAMEBUINO
Pokitto 0:e8b8f36b4505 1702
Pokitto 0:e8b8f36b4505 1703 }
Pokitto 0:e8b8f36b4505 1704
Pokitto 0:e8b8f36b4505 1705 uint8_t* Display::getBuffer() {
Pokitto 0:e8b8f36b4505 1706 return m_scrbuf;
Pokitto 0:e8b8f36b4505 1707 }
Pokitto 0:e8b8f36b4505 1708
Pokitto 0:e8b8f36b4505 1709 uint8_t Display::getBitmapPixel(const uint8_t* bitmap, uint16_t x, uint16_t y) {
Pokitto 0:e8b8f36b4505 1710 uint16_t w = *bitmap;
Pokitto 0:e8b8f36b4505 1711 uint8_t sourcebyte = bitmap[2+(y * ((w+7)>>3))+ (x>>3)];
Pokitto 0:e8b8f36b4505 1712 return sourcebyte & (0x80>>(x&7));
Pokitto 0:e8b8f36b4505 1713 }
Pokitto 0:e8b8f36b4505 1714
Pokitto 0:e8b8f36b4505 1715 int Display::print_char(uint8_t x, uint8_t y, unsigned char c) {
Pokitto 0:e8b8f36b4505 1716 c -= font[2];
Pokitto 0:e8b8f36b4505 1717 if (m_mode) return directChar(x,y,c);
Pokitto 0:e8b8f36b4505 1718 return bufferChar(x,y,c);
Pokitto 0:e8b8f36b4505 1719 }
Pokitto 0:e8b8f36b4505 1720
Pokitto 0:e8b8f36b4505 1721 void Display::drawChar(int8_t x, int8_t y, unsigned char c, uint8_t size) {
Pokitto 0:e8b8f36b4505 1722 print_char(x,y,c);
Pokitto 0:e8b8f36b4505 1723 return;
Pokitto 0:e8b8f36b4505 1724 }
Pokitto 0:e8b8f36b4505 1725
Pokitto 0:e8b8f36b4505 1726
Pokitto 0:e8b8f36b4505 1727 bool Display::isDirectPrintingEnabled() {
Pokitto 0:e8b8f36b4505 1728 return m_mode;
Pokitto 0:e8b8f36b4505 1729 }
Pokitto 0:e8b8f36b4505 1730
Pokitto 0:e8b8f36b4505 1731 void Display::enableDirectPrinting(uint8_t m) {
Pokitto 0:e8b8f36b4505 1732 if (m) {
Pokitto 0:e8b8f36b4505 1733 m_mode=true;
Pokitto 0:e8b8f36b4505 1734 m_w = POK_LCD_W;
Pokitto 0:e8b8f36b4505 1735 m_h = POK_LCD_H;
Pokitto 0:e8b8f36b4505 1736 } else {
Pokitto 0:e8b8f36b4505 1737 m_mode=false;
Pokitto 0:e8b8f36b4505 1738 m_w = getWidth();
Pokitto 0:e8b8f36b4505 1739 m_h = getHeight();
Pokitto 0:e8b8f36b4505 1740 }
Pokitto 0:e8b8f36b4505 1741 }
Pokitto 0:e8b8f36b4505 1742
Pokitto 0:e8b8f36b4505 1743 void Display::write(uint8_t c) {
Pokitto 0:e8b8f36b4505 1744 int charstep=0;
Pokitto 0:e8b8f36b4505 1745 if(font[3]) {
Pokitto 0:e8b8f36b4505 1746 // only caps in this font
Pokitto 0:e8b8f36b4505 1747 if (c>=97) c-=32;
Pokitto 0:e8b8f36b4505 1748 }
Pokitto 0:e8b8f36b4505 1749 switch(c) {
Pokitto 0:e8b8f36b4505 1750 case '\0': //null
Pokitto 0:e8b8f36b4505 1751 break;
Pokitto 0:e8b8f36b4505 1752 case '\n': //line feed
Pokitto 0:e8b8f36b4505 1753 cursorX = 0;
Pokitto 0:e8b8f36b4505 1754 inc_txtline();
Pokitto 0:e8b8f36b4505 1755 break;
Pokitto 0:e8b8f36b4505 1756 case 8: //backspace
Pokitto 0:e8b8f36b4505 1757 cursorX -= font[0];
Pokitto 0:e8b8f36b4505 1758 charstep=print_char(cursorX,cursorY,' ');
Pokitto 0:e8b8f36b4505 1759 break;
Pokitto 2:968589ca3484 1760 case 13: //carriage return
Pokitto 0:e8b8f36b4505 1761 cursorX = 0;
Pokitto 0:e8b8f36b4505 1762 break;
Pokitto 0:e8b8f36b4505 1763 case 14: //form feed new page(clear screen)
Pokitto 0:e8b8f36b4505 1764 //clear_screen();
Pokitto 0:e8b8f36b4505 1765 break;
Pokitto 0:e8b8f36b4505 1766 default:
Pokitto 0:e8b8f36b4505 1767 if (cursorX >= (m_w - font[0])) {
Pokitto 0:e8b8f36b4505 1768 cursorX = 0;
Pokitto 0:e8b8f36b4505 1769 if (textWrap) inc_txtline();
Pokitto 0:e8b8f36b4505 1770 else return; // stop outputting text
Pokitto 0:e8b8f36b4505 1771 charstep=print_char(cursorX,cursorY,c);
Pokitto 0:e8b8f36b4505 1772 }
Pokitto 0:e8b8f36b4505 1773 else
Pokitto 0:e8b8f36b4505 1774 charstep=print_char(cursorX,cursorY,c);
Pokitto 0:e8b8f36b4505 1775 if (c==' ' && adjustCharStep) charstep=(charstep>>1)+1;
Pokitto 0:e8b8f36b4505 1776 cursorX += charstep;
Pokitto 0:e8b8f36b4505 1777 }
Pokitto 0:e8b8f36b4505 1778 }
Pokitto 0:e8b8f36b4505 1779
Pokitto 0:e8b8f36b4505 1780 void Display::inc_txtline() {
Pokitto 0:e8b8f36b4505 1781 if (cursorY > m_h - 2*font[1]) //= (height - (font[1]+1)))
Pokitto 0:e8b8f36b4505 1782 #if SCROLL_TEXT > 0
Pokitto 0:e8b8f36b4505 1783 scroll(font[1] + adjustLineStep);
Pokitto 0:e8b8f36b4505 1784 #else
Pokitto 0:e8b8f36b4505 1785 cursorY = 0;
Pokitto 0:e8b8f36b4505 1786 #endif
Pokitto 0:e8b8f36b4505 1787 else
Pokitto 0:e8b8f36b4505 1788 cursorY += font[1] + adjustLineStep;
Pokitto 0:e8b8f36b4505 1789 }
Pokitto 0:e8b8f36b4505 1790
Pokitto 0:e8b8f36b4505 1791 /* default implementation: may be overridden */
Pokitto 0:e8b8f36b4505 1792 void Display::write(const char *str)
Pokitto 0:e8b8f36b4505 1793 {
Pokitto 0:e8b8f36b4505 1794 while (*str)
Pokitto 0:e8b8f36b4505 1795 write(*str++);
Pokitto 0:e8b8f36b4505 1796 }
Pokitto 0:e8b8f36b4505 1797
Pokitto 0:e8b8f36b4505 1798 /* default implementation: may be overridden */
Pokitto 0:e8b8f36b4505 1799 void Display::write(const uint8_t *buffer, uint8_t size)
Pokitto 0:e8b8f36b4505 1800 {
Pokitto 0:e8b8f36b4505 1801 while (size--)
Pokitto 0:e8b8f36b4505 1802 write(*buffer++);
Pokitto 0:e8b8f36b4505 1803 }
Pokitto 0:e8b8f36b4505 1804
Pokitto 0:e8b8f36b4505 1805 void Display::print(const char str[])
Pokitto 0:e8b8f36b4505 1806 {
Pokitto 0:e8b8f36b4505 1807 write(str);
Pokitto 0:e8b8f36b4505 1808 }
Pokitto 0:e8b8f36b4505 1809
Pokitto 0:e8b8f36b4505 1810 void Display::print(char c, int base)
Pokitto 0:e8b8f36b4505 1811 {
Pokitto 0:e8b8f36b4505 1812 print((long) c, base);
Pokitto 0:e8b8f36b4505 1813 }
Pokitto 0:e8b8f36b4505 1814
Pokitto 0:e8b8f36b4505 1815 void Display::print(unsigned char b, int base)
Pokitto 0:e8b8f36b4505 1816 {
Pokitto 0:e8b8f36b4505 1817 print((unsigned long) b, base);
Pokitto 0:e8b8f36b4505 1818 }
Pokitto 0:e8b8f36b4505 1819
Pokitto 0:e8b8f36b4505 1820 void Display::print(int n, int base)
Pokitto 0:e8b8f36b4505 1821 {
Pokitto 0:e8b8f36b4505 1822 print((long) n, base);
Pokitto 0:e8b8f36b4505 1823 }
Pokitto 0:e8b8f36b4505 1824
Pokitto 0:e8b8f36b4505 1825 void Display::print(unsigned int n, int base)
Pokitto 0:e8b8f36b4505 1826 {
Pokitto 0:e8b8f36b4505 1827 print((unsigned long) n, base);
Pokitto 0:e8b8f36b4505 1828 }
Pokitto 0:e8b8f36b4505 1829
Pokitto 0:e8b8f36b4505 1830 void Display::print(long n, int base)
Pokitto 0:e8b8f36b4505 1831 {
Pokitto 0:e8b8f36b4505 1832 if (base == 0) {
Pokitto 0:e8b8f36b4505 1833 write(n);
Pokitto 0:e8b8f36b4505 1834 } else if (base == 10) {
Pokitto 0:e8b8f36b4505 1835 if (n < 0) {
Pokitto 0:e8b8f36b4505 1836 print('-');
Pokitto 0:e8b8f36b4505 1837 n = -n;
Pokitto 0:e8b8f36b4505 1838 }
Pokitto 0:e8b8f36b4505 1839 printNumber(n, 10);
Pokitto 0:e8b8f36b4505 1840 } else {
Pokitto 0:e8b8f36b4505 1841 printNumber(n, base);
Pokitto 0:e8b8f36b4505 1842 }
Pokitto 0:e8b8f36b4505 1843 }
Pokitto 0:e8b8f36b4505 1844
Pokitto 0:e8b8f36b4505 1845 void Display::print(unsigned long n, int base)
Pokitto 0:e8b8f36b4505 1846 {
Pokitto 0:e8b8f36b4505 1847 if (base == 0) write(n);
Pokitto 0:e8b8f36b4505 1848 else printNumber(n, base);
Pokitto 0:e8b8f36b4505 1849 }
Pokitto 0:e8b8f36b4505 1850
Pokitto 0:e8b8f36b4505 1851 void Display::print(double n, int digits)
Pokitto 0:e8b8f36b4505 1852 {
Pokitto 0:e8b8f36b4505 1853 printFloat(n, digits);
Pokitto 0:e8b8f36b4505 1854 }
Pokitto 0:e8b8f36b4505 1855
Pokitto 0:e8b8f36b4505 1856 void Display::println(void)
Pokitto 0:e8b8f36b4505 1857 {
Pokitto 0:e8b8f36b4505 1858 print('\r');
Pokitto 0:e8b8f36b4505 1859 print('\n');
Pokitto 0:e8b8f36b4505 1860 }
Pokitto 0:e8b8f36b4505 1861
Pokitto 0:e8b8f36b4505 1862 void Display::println(const char c[])
Pokitto 0:e8b8f36b4505 1863 {
Pokitto 0:e8b8f36b4505 1864 print(c);
Pokitto 0:e8b8f36b4505 1865 println();
Pokitto 0:e8b8f36b4505 1866 }
Pokitto 0:e8b8f36b4505 1867
Pokitto 0:e8b8f36b4505 1868 void Display::println(char c, int base)
Pokitto 0:e8b8f36b4505 1869 {
Pokitto 0:e8b8f36b4505 1870 print(c, base);
Pokitto 0:e8b8f36b4505 1871 println();
Pokitto 0:e8b8f36b4505 1872 }
Pokitto 0:e8b8f36b4505 1873
Pokitto 0:e8b8f36b4505 1874 void Display::println(unsigned char b, int base)
Pokitto 0:e8b8f36b4505 1875 {
Pokitto 0:e8b8f36b4505 1876 print(b, base);
Pokitto 0:e8b8f36b4505 1877 println();
Pokitto 0:e8b8f36b4505 1878 }
Pokitto 0:e8b8f36b4505 1879
Pokitto 0:e8b8f36b4505 1880 void Display::println(int n, int base)
Pokitto 0:e8b8f36b4505 1881 {
Pokitto 0:e8b8f36b4505 1882 print(n, base);
Pokitto 0:e8b8f36b4505 1883 println();
Pokitto 0:e8b8f36b4505 1884 }
Pokitto 0:e8b8f36b4505 1885
Pokitto 0:e8b8f36b4505 1886 void Display::println(unsigned int n, int base)
Pokitto 0:e8b8f36b4505 1887 {
Pokitto 0:e8b8f36b4505 1888 print(n, base);
Pokitto 0:e8b8f36b4505 1889 println();
Pokitto 0:e8b8f36b4505 1890 }
Pokitto 0:e8b8f36b4505 1891
Pokitto 0:e8b8f36b4505 1892 void Display::println(long n, int base)
Pokitto 0:e8b8f36b4505 1893 {
Pokitto 0:e8b8f36b4505 1894 print(n, base);
Pokitto 0:e8b8f36b4505 1895 println();
Pokitto 0:e8b8f36b4505 1896 }
Pokitto 0:e8b8f36b4505 1897
Pokitto 0:e8b8f36b4505 1898 void Display::println(unsigned long n, int base)
Pokitto 0:e8b8f36b4505 1899 {
Pokitto 0:e8b8f36b4505 1900 print(n, base);
Pokitto 0:e8b8f36b4505 1901 println();
Pokitto 0:e8b8f36b4505 1902 }
Pokitto 0:e8b8f36b4505 1903
Pokitto 0:e8b8f36b4505 1904 void Display::println(double n, int digits)
Pokitto 0:e8b8f36b4505 1905 {
Pokitto 0:e8b8f36b4505 1906 print(n, digits);
Pokitto 0:e8b8f36b4505 1907 println();
Pokitto 0:e8b8f36b4505 1908 }
Pokitto 0:e8b8f36b4505 1909
Pokitto 0:e8b8f36b4505 1910 void Display::set_cursor(uint8_t x, uint8_t y) {
Pokitto 0:e8b8f36b4505 1911 cursorX = x;
Pokitto 0:e8b8f36b4505 1912 cursorY = y;
Pokitto 0:e8b8f36b4505 1913 }
Pokitto 0:e8b8f36b4505 1914
Pokitto 0:e8b8f36b4505 1915 void Display::print(uint8_t x, uint8_t y, const char str[]) {
Pokitto 0:e8b8f36b4505 1916 cursorX = x;
Pokitto 0:e8b8f36b4505 1917 cursorY = y;
Pokitto 0:e8b8f36b4505 1918 write(str);
Pokitto 0:e8b8f36b4505 1919
Pokitto 0:e8b8f36b4505 1920 }
Pokitto 0:e8b8f36b4505 1921 void Display::print(uint8_t x, uint8_t y, char c, int base) {
Pokitto 0:e8b8f36b4505 1922 cursorX = x;
Pokitto 0:e8b8f36b4505 1923 cursorY = y;
Pokitto 0:e8b8f36b4505 1924 print((long) c, base);
Pokitto 0:e8b8f36b4505 1925 }
Pokitto 0:e8b8f36b4505 1926 void Display::print(uint8_t x, uint8_t y, unsigned char b, int base) {
Pokitto 0:e8b8f36b4505 1927 cursorX = x;
Pokitto 0:e8b8f36b4505 1928 cursorY = y;
Pokitto 0:e8b8f36b4505 1929 print((unsigned long) b, base);
Pokitto 0:e8b8f36b4505 1930 }
Pokitto 0:e8b8f36b4505 1931 void Display::print(uint8_t x, uint8_t y, int n, int base) {
Pokitto 0:e8b8f36b4505 1932 cursorX = x;
Pokitto 0:e8b8f36b4505 1933 cursorY = y;
Pokitto 0:e8b8f36b4505 1934 print((long) n, base);
Pokitto 0:e8b8f36b4505 1935 }
Pokitto 0:e8b8f36b4505 1936 void Display::print(uint8_t x, uint8_t y, unsigned int n, int base) {
Pokitto 0:e8b8f36b4505 1937 cursorX = x;
Pokitto 0:e8b8f36b4505 1938 cursorY = y;
Pokitto 0:e8b8f36b4505 1939 print((unsigned long) n, base);
Pokitto 0:e8b8f36b4505 1940 }
Pokitto 0:e8b8f36b4505 1941 void Display::print(uint8_t x, uint8_t y, long n, int base) {
Pokitto 0:e8b8f36b4505 1942 cursorX = x;
Pokitto 0:e8b8f36b4505 1943 cursorY = y;
Pokitto 0:e8b8f36b4505 1944 print(n,base);
Pokitto 0:e8b8f36b4505 1945 }
Pokitto 0:e8b8f36b4505 1946 void Display::print(uint8_t x, uint8_t y, unsigned long n, int base) {
Pokitto 0:e8b8f36b4505 1947 cursorX = x;
Pokitto 0:e8b8f36b4505 1948 cursorY = y;
Pokitto 0:e8b8f36b4505 1949 print(n,base);
Pokitto 0:e8b8f36b4505 1950 }
Pokitto 0:e8b8f36b4505 1951 void Display::print(uint8_t x, uint8_t y, double n, int digits) {
Pokitto 0:e8b8f36b4505 1952 cursorX = x;
Pokitto 0:e8b8f36b4505 1953 cursorY = y;
Pokitto 0:e8b8f36b4505 1954 print(n,digits);
Pokitto 0:e8b8f36b4505 1955 }
Pokitto 0:e8b8f36b4505 1956
Pokitto 0:e8b8f36b4505 1957 void Display::println(uint8_t x, uint8_t y, const char c[])
Pokitto 0:e8b8f36b4505 1958 {
Pokitto 0:e8b8f36b4505 1959 cursorX = x;
Pokitto 0:e8b8f36b4505 1960 cursorY = y;
Pokitto 0:e8b8f36b4505 1961 print(c);
Pokitto 0:e8b8f36b4505 1962 println();
Pokitto 0:e8b8f36b4505 1963 }
Pokitto 0:e8b8f36b4505 1964
Pokitto 0:e8b8f36b4505 1965 void Display::println(uint8_t x, uint8_t y, char c, int base)
Pokitto 0:e8b8f36b4505 1966 {
Pokitto 0:e8b8f36b4505 1967 cursorX = x;
Pokitto 0:e8b8f36b4505 1968 cursorY = y;
Pokitto 0:e8b8f36b4505 1969 print(c, base);
Pokitto 0:e8b8f36b4505 1970 println();
Pokitto 0:e8b8f36b4505 1971 }
Pokitto 0:e8b8f36b4505 1972
Pokitto 0:e8b8f36b4505 1973 void Display::println(uint8_t x, uint8_t y, unsigned char b, int base)
Pokitto 0:e8b8f36b4505 1974 {
Pokitto 0:e8b8f36b4505 1975 cursorX = x;
Pokitto 0:e8b8f36b4505 1976 cursorY = y;
Pokitto 0:e8b8f36b4505 1977 print(b, base);
Pokitto 0:e8b8f36b4505 1978 println();
Pokitto 0:e8b8f36b4505 1979 }
Pokitto 0:e8b8f36b4505 1980
Pokitto 0:e8b8f36b4505 1981 void Display::println(uint8_t x, uint8_t y, int n, int base)
Pokitto 0:e8b8f36b4505 1982 {
Pokitto 0:e8b8f36b4505 1983 cursorX = x;
Pokitto 0:e8b8f36b4505 1984 cursorY = y;
Pokitto 0:e8b8f36b4505 1985 print(n, base);
Pokitto 0:e8b8f36b4505 1986 println();
Pokitto 0:e8b8f36b4505 1987 }
Pokitto 0:e8b8f36b4505 1988
Pokitto 0:e8b8f36b4505 1989 void Display::println(uint8_t x, uint8_t y, unsigned int n, int base)
Pokitto 0:e8b8f36b4505 1990 {
Pokitto 0:e8b8f36b4505 1991 cursorX = x;
Pokitto 0:e8b8f36b4505 1992 cursorY = y;
Pokitto 0:e8b8f36b4505 1993 print(n, base);
Pokitto 0:e8b8f36b4505 1994 println();
Pokitto 0:e8b8f36b4505 1995 }
Pokitto 0:e8b8f36b4505 1996
Pokitto 0:e8b8f36b4505 1997 void Display::println(uint8_t x, uint8_t y, long n, int base)
Pokitto 0:e8b8f36b4505 1998 {
Pokitto 0:e8b8f36b4505 1999 cursorX = x;
Pokitto 0:e8b8f36b4505 2000 cursorY = y;
Pokitto 0:e8b8f36b4505 2001 print(n, base);
Pokitto 0:e8b8f36b4505 2002 println();
Pokitto 0:e8b8f36b4505 2003 }
Pokitto 0:e8b8f36b4505 2004
Pokitto 0:e8b8f36b4505 2005 void Display::println(uint8_t x, uint8_t y, unsigned long n, int base)
Pokitto 0:e8b8f36b4505 2006 {
Pokitto 0:e8b8f36b4505 2007 cursorX = x;
Pokitto 0:e8b8f36b4505 2008 cursorY = y;
Pokitto 0:e8b8f36b4505 2009 print(n, base);
Pokitto 0:e8b8f36b4505 2010 println();
Pokitto 0:e8b8f36b4505 2011 }
Pokitto 0:e8b8f36b4505 2012
Pokitto 0:e8b8f36b4505 2013 void Display::println(uint8_t x, uint8_t y, double n, int digits)
Pokitto 0:e8b8f36b4505 2014 {
Pokitto 0:e8b8f36b4505 2015 cursorX = x;
Pokitto 0:e8b8f36b4505 2016 cursorY = y;
Pokitto 0:e8b8f36b4505 2017 print(n, digits);
Pokitto 0:e8b8f36b4505 2018 println();
Pokitto 0:e8b8f36b4505 2019 }
Pokitto 0:e8b8f36b4505 2020
Pokitto 0:e8b8f36b4505 2021 void Display::printNumber(unsigned long n, uint8_t base)
Pokitto 0:e8b8f36b4505 2022 {
Pokitto 0:e8b8f36b4505 2023 unsigned char buf[8 * sizeof(long)]; // Assumes 8-bit chars.
Pokitto 0:e8b8f36b4505 2024 unsigned long i = 0;
Pokitto 0:e8b8f36b4505 2025
Pokitto 0:e8b8f36b4505 2026 if (n == 0) {
Pokitto 0:e8b8f36b4505 2027 print('0');
Pokitto 0:e8b8f36b4505 2028 return;
Pokitto 0:e8b8f36b4505 2029 }
Pokitto 0:e8b8f36b4505 2030
Pokitto 0:e8b8f36b4505 2031 while (n > 0) {
Pokitto 0:e8b8f36b4505 2032 buf[i++] = n % base;
Pokitto 0:e8b8f36b4505 2033 n /= base;
Pokitto 0:e8b8f36b4505 2034 }
Pokitto 0:e8b8f36b4505 2035
Pokitto 0:e8b8f36b4505 2036 for (; i > 0; i--)
Pokitto 0:e8b8f36b4505 2037 print((char) (buf[i - 1] < 10 ?
Pokitto 0:e8b8f36b4505 2038 '0' + buf[i - 1] :
Pokitto 0:e8b8f36b4505 2039 'A' + buf[i - 1] - 10));
Pokitto 0:e8b8f36b4505 2040 }
Pokitto 0:e8b8f36b4505 2041
Pokitto 0:e8b8f36b4505 2042 void Display::printFloat(double number, uint8_t digits)
Pokitto 0:e8b8f36b4505 2043 {
Pokitto 0:e8b8f36b4505 2044 // Handle negative numbers
Pokitto 0:e8b8f36b4505 2045 if (number < 0.0)
Pokitto 0:e8b8f36b4505 2046 {
Pokitto 0:e8b8f36b4505 2047 print('-');
Pokitto 0:e8b8f36b4505 2048 number = -number;
Pokitto 0:e8b8f36b4505 2049 }
Pokitto 0:e8b8f36b4505 2050
Pokitto 0:e8b8f36b4505 2051 // Round correctly so that print(1.999, 2) prints as "2.00"
Pokitto 0:e8b8f36b4505 2052 double rounding = 0.5;
Pokitto 0:e8b8f36b4505 2053 for (uint8_t i=0; i<digits; ++i)
Pokitto 0:e8b8f36b4505 2054 rounding /= 10.0;
Pokitto 0:e8b8f36b4505 2055
Pokitto 0:e8b8f36b4505 2056 number += rounding;
Pokitto 0:e8b8f36b4505 2057
Pokitto 0:e8b8f36b4505 2058 // Extract the integer part of the number and print it
Pokitto 0:e8b8f36b4505 2059 unsigned long int_part = (unsigned long)number;
Pokitto 0:e8b8f36b4505 2060 double remainder = number - (double)int_part;
Pokitto 0:e8b8f36b4505 2061 print(int_part);
Pokitto 0:e8b8f36b4505 2062
Pokitto 0:e8b8f36b4505 2063 // Print the decimal point, but only if there are digits beyond
Pokitto 0:e8b8f36b4505 2064 if (digits > 0)
Pokitto 0:e8b8f36b4505 2065 print(".");
Pokitto 0:e8b8f36b4505 2066
Pokitto 0:e8b8f36b4505 2067 // Extract digits from the remainder one at a time
Pokitto 0:e8b8f36b4505 2068 while (digits-- > 0)
Pokitto 0:e8b8f36b4505 2069 {
Pokitto 0:e8b8f36b4505 2070 remainder *= 10.0;
Pokitto 0:e8b8f36b4505 2071 int toPrint = int(remainder);
Pokitto 0:e8b8f36b4505 2072 print(toPrint);
Pokitto 0:e8b8f36b4505 2073 remainder -= toPrint;
Pokitto 0:e8b8f36b4505 2074 }
Pokitto 0:e8b8f36b4505 2075 }
Pokitto 0:e8b8f36b4505 2076
Pokitto 0:e8b8f36b4505 2077 void Display::draw4BitColumn(int16_t x, int16_t y, uint8_t h, uint8_t* bitmap)
Pokitto 0:e8b8f36b4505 2078 {
Pokitto 0:e8b8f36b4505 2079 int8_t scry;
Pokitto 0:e8b8f36b4505 2080 uint8_t* scrptr = m_scrbuf + (y*(width>>1) + (x>>1));
Pokitto 0:e8b8f36b4505 2081
Pokitto 0:e8b8f36b4505 2082 /** ONLY 4-bit mode for time being **/
Pokitto 0:e8b8f36b4505 2083
Pokitto 0:e8b8f36b4505 2084 if ((x&1)==0) { /** EVEN pixel starting line, very simple, just copypaste **/
Pokitto 0:e8b8f36b4505 2085 for (scry = y; scry < h+y; scry++) {
Pokitto 0:e8b8f36b4505 2086 uint8_t sourcepixel = *bitmap;
Pokitto 0:e8b8f36b4505 2087 uint8_t targetpixel = *scrptr;
Pokitto 0:e8b8f36b4505 2088 targetpixel = (targetpixel&0x0F) | (sourcepixel << 4);
Pokitto 0:e8b8f36b4505 2089 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 2090 bitmap++;
Pokitto 0:e8b8f36b4505 2091 scrptr+=55;
Pokitto 0:e8b8f36b4505 2092 }
Pokitto 0:e8b8f36b4505 2093 } else { /** ODD pixel starting line **/
Pokitto 0:e8b8f36b4505 2094 for (scry = y; scry < h+y; scry++) {
Pokitto 0:e8b8f36b4505 2095 uint8_t sourcepixel = *bitmap;
Pokitto 0:e8b8f36b4505 2096 uint8_t targetpixel = *scrptr;
Pokitto 0:e8b8f36b4505 2097 // store source pixel in lower nibble of target
Pokitto 0:e8b8f36b4505 2098 targetpixel = (targetpixel & 0xF0) | (sourcepixel);
Pokitto 0:e8b8f36b4505 2099 *scrptr = targetpixel;
Pokitto 0:e8b8f36b4505 2100 scrptr+=55;
Pokitto 0:e8b8f36b4505 2101 bitmap++;
Pokitto 0:e8b8f36b4505 2102 }
Pokitto 0:e8b8f36b4505 2103 }
Pokitto 0:e8b8f36b4505 2104 }
Pokitto 0:e8b8f36b4505 2105
Pokitto 0:e8b8f36b4505 2106 void Display::lcdRefresh(unsigned char* scr) {
Pokitto 0:e8b8f36b4505 2107
Pokitto 0:e8b8f36b4505 2108 #if POK_SCREENMODE == MODE_GAMEBOY
Pokitto 0:e8b8f36b4505 2109 lcdRefreshModeGBC(scr, paletteptr);
Pokitto 0:e8b8f36b4505 2110 #endif
Pokitto 0:e8b8f36b4505 2111
Pokitto 0:e8b8f36b4505 2112 #if POK_SCREENMODE == MODE_HI_4COLOR
Pokitto 0:e8b8f36b4505 2113 lcdRefreshMode1(scr, paletteptr);
Pokitto 0:e8b8f36b4505 2114 #endif
Pokitto 0:e8b8f36b4505 2115
Pokitto 0:e8b8f36b4505 2116 #if POK_SCREENMODE == MODE_FAST_16COLOR
Pokitto 0:e8b8f36b4505 2117 lcdRefreshMode2(scr, paletteptr);
Pokitto 0:e8b8f36b4505 2118 #endif
Pokitto 0:e8b8f36b4505 2119
Pokitto 0:e8b8f36b4505 2120 #if POK_SCREENMODE == MODE_GAMEBUINO_16COLOR
Pokitto 0:e8b8f36b4505 2121 lcdRefreshGB(scr, paletteptr);
Pokitto 0:e8b8f36b4505 2122 #endif
Pokitto 0:e8b8f36b4505 2123
Pokitto 0:e8b8f36b4505 2124 #if POK_SCREENMODE == MODE_ARDUBOY_16COLOR
Pokitto 0:e8b8f36b4505 2125 lcdRefreshAB(scr, paletteptr);
Pokitto 0:e8b8f36b4505 2126 #endif
Pokitto 0:e8b8f36b4505 2127
Pokitto 0:e8b8f36b4505 2128 }
Pokitto 0:e8b8f36b4505 2129
Pokitto 0:e8b8f36b4505 2130 void Display::setFrameBufferTo(uint8_t* sb) {
Pokitto 0:e8b8f36b4505 2131 m_scrbuf = sb;
Pokitto 0:e8b8f36b4505 2132 };
Pokitto 0:e8b8f36b4505 2133
Pokitto 0:e8b8f36b4505 2134 void Display::setTileBufferTo(uint8_t* tb) {
Pokitto 0:e8b8f36b4505 2135 m_tilebuf = tb;
Pokitto 0:e8b8f36b4505 2136 };
Pokitto 0:e8b8f36b4505 2137
Pokitto 0:e8b8f36b4505 2138 void Display::loadTileset(const uint8_t* ts) {
Pokitto 0:e8b8f36b4505 2139 m_tileset = (uint8_t*) ts;
Pokitto 0:e8b8f36b4505 2140 };
Pokitto 0:e8b8f36b4505 2141
Pokitto 0:e8b8f36b4505 2142 void Display::setTile(uint16_t i, uint8_t t) {
Pokitto 0:e8b8f36b4505 2143 if (!m_tilebuf) return;
Pokitto 0:e8b8f36b4505 2144 m_tilebuf[i]=t;
Pokitto 0:e8b8f36b4505 2145 };
Pokitto 0:e8b8f36b4505 2146
Pokitto 0:e8b8f36b4505 2147
Pokitto 0:e8b8f36b4505 2148 /** Eof */
Pokitto 0:e8b8f36b4505 2149
Pokitto 0:e8b8f36b4505 2150
Pokitto 0:e8b8f36b4505 2151