Fri Sep 30, 2016 9:05 am
Arduino: 1.6.11 (Windows 7), TD: 1.30-beta3, Board: "Teensy 3.2 / 3.1, Serial, 96 MHz optimize speed (overclock), US English"
C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp: In member function 'void Adafruit_GFX::drawTilemap(int, int, const uint8_t*, const uint8_t**, uint8_t, uint8_t, uint8_t, uint8_t)':
C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:477:72: error: no matching function for call to 'Adafruit_GFX::drawBitmap(int8_t&, int8_t&, uint8_t&, uint8_t&, const uint8_t*&)'
drawBitmap(drawX, drawY, tile_width, tile_height, spritesheet[tile]);
^
C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:477:72: note: candidate is:
C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:356:6: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, const uint8_t*, int16_t, int16_t, uint16_t)
void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
^
C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:356:6: note: candidate expects 6 arguments, 5 provided
C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:487:88: error: no matching function for call to 'Adafruit_GFX::drawBitmap(int8_t&, int8_t&, uint8_t&, uint8_t&, const uint8_t*&, uint8_t&, uint8_t&, uint8_t&, uint8_t&)'
drawBitmap(drawX, drawY, tile_width, tile_height, spritesheet[tile], dx, dy, dw, dh);
^
C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:487:88: note: candidate is:
C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:356:6: note: void Adafruit_GFX::drawBitmap(int16_t, int16_t, const uint8_t*, int16_t, int16_t, uint16_t)
void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
^
C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:356:6: note: candidate expects 6 arguments, 9 provided
C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp: In member function 'void Adafruit_GFX::drawChar(int16_t, int16_t, unsigned char, uint16_t, uint16_t, uint8_t)':
C:\Users\duhjoker\Documents\Arduino\libraries\LCD_2000_7775_TEENSY\src\utility\Adafruit_GFX.cpp:590:14: warning: unused variable 'xa' [-Wunused-variable]
xa = pgm_read_byte(&glyph->xAdvance);
^
Error compiling for board Teensy 3.2 / 3.1.
This report would have more information with
"Show verbose output during compilation"
option enabled in File -> Preferences.
#ifdef __AVR__
#include <avr/pgmspace.h>
#elif defined(ESP8266)
#include <pgmspace.h>
#endif
#include "Adafruit_GFX.h"
#include "glcdfont.c"
#define LCD_2000_7775_TFTWIDTH 176
#define LCD_2000_7775_TFTHEIGHT 220
// Many (but maybe not all) non-AVR board installs define macros
// for compatibility with existing PROGMEM-reading AVR code.
// Do our own checks and defines here for good measure...
#ifndef pgm_read_byte
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#endif
#ifndef pgm_read_word
#define pgm_read_word(addr) (*(const unsigned short *)(addr))
#endif
#ifndef pgm_read_dword
#define pgm_read_dword(addr) (*(const unsigned long *)(addr))
#endif
// Pointers are a peculiar case...typically 16-bit on AVR boards,
// 32 bits elsewhere. Try to accommodate both...
#if !defined(__INT_MAX__) || (__INT_MAX__ > 0xFFFF)
#define pgm_read_pointer(addr) ((void *)pgm_read_dword(addr))
#else
#define pgm_read_pointer(addr) ((void *)pgm_read_word(addr))
#endif
#ifndef min
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif
#ifndef _swap_int16_t
#define _swap_int16_t(a, b) { int16_t t = a; a = b; b = t; }
#endif
Adafruit_GFX::Adafruit_GFX(int16_t w, int16_t h):
WIDTH(w), HEIGHT(h)
{
_width = WIDTH;
_height = HEIGHT;
rotation = 0;
cursor_y = cursor_x = 0;
textsize = 1;
textcolor = textbgcolor = 0xFFFF;
wrap = true;
_cp437 = false;
gfxFont = NULL;
}
// Draw a circle outline
void Adafruit_GFX::drawCircle(int16_t x0, int16_t y0, int16_t r,
uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;
drawPixel(x0 , y0+r, color);
drawPixel(x0 , y0-r, color);
drawPixel(x0+r, y0 , color);
drawPixel(x0-r, y0 , color);
while (x<y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
drawPixel(x0 + x, y0 + y, color);
drawPixel(x0 - x, y0 + y, color);
drawPixel(x0 + x, y0 - y, color);
drawPixel(x0 - x, y0 - y, color);
drawPixel(x0 + y, y0 + x, color);
drawPixel(x0 - y, y0 + x, color);
drawPixel(x0 + y, y0 - x, color);
drawPixel(x0 - y, y0 - x, color);
}
}
void Adafruit_GFX::drawCircleHelper( int16_t x0, int16_t y0,
int16_t r, uint8_t cornername, uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;
while (x<y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
if (cornername & 0x4) {
drawPixel(x0 + x, y0 + y, color);
drawPixel(x0 + y, y0 + x, color);
}
if (cornername & 0x2) {
drawPixel(x0 + x, y0 - y, color);
drawPixel(x0 + y, y0 - x, color);
}
if (cornername & 0x8) {
drawPixel(x0 - y, y0 + x, color);
drawPixel(x0 - x, y0 + y, color);
}
if (cornername & 0x1) {
drawPixel(x0 - y, y0 - x, color);
drawPixel(x0 - x, y0 - y, color);
}
}
}
void Adafruit_GFX::fillCircle(int16_t x0, int16_t y0, int16_t r,
uint16_t color) {
drawFastVLine(x0, y0-r, 2*r+1, color);
fillCircleHelper(x0, y0, r, 3, 0, color);
}
// Used to do circles and roundrects
void Adafruit_GFX::fillCircleHelper(int16_t x0, int16_t y0, int16_t r,
uint8_t cornername, int16_t delta, uint16_t color) {
int16_t f = 1 - r;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * r;
int16_t x = 0;
int16_t y = r;
while (x<y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;
if (cornername & 0x1) {
drawFastVLine(x0+x, y0-y, 2*y+1+delta, color);
drawFastVLine(x0+y, y0-x, 2*x+1+delta, color);
}
if (cornername & 0x2) {
drawFastVLine(x0-x, y0-y, 2*y+1+delta, color);
drawFastVLine(x0-y, y0-x, 2*x+1+delta, color);
}
}
}
// Bresenham's algorithm - thx wikpedia
void Adafruit_GFX::drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
uint16_t color) {
int16_t steep = abs(y1 - y0) > abs(x1 - x0);
if (steep) {
_swap_int16_t(x0, y0);
_swap_int16_t(x1, y1);
}
if (x0 > x1) {
_swap_int16_t(x0, x1);
_swap_int16_t(y0, y1);
}
int16_t dx, dy;
dx = x1 - x0;
dy = abs(y1 - y0);
int16_t err = dx / 2;
int16_t ystep;
if (y0 < y1) {
ystep = 1;
} else {
ystep = -1;
}
for (; x0<=x1; x0++) {
if (steep) {
drawPixel(y0, x0, color);
} else {
drawPixel(x0, y0, color);
}
err -= dy;
if (err < 0) {
y0 += ystep;
err += dx;
}
}
}
// Draw a rectangle
void Adafruit_GFX::drawRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color) {
drawFastHLine(x, y, w, color);
drawFastHLine(x, y+h-1, w, color);
drawFastVLine(x, y, h, color);
drawFastVLine(x+w-1, y, h, color);
}
void Adafruit_GFX::drawFastVLine(int16_t x, int16_t y,
int16_t h, uint16_t color) {
// Update in subclasses if desired!
drawLine(x, y, x, y+h-1, color);
}
void Adafruit_GFX::drawFastHLine(int16_t x, int16_t y,
int16_t w, uint16_t color) {
// Update in subclasses if desired!
drawLine(x, y, x+w-1, y, color);
}
void Adafruit_GFX::fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color) {
// Update in subclasses if desired!
for (int16_t i=x; i<x+w; i++) {
drawFastVLine(i, y, h, color);
}
}
void Adafruit_GFX::fillScreen(uint16_t color) {
fillRect(0, 0, _width, _height, color);
}
// Draw a rounded rectangle
void Adafruit_GFX::drawRoundRect(int16_t x, int16_t y, int16_t w,
int16_t h, int16_t r, uint16_t color) {
// smarter version
drawFastHLine(x+r , y , w-2*r, color); // Top
drawFastHLine(x+r , y+h-1, w-2*r, color); // Bottom
drawFastVLine(x , y+r , h-2*r, color); // Left
drawFastVLine(x+w-1, y+r , h-2*r, color); // Right
// draw four corners
drawCircleHelper(x+r , y+r , r, 1, color);
drawCircleHelper(x+w-r-1, y+r , r, 2, color);
drawCircleHelper(x+w-r-1, y+h-r-1, r, 4, color);
drawCircleHelper(x+r , y+h-r-1, r, 8, color);
}
// Fill a rounded rectangle
void Adafruit_GFX::fillRoundRect(int16_t x, int16_t y, int16_t w,
int16_t h, int16_t r, uint16_t color) {
// smarter version
fillRect(x+r, y, w-2*r, h, color);
// draw four corners
fillCircleHelper(x+w-r-1, y+r, r, 1, h-2*r-1, color);
fillCircleHelper(x+r , y+r, r, 2, h-2*r-1, color);
}
// Draw a triangle
void Adafruit_GFX::drawTriangle(int16_t x0, int16_t y0,
int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
drawLine(x0, y0, x1, y1, color);
drawLine(x1, y1, x2, y2, color);
drawLine(x2, y2, x0, y0, color);
}
// Fill a triangle
void Adafruit_GFX::fillTriangle(int16_t x0, int16_t y0,
int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
int16_t a, b, y, last;
// Sort coordinates by Y order (y2 >= y1 >= y0)
if (y0 > y1) {
_swap_int16_t(y0, y1); _swap_int16_t(x0, x1);
}
if (y1 > y2) {
_swap_int16_t(y2, y1); _swap_int16_t(x2, x1);
}
if (y0 > y1) {
_swap_int16_t(y0, y1); _swap_int16_t(x0, x1);
}
if(y0 == y2) { // Handle awkward all-on-same-line case as its own thing
a = b = x0;
if(x1 < a) a = x1;
else if(x1 > b) b = x1;
if(x2 < a) a = x2;
else if(x2 > b) b = x2;
drawFastHLine(a, y0, b-a+1, color);
return;
}
int16_t
dx01 = x1 - x0,
dy01 = y1 - y0,
dx02 = x2 - x0,
dy02 = y2 - y0,
dx12 = x2 - x1,
dy12 = y2 - y1;
int32_t
sa = 0,
sb = 0;
// For upper part of triangle, find scanline crossings for segments
// 0-1 and 0-2. If y1=y2 (flat-bottomed triangle), the scanline y1
// is included here (and second loop will be skipped, avoiding a /0
// error there), otherwise scanline y1 is skipped here and handled
// in the second loop...which also avoids a /0 error here if y0=y1
// (flat-topped triangle).
if(y1 == y2) last = y1; // Include y1 scanline
else last = y1-1; // Skip it
for(y=y0; y<=last; y++) {
a = x0 + sa / dy01;
b = x0 + sb / dy02;
sa += dx01;
sb += dx02;
/* longhand:
a = x0 + (x1 - x0) * (y - y0) / (y1 - y0);
b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
*/
if(a > b) _swap_int16_t(a,b);
drawFastHLine(a, y, b-a+1, color);
}
// For lower part of triangle, find scanline crossings for segments
// 0-2 and 1-2. This loop is skipped if y1=y2.
sa = dx12 * (y - y1);
sb = dx02 * (y - y0);
for(; y<=y2; y++) {
a = x1 + sa / dy12;
b = x0 + sb / dy02;
sa += dx12;
sb += dx02;
/* longhand:
a = x1 + (x2 - x1) * (y - y1) / (y2 - y1);
b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
*/
if(a > b) _swap_int16_t(a,b);
drawFastHLine(a, y, b-a+1, color);
}
}
// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
// provided bitmap buffer (must be PROGMEM memory) using the specified
// foreground color (unset bits are transparent).
void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {
int16_t i, j, byteWidth = (w + 7) / 8;
uint8_t byte;
for(j=0; j<h; j++) {
for(i=0; i<w; i++) {
if(i & 7) byte <<= 1;
else byte = pgm_read_byte(bitmap + j * byteWidth + i / 8);
if(byte & 0x80) drawPixel(x+i, y+j, color);
}
}
}
// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
// provided bitmap buffer (must be PROGMEM memory) using the specified
// foreground (for set bits) and background (for clear bits) colors.
//void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
// const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) {
// int16_t i, j, byteWidth = (w + 7) / 8;
// uint8_t byte;
// for(j=0; j<h; j++) {
// for(i=0; i<w; i++ ) {
// if(i & 7) byte <<= 1;
// else byte = pgm_read_byte(bitmap + j * byteWidth + i / 8);
// if(byte & 0x80) drawPixel(x+i, y+j, color);
// else drawPixel(x+i, y+j, bg);
// }
// }
//}
// drawBitmap() variant for RAM-resident (not PROGMEM) bitmaps.
//void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
// uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {
// int16_t i, j, byteWidth = (w + 7) / 8;
// uint8_t byte;
// for(j=0; j<h; j++) {
// for(i=0; i<w; i++ ) {
// if(i & 7) byte <<= 1;
// else byte = bitmap[j * byteWidth + i / 8];
// if(byte & 0x80) drawPixel(x+i, y+j, color);
// }
// }
//}
// drawBitmap() variant w/background for RAM-resident (not PROGMEM) bitmaps.
//void Adafruit_GFX::drawBitmap(int16_t x, int16_t y,
// uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) {
// int16_t i, j, byteWidth = (w + 7) / 8;
// uint8_t byte;
// for(j=0; j<h; j++) {
// for(i=0; i<w; i++ ) {
// if(i & 7) byte <<= 1;
// else byte = bitmap[j * byteWidth + i / 8];
// if(byte & 0x80) drawPixel(x+i, y+j, color);
// else drawPixel(x+i, y+j, bg);
// }
// }
//}
//Draw XBitMap Files (*.xbm), exported from GIMP,
//Usage: Export from GIMP to *.xbm, rename *.xbm to *.c and open in editor.
//C Array can be directly used with this function
void Adafruit_GFX::drawXBitmap(int16_t x, int16_t y,
const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {
int16_t i, j, byteWidth = (w + 7) / 8;
uint8_t byte;
for(j=0; j<h; j++) {
for(i=0; i<w; i++ ) {
if(i & 7) byte >>= 1;
else byte = pgm_read_byte(bitmap + j * byteWidth + i / 8);
if(byte & 0x01) drawPixel(x+i, y+j, color);
}
}
}
///SUMMONER123
void Adafruit_GFX::drawTilemap(int x, int y, const uint8_t *tilemap, const uint8_t **spritesheet) {
drawTilemap(x, y, tilemap, spritesheet, 0, 0, LCD_2000_7775_TFTWIDTH, LCD_2000_7775_TFTHEIGHT);
}
void Adafruit_GFX::drawTilemap(int x, int y, const uint8_t *tilemap, const uint8_t **spritesheet, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh) {
uint8_t tilemap_width = pgm_read_byte(tilemap);
uint8_t tilemap_height = pgm_read_byte(tilemap + 1);
uint8_t tile_width = pgm_read_byte(tilemap + 2);
uint8_t tile_height = pgm_read_byte(tilemap + 3);
tilemap += 4; // now the first tiyleis at tilemap
uint8_t ddw = dw + dx;
uint8_t ddh = dh + dy;
uint8_t maxDdx = (dw - x + tile_width - 1) / tile_width;
uint8_t maxDdy = (dh - y + tile_height - 1) / tile_height;
if (tilemap_width < maxDdx) {
maxDdx = tilemap_width;
}
if (tilemap_height < maxDdy) {
maxDdy = tilemap_height;
}
int8_t startDdx = (-x) / tile_width;
int8_t startDdy = (-y) / tile_height;
if (startDdx < 0) {
startDdx = 0;
}
if (startDdy < 0) {
startDdy = 0;
}
if (flagcollision)numcolision = 0; //Line 735 - clear numcolision - ADD by Summoner123
for (uint8_t ddy = startDdy; ddy < maxDdy; ddy++) {
for (uint8_t ddx = startDdx; ddx < maxDdx; ddx++) {
int8_t drawX = ddx*tile_width + x + dx;
int8_t drawY = ddy*tile_height + y + dy;
uint8_t tile = pgm_read_byte(tilemap + ddy*tilemap_width + ddx);
if (drawX >= dx && drawY >= dy && drawX <= (ddw - tile_width) && drawY <= (ddh - tile_height)) {
drawBitmap(drawX, drawY, tile_width, tile_height, spritesheet[tile]);
if (flagcollision) {
solid[numcolision].x = drawX; //Save X coordinate - ADD by Summoner123
solid[numcolision].y = drawY; //Save Y coordinate - ADD by Summoner123
solid[numcolision].spritecol = spritesheet[tile]; //Save Sprite of tile - ADD by Summoner123
numcolision++; //Increment numcolision - ADD by Summoner123
}
}
else { // we need to draw a partial bitmap
drawBitmap(drawX, drawY, tile_width, tile_height, spritesheet[tile], dx, dy, dw, dh);
}
}
}
}
#if ARDUINO >= 100
size_t Adafruit_GFX::write(uint8_t c) {
#else
void Adafruit_GFX::write(uint8_t c) {
#endif
if(!gfxFont) { // 'Classic' built-in font
if(c == '\n') {
cursor_y += textsize*8;
cursor_x = 0;
} else if(c == '\r') {
// skip em
} else {
if(wrap && ((cursor_x + textsize * 6) >= _width)) { // Heading off edge?
cursor_x = 0; // Reset x to zero
cursor_y += textsize * 8; // Advance y one line
}
drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize);
cursor_x += textsize * 6;
}
} else { // Custom font
if(c == '\n') {
cursor_x = 0;
cursor_y += (int16_t)textsize *
(uint8_t)pgm_read_byte(&gfxFont->yAdvance);
} else if(c != '\r') {
uint8_t first = pgm_read_byte(&gfxFont->first);
if((c >= first) && (c <= (uint8_t)pgm_read_byte(&gfxFont->last))) {
uint8_t c2 = c - pgm_read_byte(&gfxFont->first);
GFXglyph *glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c2]);
uint8_t w = pgm_read_byte(&glyph->width),
h = pgm_read_byte(&glyph->height);
if((w > 0) && (h > 0)) { // Is there an associated bitmap?
int16_t xo = (int8_t)pgm_read_byte(&glyph->xOffset); // sic
if(wrap && ((cursor_x + textsize * (xo + w)) >= _width)) {
// Drawing character would go off right edge; wrap to new line
cursor_x = 0;
cursor_y += (int16_t)textsize *
(uint8_t)pgm_read_byte(&gfxFont->yAdvance);
}
drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize);
}
cursor_x += pgm_read_byte(&glyph->xAdvance) * (int16_t)textsize;
}
}
}
#if ARDUINO >= 100
return 1;
#endif
}
// Draw a character
void Adafruit_GFX::drawChar(int16_t x, int16_t y, unsigned char c,
uint16_t color, uint16_t bg, uint8_t size) {
if(!gfxFont) { // 'Classic' built-in font
if((x >= _width) || // Clip right
(y >= _height) || // Clip bottom
((x + 6 * size - 1) < 0) || // Clip left
((y + 8 * size - 1) < 0)) // Clip top
return;
if(!_cp437 && (c >= 176)) c++; // Handle 'classic' charset behavior
for(int8_t i=0; i<6; i++ ) {
uint8_t line;
if(i < 5) line = pgm_read_byte(font+(c*5)+i);
else line = 0x0;
for(int8_t j=0; j<8; j++, line >>= 1) {
if(line & 0x1) {
if(size == 1) drawPixel(x+i, y+j, color);
else fillRect(x+(i*size), y+(j*size), size, size, color);
} else if(bg != color) {
if(size == 1) drawPixel(x+i, y+j, bg);
else fillRect(x+i*size, y+j*size, size, size, bg);
}
}
}
} else { // Custom font
// Character is assumed previously filtered by write() to eliminate
// newlines, returns, non-printable characters, etc. Calling drawChar()
// directly with 'bad' characters of font may cause mayhem!
c -= pgm_read_byte(&gfxFont->first);
GFXglyph *glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
uint8_t *bitmap = (uint8_t *)pgm_read_pointer(&gfxFont->bitmap);
uint16_t bo = pgm_read_word(&glyph->bitmapOffset);
uint8_t w = pgm_read_byte(&glyph->width),
h = pgm_read_byte(&glyph->height),
xa = pgm_read_byte(&glyph->xAdvance);
int8_t xo = pgm_read_byte(&glyph->xOffset),
yo = pgm_read_byte(&glyph->yOffset);
uint8_t xx, yy, bits, bit = 0;
int16_t xo16, yo16;
if(size > 1) {
xo16 = xo;
yo16 = yo;
}
// Todo: Add character clipping here
// NOTE: THERE IS NO 'BACKGROUND' COLOR OPTION ON CUSTOM FONTS.
// THIS IS ON PURPOSE AND BY DESIGN. The background color feature
// has typically been used with the 'classic' font to overwrite old
// screen contents with new data. This ONLY works because the
// characters are a uniform size; it's not a sensible thing to do with
// proportionally-spaced fonts with glyphs of varying sizes (and that
// may overlap). To replace previously-drawn text when using a custom
// font, use the getTextBounds() function to determine the smallest
// rectangle encompassing a string, erase the area with fillRect(),
// then draw new text. This WILL infortunately 'blink' the text, but
// is unavoidable. Drawing 'background' pixels will NOT fix this,
// only creates a new set of problems. Have an idea to work around
// this (a canvas object type for MCUs that can afford the RAM and
// displays supporting setAddrWindow() and pushColors()), but haven't
// implemented this yet.
for(yy=0; yy<h; yy++) {
for(xx=0; xx<w; xx++) {
if(!(bit++ & 7)) {
bits = pgm_read_byte(&bitmap[bo++]);
}
if(bits & 0x80) {
if(size == 1) {
drawPixel(x+xo+xx, y+yo+yy, color);
} else {
fillRect(x+(xo16+xx)*size, y+(yo16+yy)*size, size, size, color);
}
}
bits <<= 1;
}
}
} // End classic vs custom font
}
void Adafruit_GFX::setCursor(int16_t x, int16_t y) {
cursor_x = x;
cursor_y = y;
}
int16_t Adafruit_GFX::getCursorX(void){
return cursor_x;
}
int16_t Adafruit_GFX::getCursorY(void){
return cursor_y;
}
void Adafruit_GFX::setTextSize(uint8_t s) {
textsize = (s > 0) ? s : 1;
}
void Adafruit_GFX::setTextColor(uint16_t c) {
// For 'transparent' background, we'll set the bg
// to the same as fg instead of using a flag
textcolor = textbgcolor = c;
}
void Adafruit_GFX::setTextColor(uint16_t c, uint16_t b) {
textcolor = c;
textbgcolor = b;
}
void Adafruit_GFX::setTextWrap(boolean w) {
wrap = w;
}
uint8_t Adafruit_GFX::getRotation(void)
{
return rotation;
}
void Adafruit_GFX::setRotation(uint8_t x) {
rotation = (x & 3);
switch(rotation) {
case 0:
case 2:
_width = WIDTH;
_height = HEIGHT;
break;
case 1:
case 3:
_width = HEIGHT;
_height = WIDTH;
break;
}
}
// Enable (or disable) Code Page 437-compatible charset.
// There was an error in glcdfont.c for the longest time -- one character
// (#176, the 'light shade' block) was missing -- this threw off the index
// of every character that followed it. But a TON of code has been written
// with the erroneous character indices. By default, the library uses the
// original 'wrong' behavior and old sketches will still work. Pass 'true'
// to this function to use correct CP437 character values in your code.
void Adafruit_GFX::cp437(boolean x) {
_cp437 = x;
}
void Adafruit_GFX::setFont(const GFXfont *f) {
if(f) { // Font struct pointer passed in?
if(!gfxFont) { // And no current font struct?
// Switching from classic to new font behavior.
// Move cursor pos down 6 pixels so it's on baseline.
cursor_y += 6;
}
} else if(gfxFont) { // NULL passed. Current font struct defined?
// Switching from new to classic font behavior.
// Move cursor pos up 6 pixels so it's at top-left of char.
cursor_y -= 6;
}
gfxFont = (GFXfont *)f;
}
// Pass string and a cursor position, returns UL corner and W,H.
void Adafruit_GFX::getTextBounds(char *str, int16_t x, int16_t y,
int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) {
uint8_t c; // Current character
*x1 = x;
*y1 = y;
*w = *h = 0;
if(gfxFont) {
GFXglyph *glyph;
uint8_t first = pgm_read_byte(&gfxFont->first),
last = pgm_read_byte(&gfxFont->last),
gw, gh, xa;
int8_t xo, yo;
int16_t minx = _width, miny = _height, maxx = -1, maxy = -1,
gx1, gy1, gx2, gy2, ts = (int16_t)textsize,
ya = ts * (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
while((c = *str++)) {
if(c != '\n') { // Not a newline
if(c != '\r') { // Not a carriage return, is normal char
if((c >= first) && (c <= last)) { // Char present in current font
c -= first;
glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
gw = pgm_read_byte(&glyph->width);
gh = pgm_read_byte(&glyph->height);
xa = pgm_read_byte(&glyph->xAdvance);
xo = pgm_read_byte(&glyph->xOffset);
yo = pgm_read_byte(&glyph->yOffset);
if(wrap && ((x + (((int16_t)xo + gw) * ts)) >= _width)) {
// Line wrap
x = 0; // Reset x to 0
y += ya; // Advance y by 1 line
}
gx1 = x + xo * ts;
gy1 = y + yo * ts;
gx2 = gx1 + gw * ts - 1;
gy2 = gy1 + gh * ts - 1;
if(gx1 < minx) minx = gx1;
if(gy1 < miny) miny = gy1;
if(gx2 > maxx) maxx = gx2;
if(gy2 > maxy) maxy = gy2;
x += xa * ts;
}
} // Carriage return = do nothing
} else { // Newline
x = 0; // Reset x
y += ya; // Advance y by 1 line
}
}
// End of string
*x1 = minx;
*y1 = miny;
if(maxx >= minx) *w = maxx - minx + 1;
if(maxy >= miny) *h = maxy - miny + 1;
} else { // Default font
uint16_t lineWidth = 0, maxWidth = 0; // Width of current, all lines
while((c = *str++)) {
if(c != '\n') { // Not a newline
if(c != '\r') { // Not a carriage return, is normal char
if(wrap && ((x + textsize * 6) >= _width)) {
x = 0; // Reset x to 0
y += textsize * 8; // Advance y by 1 line
if(lineWidth > maxWidth) maxWidth = lineWidth; // Save widest line
lineWidth = textsize * 6; // First char on new line
} else { // No line wrap, just keep incrementing X
lineWidth += textsize * 6; // Includes interchar x gap
}
} // Carriage return = do nothing
} else { // Newline
x = 0; // Reset x to 0
y += textsize * 8; // Advance y by 1 line
if(lineWidth > maxWidth) maxWidth = lineWidth; // Save widest line
lineWidth = 0; // Reset lineWidth for new line
}
}
// End of string
if(lineWidth) y += textsize * 8; // Add height of last (or only) line
*w = maxWidth - 1; // Don't include last interchar x gap
*h = y - *y1;
} // End classic vs custom font
}
// Same as above, but for PROGMEM strings
void Adafruit_GFX::getTextBounds(const __FlashStringHelper *str,
int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h) {
uint8_t *s = (uint8_t *)str, c;
*x1 = x;
*y1 = y;
*w = *h = 0;
if(gfxFont) {
GFXglyph *glyph;
uint8_t first = pgm_read_byte(&gfxFont->first),
last = pgm_read_byte(&gfxFont->last),
gw, gh, xa;
int8_t xo, yo;
int16_t minx = _width, miny = _height, maxx = -1, maxy = -1,
gx1, gy1, gx2, gy2, ts = (int16_t)textsize,
ya = ts * (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
while((c = pgm_read_byte(s++))) {
if(c != '\n') { // Not a newline
if(c != '\r') { // Not a carriage return, is normal char
if((c >= first) && (c <= last)) { // Char present in current font
c -= first;
glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
gw = pgm_read_byte(&glyph->width);
gh = pgm_read_byte(&glyph->height);
xa = pgm_read_byte(&glyph->xAdvance);
xo = pgm_read_byte(&glyph->xOffset);
yo = pgm_read_byte(&glyph->yOffset);
if(wrap && ((x + (((int16_t)xo + gw) * ts)) >= _width)) {
// Line wrap
x = 0; // Reset x to 0
y += ya; // Advance y by 1 line
}
gx1 = x + xo * ts;
gy1 = y + yo * ts;
gx2 = gx1 + gw * ts - 1;
gy2 = gy1 + gh * ts - 1;
if(gx1 < minx) minx = gx1;
if(gy1 < miny) miny = gy1;
if(gx2 > maxx) maxx = gx2;
if(gy2 > maxy) maxy = gy2;
x += xa * ts;
}
} // Carriage return = do nothing
} else { // Newline
x = 0; // Reset x
y += ya; // Advance y by 1 line
}
}
// End of string
*x1 = minx;
*y1 = miny;
if(maxx >= minx) *w = maxx - minx + 1;
if(maxy >= miny) *h = maxy - miny + 1;
} else { // Default font
uint16_t lineWidth = 0, maxWidth = 0; // Width of current, all lines
while((c = pgm_read_byte(s++))) {
if(c != '\n') { // Not a newline
if(c != '\r') { // Not a carriage return, is normal char
if(wrap && ((x + textsize * 6) >= _width)) {
x = 0; // Reset x to 0
y += textsize * 8; // Advance y by 1 line
if(lineWidth > maxWidth) maxWidth = lineWidth; // Save widest line
lineWidth = textsize * 6; // First char on new line
} else { // No line wrap, just keep incrementing X
lineWidth += textsize * 6; // Includes interchar x gap
}
} // Carriage return = do nothing
} else { // Newline
x = 0; // Reset x to 0
y += textsize * 8; // Advance y by 1 line
if(lineWidth > maxWidth) maxWidth = lineWidth; // Save widest line
lineWidth = 0; // Reset lineWidth for new line
}
}
// End of string
if(lineWidth) y += textsize * 8; // Add height of last (or only) line
*w = maxWidth - 1; // Don't include last interchar x gap
*h = y - *y1;
} // End classic vs custom font
}
// Return the size of the display (per current rotation)
int16_t Adafruit_GFX::width(void)
{
return _width;
}
int16_t Adafruit_GFX::height(void)
{
return _height;
}
void Adafruit_GFX::invertDisplay(boolean i) {
// Do nothing, must be subclassed if supported by hardware
}
uint16_t Adafruit_GFX::newColor(uint8_t r, uint8_t g, uint8_t b)
{
return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
}
void Adafruit_GFX::background(uint8_t red, uint8_t green, uint8_t blue)
{
background(newColor(red, green, blue));
}
void Adafruit_GFX::background(color c) {
fillScreen(c);
}
void Adafruit_GFX::stroke(uint8_t red, uint8_t green, uint8_t blue)
{
stroke(newColor(red, green, blue));
}
void Adafruit_GFX::stroke(color c)
{
useStroke = true;
strokeColor = c;
setTextColor(c);
}
void Adafruit_GFX::noStroke()
{
useStroke = false;
}
void Adafruit_GFX::noFill() {
useFill = false;
}
void Adafruit_GFX::fill(uint8_t red, uint8_t green, uint8_t blue)
{
fill(newColor(red, green, blue));
}
void Adafruit_GFX::fill(color c)
{
useFill = true;
fillColor = c;
}
void Adafruit_GFX::text(const char * text, int16_t x, int16_t y)
{
if (!useStroke)
return;
setTextWrap(false);
setTextColor(strokeColor);
setCursor(x, y);
print(text);
}
void Adafruit_GFX::textWrap(const char * text, int16_t x, int16_t y)
{
if (!useStroke)
return;
setTextWrap(true);
setTextColor(strokeColor);
setCursor(x, y);
print(text);
}
void Adafruit_GFX::textSize(uint8_t size)
{
setTextSize(size);
}
void Adafruit_GFX::point(int16_t x, int16_t y)
{
if (!useStroke)
return;
drawPixel(x, y, strokeColor);
}
void Adafruit_GFX::line(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
{
if (!useStroke)
return;
if (x1 == x2) {
if (y1 < y2)
drawFastVLine(x1, y1, y2 - y1, strokeColor);
else
drawFastVLine(x1, y2, y1 - y2, strokeColor);
}
else if (y1 == y2) {
if (x1 < x2)
drawFastHLine(x1, y1, x2 - x1, strokeColor);
else
drawFastHLine(x2, y1, x1 - x2, strokeColor);
}
else {
drawLine(x1, y1, x2, y2, strokeColor);
}
}
void Adafruit_GFX::rect(int16_t x, int16_t y, int16_t width, int16_t height)
{
if (useFill) {
fillRect(x, y, width, height, fillColor);
}
if (useStroke) {
drawRect(x, y, width, height, strokeColor);
}
}
void Adafruit_GFX::rect(int16_t x, int16_t y, int16_t width, int16_t height, int16_t radius)
{
if (radius == 0) {
rect(x, y, width, height);
}
if (useFill) {
fillRoundRect(x, y, width, height, radius, fillColor);
}
if (useStroke) {
drawRoundRect(x, y, width, height, radius, strokeColor);
}
}
void Adafruit_GFX::circle(int16_t x, int16_t y, int16_t r)
{
if (r == 0)
return;
if (useFill) {
fillCircle(x, y, r, fillColor);
}
if (useStroke) {
drawCircle(x, y, r, strokeColor);
}
}
void Adafruit_GFX::triangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3)
{
if (useFill) {
fillTriangle(x1, y1, x2, y2, x3, y3, fillColor);
}
if (useStroke) {
drawTriangle(x1, y1, x2, y2, x3, y3, strokeColor);
}
}
/***************************************************************************/
// code for the GFX button UI element
Adafruit_GFX_Button::Adafruit_GFX_Button(void) {
_gfx = 0;
}
void Adafruit_GFX_Button::initButton(
Adafruit_GFX *gfx, int16_t x, int16_t y, uint8_t w, uint8_t h,
uint16_t outline, uint16_t fill, uint16_t textcolor,
char *label, uint8_t textsize)
{
_x = x;
_y = y;
_w = w;
_h = h;
_outlinecolor = outline;
_fillcolor = fill;
_textcolor = textcolor;
_textsize = textsize;
_gfx = gfx;
strncpy(_label, label, 9);
_label[9] = 0;
}
void Adafruit_GFX_Button::drawButton(boolean inverted) {
uint16_t fill, outline, text;
if(!inverted) {
fill = _fillcolor;
outline = _outlinecolor;
text = _textcolor;
} else {
fill = _textcolor;
outline = _outlinecolor;
text = _fillcolor;
}
_gfx->fillRoundRect(_x - (_w/2), _y - (_h/2), _w, _h, min(_w,_h)/4, fill);
_gfx->drawRoundRect(_x - (_w/2), _y - (_h/2), _w, _h, min(_w,_h)/4, outline);
_gfx->setCursor(_x - strlen(_label)*3*_textsize, _y-4*_textsize);
_gfx->setTextColor(text);
_gfx->setTextSize(_textsize);
_gfx->print(_label);
}
boolean Adafruit_GFX_Button::contains(int16_t x, int16_t y) {
if ((x < (_x - _w/2)) || (x > (_x + _w/2))) return false;
if ((y < (_y - _h/2)) || (y > (_y + _h/2))) return false;
return true;
}
void Adafruit_GFX_Button::press(boolean p) {
laststate = currstate;
currstate = p;
}
boolean Adafruit_GFX_Button::isPressed() { return currstate; }
boolean Adafruit_GFX_Button::justPressed() { return (currstate && !laststate); }
boolean Adafruit_GFX_Button::justReleased() { return (!currstate && laststate); }
// -------------------------------------------------------------------------
// GFXcanvas1 and GFXcanvas16 (currently a WIP, don't get too comfy with the
// implementation) provide 1- and 16-bit offscreen canvases, the address of
// which can be passed to drawBitmap() or pushColors() (the latter appears
// to only be in Adafruit_TFTLCD at this time). This is here mostly to
// help with the recently-added proportionally-spaced fonts; adds a way to
// refresh a section of the screen without a massive flickering clear-and-
// redraw...but maybe you'll find other uses too. VERY RAM-intensive, since
// the buffer is in MCU memory and not the display driver...GXFcanvas1 might
// be minimally useful on an Uno-class board, but this and GFXcanvas16 are
// much more likely to require at least a Mega or various recent ARM-type
// boards (recomment, as the text+bitmap draw can be pokey). GFXcanvas1
// requires 1 bit per pixel (rounded up to nearest byte per scanline),
// GFXcanvas16 requires 2 bytes per pixel (no scanline pad).
// NOT EXTENSIVELY TESTED YET. MAY CONTAIN WORST BUGS KNOWN TO HUMANKIND.
GFXcanvas1::GFXcanvas1(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) {
uint16_t bytes = ((w + 7) / 8) * h;
if((buffer = (uint8_t *)malloc(bytes))) {
memset(buffer, 0, bytes);
}
}
GFXcanvas1::~GFXcanvas1(void) {
if(buffer) free(buffer);
}
uint8_t* GFXcanvas1::getBuffer(void) {
return buffer;
}
void GFXcanvas1::drawPixel(int16_t x, int16_t y, uint16_t color) {
// Bitmask tables of 0x80>>X and ~(0x80>>X), because X>>Y is slow on AVR
static const uint8_t PROGMEM
GFXsetBit[] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 },
GFXclrBit[] = { 0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0xFE };
if(buffer) {
if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return;
int16_t t;
switch(rotation) {
case 1:
t = x;
x = WIDTH - 1 - y;
y = t;
break;
case 2:
x = WIDTH - 1 - x;
y = HEIGHT - 1 - y;
break;
case 3:
t = x;
x = y;
y = HEIGHT - 1 - t;
break;
}
uint8_t *ptr = &buffer[(x / 8) + y * ((WIDTH + 7) / 8)];
if(color) *ptr |= pgm_read_byte(&GFXsetBit[x & 7]);
else *ptr &= pgm_read_byte(&GFXclrBit[x & 7]);
}
}
void GFXcanvas1::fillScreen(uint16_t color) {
if(buffer) {
uint16_t bytes = ((WIDTH + 7) / 8) * HEIGHT;
memset(buffer, color ? 0xFF : 0x00, bytes);
}
}
GFXcanvas16::GFXcanvas16(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) {
uint16_t bytes = w * h * 2;
if((buffer = (uint16_t *)malloc(bytes))) {
memset(buffer, 0, bytes);
}
}
GFXcanvas16::~GFXcanvas16(void) {
if(buffer) free(buffer);
}
uint16_t* GFXcanvas16::getBuffer(void) {
return buffer;
}
void GFXcanvas16::drawPixel(int16_t x, int16_t y, uint16_t color) {
if(buffer) {
if((x < 0) || (y < 0) || (x >= _width) || (y >= _height)) return;
int16_t t;
switch(rotation) {
case 1:
t = x;
x = WIDTH - 1 - y;
y = t;
break;
case 2:
x = WIDTH - 1 - x;
y = HEIGHT - 1 - y;
break;
case 3:
t = x;
x = y;
y = HEIGHT - 1 - t;
break;
}
buffer[x + y * WIDTH] = color;
}
}
void GFXcanvas16::fillScreen(uint16_t color) {
if(buffer) {
uint8_t hi = color >> 8, lo = color & 0xFF;
if(hi == lo) {
memset(buffer, lo, WIDTH * HEIGHT * 2);
} else {
uint16_t i, pixels = WIDTH * HEIGHT;
for(i=0; i<pixels; i++) buffer[i] = color;
}
}
}
#ifndef _ADAFRUIT_GFX_H
#define _ADAFRUIT_GFX_H
#if ARDUINO >= 100
#include "Arduino.h"
#include "Print.h"
#else
#include "WProgram.h"
#endif
#include "gfxfont.h"
#define swap(a, b) { int16_t t = a; a = b; b = t; }
/* TODO
enum RectMode {
CORNER,
CORNERS,
RADIUS,
CENTER
};
*/
typedef uint16_t color;
class Adafruit_GFX : public Print {
public:
Adafruit_GFX(int16_t w, int16_t h); // Constructor
// This MUST be defined by the subclass:
virtual void drawPixel(int16_t x, int16_t y, uint16_t color) = 0;
// These MAY be overridden by the subclass to provide device-specific
// optimized code. Otherwise 'generic' versions are used.
virtual void
drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color),
drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color),
drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color),
drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color),
fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color),
fillScreen(uint16_t color),
invertDisplay(boolean i);
// These exist only with Adafruit_GFX (no subclass overrides)
void
drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color),
drawCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername,
uint16_t color),
fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color),
fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername,
int16_t delta, uint16_t color),
drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
int16_t x2, int16_t y2, uint16_t color),
fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1,
int16_t x2, int16_t y2, uint16_t color),
drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h,
int16_t radius, uint16_t color),
fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h,
int16_t radius, uint16_t color),
drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap,
int16_t w, int16_t h, uint16_t color),
//drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, //DUHJOKER
// int16_t w, int16_t h, uint16_t color, uint16_t bg), //DUHJOKER
//drawBitmap(int16_t x, int16_t y, uint8_t *bitmap,
//int16_t w, int16_t h, uint16_t color),
//drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, //DUHJOKER
//int16_t w, int16_t h, uint16_t color, uint16_t bg), //DUHJOKER
drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap,
int16_t w, int16_t h, uint16_t color),
drawTilemap(int x, int y, const uint8_t *tilemap, const uint8_t **spritesheet),
drawTilemap(int x, int y, const uint8_t *tilemap, const uint8_t **spritesheet, uint8_t dx, uint8_t dy, uint8_t dw, uint8_t dh),
drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color,
uint16_t bg, uint8_t size),
setCursor(int16_t x, int16_t y),
setTextColor(uint16_t c),
setTextColor(uint16_t c, uint16_t bg),
setTextSize(uint8_t s),
setTextWrap(boolean w),
setRotation(uint8_t r),
cp437(boolean x=true),
setFont(const GFXfont *f = NULL),
getTextBounds(char *string, int16_t x, int16_t y,
int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h),
getTextBounds(const __FlashStringHelper *s, int16_t x, int16_t y,
int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h);
#if ARDUINO >= 100
virtual size_t write(uint8_t);
#else
virtual void write(uint8_t);
#endif
// boolean persistence; //disable clean() at each frame if true
// boolean textWrap; // If set, 'wrap' text at right edge of
// uint8_t fontSize;
// int8_t cursorX, cursorY;
// byte contrast;
// byte frameCount;
//typedef struct { //line 171 "Public Variables - ADD by Summoner123
// int x; //X coordinate - ADD by Summoner123
// int y; //Y coordinate - ADD by Summoner123
// const byte *spritecol; //Sprite of object - ADD by Summoner123
// }object;
// object solid[60]; // Matriz were saved a Sprite, X and Y cordinates of all tiles on the screen - ADD by Summoner123
// byte numcolision = 0; //count of solid objects indacat how many tiles drawed on the screen - ADD by Summoner123
// bool flagcollision = true;
int16_t height(void);
int16_t width(void);
uint8_t getRotation(void);
// get current cursor position (get rotation safe maximum values, using: width() for x, height() for y)
int16_t getCursorX(void);
int16_t getCursorY(void);
/*
* Processing-like graphics primitives
*/
/// transforms a color in 16-bit form given the RGB components.
/// The default implementation makes a 5-bit red, a 6-bit
/// green and a 5-bit blue (MSB to LSB). Devices that use
/// different scheme should override this.
virtual uint16_t newColor(uint8_t red, uint8_t green, uint8_t blue);
void
// http://processing.org/reference/background_.html
background(uint8_t red, uint8_t green, uint8_t blue),
background(color c),
// http://processing.org/reference/fill_.html
fill(uint8_t red, uint8_t green, uint8_t blue),
fill(color c),
// http://processing.org/reference/noFill_.html
noFill(),
// http://processing.org/reference/stroke_.html
stroke(uint8_t red, uint8_t green, uint8_t blue),
stroke(color c),
// http://processing.org/reference/noStroke_.html
noStroke(),
text(const char * text, int16_t x, int16_t y),
textWrap(const char * text, int16_t x, int16_t y),
textSize(uint8_t size),
// similar to ellipse() in Processing, but with
// a single radius.
// http://processing.org/reference/ellipse_.html
circle(int16_t x, int16_t y, int16_t r),
point(int16_t x, int16_t y),
line(int16_t x1, int16_t y1, int16_t x2, int16_t y2),
quad(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3, int16_t x4, int16_t y4),
rect(int16_t x, int16_t y, int16_t width, int16_t height),
rect(int16_t x, int16_t y, int16_t width, int16_t height, int16_t radius),
triangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3);
/* TODO
void rectMode(RectMode mode);
void pushStyle();
void popStyle();
*/
protected:
const int16_t
WIDTH, HEIGHT; // This is the 'raw' display w/h - never changes
int16_t
_width, _height, // Display w/h as modified by current rotation
cursor_x, cursor_y;
uint16_t
textcolor, textbgcolor;
uint8_t
textsize,
rotation;
boolean
wrap, // If set, 'wrap' text at right edge of display
_cp437; // If set, use correct CP437 charset (default is off)
GFXfont
*gfxFont;
/*
* Processing-style graphics state
*/
color strokeColor;
bool useStroke;
color fillColor;
bool useFill;
boolean persistence; //disable clean() at each frame if true
//boolean textWrap; // If set, 'wrap' text at right edge of
uint8_t fontSize;
int8_t cursorX, cursorY;
byte contrast;
byte frameCount;
typedef struct { //line 171 "Public Variables - ADD by Summoner123
int x; //X coordinate - ADD by Summoner123
int y; //Y coordinate - ADD by Summoner123
const byte *spritecol; //Sprite of object - ADD by Summoner123
}object;
object solid[60]; // Matriz were saved a Sprite, X and Y cordinates of all tiles on the screen - ADD by Summoner123
byte numcolision = 0; //count of solid objects indacat how many tiles drawed on the screen - ADD by Summoner123
bool flagcollision = true;
private:
int8_t sclk, din, dc, cs, rst;
volatile uint8_t *mosiport, *clkport, *csport, *dcport;
uint8_t mosipinmask, clkpinmask, cspinmask, dcpinmask;
//uint8_t *font;
//uint8_t color, bgcolor;
};
class Adafruit_GFX_Button {
public:
Adafruit_GFX_Button(void);
void initButton(Adafruit_GFX *gfx, int16_t x, int16_t y,
uint8_t w, uint8_t h, uint16_t outline, uint16_t fill,
uint16_t textcolor, char *label, uint8_t textsize);
void drawButton(boolean inverted = false);
boolean contains(int16_t x, int16_t y);
void press(boolean p);
boolean isPressed();
boolean justPressed();
boolean justReleased();
private:
Adafruit_GFX *_gfx;
int16_t _x, _y;
uint16_t _w, _h;
uint8_t _textsize;
uint16_t _outlinecolor, _fillcolor, _textcolor;
char _label[10];
boolean currstate, laststate;
};
class GFXcanvas1 : public Adafruit_GFX {
public:
GFXcanvas1(uint16_t w, uint16_t h);
~GFXcanvas1(void);
void drawPixel(int16_t x, int16_t y, uint16_t color),
fillScreen(uint16_t color);
uint8_t *getBuffer(void);
private:
uint8_t *buffer;
};
class GFXcanvas16 : public Adafruit_GFX {
GFXcanvas16(uint16_t w, uint16_t h);
~GFXcanvas16(void);
void drawPixel(int16_t x, int16_t y, uint16_t color),
fillScreen(uint16_t color);
uint16_t *getBuffer(void);
private:
uint16_t *buffer;
};
#endif // _ADAFRUIT_GFX_H
Fri Sep 30, 2016 9:13 am
#include <LCD_2000_7775.h>
// pin definition for the Uno
#define cs 11
#define wr 10
#define rs 12
//#define le 13
#define D0 9
#define D1 8
#define D2 7
#define D3 6
#define D4 5
#define D5 4
#define D6 3
#define D7 2
// pin definition for the Leonardo
// #define cs 7
// #define dc 0
// #define rst 1
// create an instance of the library
//LCD_2000_7775 TFTscreen(cs,wr,rs,le);
LCD_2000_7775 TFTscreen(cs,wr,rs);
// char array to print to the screen
char sensorPrintout[4];
void setup() {
// Put this line at the beginning of every sketch that uses the GLCD:
TFTscreen.setdatapin(D0,D1,D2,D3,D4,D5,D6,D7);
TFTscreen.begin();
// clear the screen with a black background
TFTscreen.background(0, 0, 0);
// write the static text to the screen
// set the font color to white
TFTscreen.stroke(255,255,255);
// set the font size
TFTscreen.setTextSize(2);
// write the text to the top left corner of the screen
TFTscreen.text("Sensor Value :\n ",0,0);
// ste the font size very large for the loop
TFTscreen.setTextSize(5);
}
void loop() {
// Read the value of the sensor on A0
String sensorVal = String(analogRead(A0));
// convert the reading to a char array
sensorVal.toCharArray(sensorPrintout, 4);
// set the font color
TFTscreen.stroke(255,255,255);
// print the sensor value
TFTscreen.text(sensorPrintout, 0, 20);
// wait for a moment
delay(250);
// erase the text you just wrote
TFTscreen.stroke(0,0,0);
TFTscreen.text(sensorPrintout, 0, 20);
}
#include "LCD_2000_7775.h"
LCD_2000_7775::LCD_2000_7775(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest ,uint8_t pmw)
: Adafruit_GFX(176, 220)
{
this->_cs = cs;
//this->_rd = rd;
this->_wr = wr;
this->_rs = rs;
this->_rest = rest;
this->_pmw = pmw;
pinMode(this->_cs,OUTPUT);
//pinMode(this->_rd,OUTPUT);
pinMode(this->_wr,OUTPUT);
pinMode(this->_rs,OUTPUT);
pinMode(this->_rest,OUTPUT);
pinMode(this->_pmw,OUTPUT);
this->csport = portOutputRegister(digitalPinToPort(this->_cs));
//this->pmwport = portOutputRegister(digitalPinToPort(this->_pmw));
this->wrport = portOutputRegister(digitalPinToPort(this->_wr));
this->rsport = portOutputRegister(digitalPinToPort(this->_rs));
this->restport = portOutputRegister(digitalPinToPort(this->_rest));
this->cspinmask = digitalPinToBitMask(this->_cs);
//this->pmwpinmask = digitalPinToBitMask(this->_pmw);
this->wrpinmask = digitalPinToBitMask(this->_wr);
this->rspinmask = digitalPinToBitMask(this->_rs);
this->restpinmask = digitalPinToBitMask(this->_rest);
*(this->csport) |= this->cspinmask;
//*(this->pmwport) |= this->pmwpinmask;
*(this->wrport) |= this->wrpinmask;
*(this->rsport) |= this->rspinmask;
*(this->restport) |= this->restpinmask;
}
LCD_2000_7775::LCD_2000_7775(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest )
: Adafruit_GFX(176, 220)
{
this->_cs = cs;
//this->_rd = rd;
this->_wr = wr;
this->_rs = rs;
this->_rest = rest;
pinMode(this->_cs,OUTPUT);
//pinMode(this->_rd,OUTPUT);
pinMode(this->_wr,OUTPUT);
pinMode(this->_rs,OUTPUT);
pinMode(this->_rest,OUTPUT);
this->csport = portOutputRegister(digitalPinToPort(this->_cs));
this->wrport = portOutputRegister(digitalPinToPort(this->_wr));
this->rsport = portOutputRegister(digitalPinToPort(this->_rs));
this->restport = portOutputRegister(digitalPinToPort(this->_rest));
this->cspinmask = digitalPinToBitMask(this->_cs);
this->wrpinmask = digitalPinToBitMask(this->_wr);
this->rspinmask = digitalPinToBitMask(this->_rs);
this->restpinmask = digitalPinToBitMask(this->_rest);
*(this->csport) |= this->cspinmask;
*(this->wrport) |= this->wrpinmask;
*(this->rsport) |= this->rspinmask;
*(this->restport) |= this->restpinmask;
}
LCD_2000_7775::LCD_2000_7775(uint8_t cs,uint8_t wr ,uint8_t rs)
: Adafruit_GFX(176, 220)
{
this->_cs = cs;
this->_wr = wr;
this->_rs = rs;
this->_rest = 0;
pinMode(this->_cs,OUTPUT);
pinMode(this->_wr,OUTPUT);
pinMode(this->_rs,OUTPUT);
this->csport = portOutputRegister(digitalPinToPort(this->_cs));
this->wrport = portOutputRegister(digitalPinToPort(this->_wr));
this->rsport = portOutputRegister(digitalPinToPort(this->_rs));
this->cspinmask = digitalPinToBitMask(this->_cs);
this->wrpinmask = digitalPinToBitMask(this->_wr);
this->rspinmask = digitalPinToBitMask(this->_rs);
*(this->csport) |= this->cspinmask;
*(this->wrport) |= this->wrpinmask;
*(this->rsport) |= this->rspinmask;
}
#if 0 //defined(ARDUINO_ARCH_SAM)
void LCD_2000_7775::write_delay()
{
volatile uint32_t delaycnt = 10;
while( delaycnt-- );
}
#endif
void LCD_2000_7775::write_spi(const uint8_t data)
{
uint8_t bit,i;
for(bit = 0x01,i = 0 ; bit ; i++,bit <<= 1)
{
if(data & bit) *(this->dataport[i]) |= this->datapinmask[i];
else *(this->dataport[i]) &= (~this->datapinmask[i]);
//write_delay();
}
}
void LCD_2000_7775::setdatapin(uint8_t b0,uint8_t b1, uint8_t b2 , uint8_t b3,
uint8_t b4, uint8_t b5, uint8_t b6, uint8_t b7)
{
uint8_t i;
this->data[0] = b0;
this->data[1] = b1;
this->data[2] = b2;
this->data[3] = b3;
this->data[4] = b4;
this->data[5] = b5;
this->data[6] = b6;
this->data[7] = b7;
for(i = 0; i < 8 ;i++)
pinMode(this->data[i],OUTPUT);
for(i = 0; i < 8 ;i++)
dataport[i] = portOutputRegister(digitalPinToPort(this->data[i]));
for(i = 0; i < 8 ;i++)
datapinmask[i] = digitalPinToBitMask(this->data[i]);
this->setbracklight(255);
}
void LCD_2000_7775::write_wr_reg(uint16_t data)
{
*(this->rsport) &= (~this->rspinmask);
write_delay();
*(this->csport) &= (~this->cspinmask);
write_delay();
this->write_spi( data >> 8 );
write_delay();
*(this->wrport) &= (~this->wrpinmask);
write_delay();
*(this->wrport) |= this->wrpinmask;
write_delay();
this->write_spi( (data&0x00ff) );
write_delay();
*(this->wrport) &= (~this->wrpinmask);
write_delay();
*(this->wrport) |= this->wrpinmask;
write_delay();
*(this->csport) |= this->cspinmask;
write_delay();
}
void LCD_2000_7775::write_wr_data(uint16_t data)
{
*(this->rsport) |= this->rspinmask;
write_delay();
*(this->csport) &= (~this->cspinmask);
write_delay();
this->write_spi( data >> 8 );
write_delay();
*(this->wrport) &= (~this->wrpinmask);
write_delay();
*(this->wrport) |= this->wrpinmask;
write_delay();
this->write_spi( (data&0x00ff) );
write_delay();
*(this->wrport) &= (~this->wrpinmask);
write_delay();
*(this->wrport) |= this->wrpinmask;
write_delay();
*(this->csport) |= this->cspinmask;
write_delay();
}
void LCD_2000_7775::write_cmd(uint16_t cmd ,uint16_t data)
{
this->write_wr_reg(cmd);
this->write_wr_data(data);
}
void LCD_2000_7775::set_window(uint8_t x1,uint8_t y1,uint8_t x2,uint8_t y2)
{
this->write_wr_reg(0x0037);this->write_wr_data(x1); // windows address
this->write_wr_reg(0x0036);this->write_wr_data(x2);
this->write_wr_reg(0x0039);this->write_wr_data(y1);
this->write_wr_reg(0x0038);this->write_wr_data(y2);
this->write_wr_reg(0x0020); //HS
this->write_wr_data(x1);
this->write_wr_reg(0x0021); //VS
this->write_wr_data(y1);
}
void LCD_2000_7775::drawPixel(int16_t x, int16_t y, uint16_t color)
{
set_window(x,y,x,y);
//this->write_wr_reg(0x0022);
//this->write_wr_data(color);
this->write_cmd(0x22,color);
}
void LCD_2000_7775::fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color)
{
set_window(x,y,x+w-1,y+h-1);
this->write_wr_reg(0x22);
int i = w*h;
while(i--)
this->write_wr_data(color);
}
void LCD_2000_7775::setbracklight(uint8_t pmw)
{
analogWrite(this->_pmw,pmw);
}
void LCD_2000_7775::drawbitmap(uint16_t* data, uint16_t x ,uint16_t y,uint16_t with , uint16_t height)
{
uint32_t i;
this->set_window(x,y,x+with-1,y+height-1);
this->write_wr_reg(0x22);
i = with * height;
while(i--)
{
this->write_wr_data(*data);
data++;
}
}
void LCD_2000_7775::begin()
{
if( this->_rest )
{
*(this->restport) &= (~this->restpinmask);
delay(50); // Delay 50ms
*(this->restport) |= this->restpinmask;
delay(10); // Delay 10ms
}
this->write_cmd(0x0001, 0x011C); // set SS and NL bit
this->write_cmd(0x0002, 0x0100); // set 1 line inversion
this->write_cmd(0x0003, 0x1030); // set GRAM write direction and BGR=1,??16BIT 65K?MDT1=0,MDT0=0
this->write_cmd(0x0008, 0x0808); // set BP and FP
this->write_cmd(0x000C, 0x0000); // RGB interface setting R0Ch=0x0110 for RGB 18Bit and R0Ch=0111for
this->write_cmd(0x000F, 0x0e01); // Set frame rate
//*************Power On sequence ****************//
delay(50); // Delay 50ms
this->write_cmd(0x0010, 0x0A00); // Set SAP,DSTB,STB
this->write_cmd(0x0011, 0x1038); // Set APON,PON,AON,VCI1EN,VC
//delay(50); // Delay 50ms
this->write_cmd(0x00ff, 0x0003); //
this->write_cmd(0x00b0, 0x1411); //Set VCOM 1d
this->write_cmd(0x00b1, 0x0202); //GVCL/GVDD voltage setting
this->write_cmd(0x00b2, 0x0313); //VCL voltage setting
//------------------------ Set GRAM area set window --------------------------------//
this->write_cmd (0x0030, 0x0000);//???????
this->write_cmd (0x0031, 0x00db);
this->write_cmd (0x0032, 0x0000);
this->write_cmd (0x0033, 0x0000);//??????
this->write_cmd (0x0034, 0x00db);
this->write_cmd (0x0035, 0x0000);//R34H,R35H???????
this->write_cmd (0x0036, 0x00AF);
this->write_cmd (0x0037, 0x0000);
this->write_cmd (0x0038, 0x00DB);
this->write_cmd (0x0039, 0x0000);
delay(20);
this->write_cmd(0x00ff, 0x0003);
// WriteRegister(0x00b0, 0x1d01);
// ----------- Adjust the Gamma Curve ----------//
this->write_cmd(0x0050, 0x0000);
this->write_cmd(0x0051, 0x0300);
this->write_cmd(0x0052, 0x0103);
this->write_cmd(0x0053, 0x2011);
this->write_cmd(0x0054, 0x0703);
this->write_cmd(0x0055, 0x0000);
this->write_cmd(0x0056, 0x0400);
this->write_cmd(0x0057, 0x0107);
this->write_cmd(0x0058, 0x2011);
this->write_cmd(0x0059, 0x0703);
delay(50); // Delay 50ms
this->write_cmd(0x0020, 0x0000); // Set GRAM Address
this->write_cmd(0x0021, 0x0000); // Set GRAM Address
this->write_cmd(0x0007, 0x1017);
this->fillRect(0,0,LCD_2000_7775_TFTWIDTH,LCD_2000_7775_TFTHEIGHT,0xffff);
}
/*********************************º¯Êý******************************/
uint16_t RGB(uint16_t r,uint16_t g , uint16_t b)
{
uint16_t rgb = 0;
r *= 31;
r /= 255;
g *= 63;
g /= 255;
b *= 31;
b /= 255;
rgb |= (r<<11);
rgb |= (g<<6);
rgb |= b;
return rgb;
}
#ifndef LCD_2000_7775_H
#define LCD_2000_7775_H
#if ARDUINO >= 100
#include "Arduino.h"
#include "Print.h"
#else
#include "WProgram.h"
#endif
#include "utility/Adafruit_GFX.h"
#include <avr/pgmspace.h>
#define LCD_2000_7775_TFTWIDTH 176
#define LCD_2000_7775_TFTHEIGHT 220
class LCD_2000_7775 : public Adafruit_GFX
{
public:
LCD_2000_7775(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest ,uint8_t pmw );
LCD_2000_7775(uint8_t cs,uint8_t wr ,uint8_t rs , uint8_t rest );
LCD_2000_7775(uint8_t cs,uint8_t wr ,uint8_t rs );
//LCD_2000_7775(){};
void write_spi(const uint8_t data);
void drawPixel(int16_t x, int16_t y, uint16_t color);
void setdatapin(uint8_t b0,uint8_t b1, uint8_t b2 , uint8_t b3,
uint8_t b4, uint8_t b5, uint8_t b6, uint8_t b7);
void fillRect(int16_t x, int16_t y, int16_t w, int16_t h,
uint16_t color);
void setbracklight(uint8_t pmw);
void begin();
void drawbitmap(uint16_t* data, uint16_t x ,uint16_t y,uint16_t with , uint16_t height);
//fuction
private:
void set_window(uint8_t x1,uint8_t y1,uint8_t x2,uint8_t y2);
void write_wr_reg(uint16_t data);
void write_wr_data(uint16_t data);
void write_cmd(uint16_t cmd ,uint16_t data);
#if 0 //defined(ARDUINO_ARCH_SAM)
void write_delay();
#else
#define write_delay()
#endif
//value
//private:
#if defined(ARDUINO_ARCH_SAM)
uint32_t _cs;
uint32_t _pmw;
uint32_t _wr;
uint32_t _rs;
uint32_t _rest;
volatile uint32_t *csport;
volatile uint32_t *pmwport;
volatile uint32_t *wrport;
volatile uint32_t *rsport;
volatile uint32_t *restport;
uint32_t cspinmask;
uint32_t pmwpinmask;
uint32_t wrpinmask;
uint32_t rspinmask;
uint32_t restpinmask;
volatile uint32_t data[8];
volatile uint32_t datapinmask[8];
volatile uint32_t* dataport[8];
#else
uint8_t _cs;
uint8_t _pmw;
uint8_t _wr;
uint8_t _rs;
uint8_t _rest;
volatile uint8_t *csport;
volatile uint8_t *pmwport;
volatile uint8_t *wrport;
volatile uint8_t *rsport;
volatile uint8_t *restport;
uint8_t cspinmask;
uint8_t pmwpinmask;
uint8_t wrpinmask;
uint8_t rspinmask;
uint8_t restpinmask;
volatile uint8_t data[8];
volatile uint8_t datapinmask[8];
volatile uint8_t* dataport[8];
#endif
};
uint16_t RGB(uint16_t r,uint16_t g , uint16_t b);
#endif