You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2669 lines
91 KiB
2669 lines
91 KiB
/* |
|
This is the core graphics library for all our displays, providing a common |
|
set of graphics primitives (points, lines, circles, etc.). It needs to be |
|
paired with a hardware-specific library for each display device we carry |
|
(to handle the lower-level functions). |
|
|
|
Adafruit invests time and resources providing this open source code, please |
|
support Adafruit & open-source hardware by purchasing products from Adafruit! |
|
|
|
Copyright (c) 2013 Adafruit Industries. All rights reserved. |
|
|
|
Redistribution and use in source and binary forms, with or without |
|
modification, are permitted provided that the following conditions are met: |
|
|
|
- Redistributions of source code must retain the above copyright notice, |
|
this list of conditions and the following disclaimer. |
|
- Redistributions in binary form must reproduce the above copyright notice, |
|
this list of conditions and the following disclaimer in the documentation |
|
and/or other materials provided with the distribution. |
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
|
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE |
|
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
|
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
|
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
|
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
|
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
|
POSSIBILITY OF SUCH DAMAGE. |
|
*/ |
|
|
|
#include "Adafruit_GFX.h" |
|
#include "glcdfont.c" |
|
#ifdef __AVR__ |
|
#include <avr/pgmspace.h> |
|
#elif defined(ESP8266) || defined(ESP32) |
|
#include <pgmspace.h> |
|
#endif |
|
|
|
// 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 |
|
|
|
inline GFXglyph *pgm_read_glyph_ptr(const GFXfont *gfxFont, uint8_t c) { |
|
#ifdef __AVR__ |
|
return &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]); |
|
#else |
|
// expression in __AVR__ section may generate "dereferencing type-punned |
|
// pointer will break strict-aliasing rules" warning In fact, on other |
|
// platforms (such as STM32) there is no need to do this pointer magic as |
|
// program memory may be read in a usual way So expression may be simplified |
|
return gfxFont->glyph + c; |
|
#endif //__AVR__ |
|
} |
|
|
|
inline uint8_t *pgm_read_bitmap_ptr(const GFXfont *gfxFont) { |
|
#ifdef __AVR__ |
|
return (uint8_t *)pgm_read_pointer(&gfxFont->bitmap); |
|
#else |
|
// expression in __AVR__ section generates "dereferencing type-punned pointer |
|
// will break strict-aliasing rules" warning In fact, on other platforms (such |
|
// as STM32) there is no need to do this pointer magic as program memory may |
|
// be read in a usual way So expression may be simplified |
|
return gfxFont->bitmap; |
|
#endif //__AVR__ |
|
} |
|
|
|
#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 |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Instatiate a GFX context for graphics! Can only be done by a |
|
superclass |
|
@param w Display width, in pixels |
|
@param h Display height, in pixels |
|
*/ |
|
/**************************************************************************/ |
|
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_x = textsize_y = 1; |
|
textcolor = textbgcolor = 0xFFFF; |
|
wrap = true; |
|
_cp437 = false; |
|
gfxFont = NULL; |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Write a line. Bresenham's algorithm - thx wikpedia |
|
@param x0 Start point x coordinate |
|
@param y0 Start point y coordinate |
|
@param x1 End point x coordinate |
|
@param y1 End point y coordinate |
|
@param color 16-bit 5-6-5 Color to draw with |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::writeLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, |
|
uint16_t color) { |
|
#if defined(ESP8266) |
|
yield(); |
|
#endif |
|
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) { |
|
writePixel(y0, x0, color); |
|
} else { |
|
writePixel(x0, y0, color); |
|
} |
|
err -= dy; |
|
if (err < 0) { |
|
y0 += ystep; |
|
err += dx; |
|
} |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Start a display-writing routine, overwrite in subclasses. |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::startWrite() {} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Write a pixel, overwrite in subclasses if startWrite is defined! |
|
@param x x coordinate |
|
@param y y coordinate |
|
@param color 16-bit 5-6-5 Color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::writePixel(int16_t x, int16_t y, uint16_t color) { |
|
drawPixel(x, y, color); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Write a perfectly vertical line, overwrite in subclasses if |
|
startWrite is defined! |
|
@param x Top-most x coordinate |
|
@param y Top-most y coordinate |
|
@param h Height in pixels |
|
@param color 16-bit 5-6-5 Color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::writeFastVLine(int16_t x, int16_t y, int16_t h, |
|
uint16_t color) { |
|
// Overwrite in subclasses if startWrite is defined! |
|
// Can be just writeLine(x, y, x, y+h-1, color); |
|
// or writeFillRect(x, y, 1, h, color); |
|
drawFastVLine(x, y, h, color); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Write a perfectly horizontal line, overwrite in subclasses if |
|
startWrite is defined! |
|
@param x Left-most x coordinate |
|
@param y Left-most y coordinate |
|
@param w Width in pixels |
|
@param color 16-bit 5-6-5 Color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::writeFastHLine(int16_t x, int16_t y, int16_t w, |
|
uint16_t color) { |
|
// Overwrite in subclasses if startWrite is defined! |
|
// Example: writeLine(x, y, x+w-1, y, color); |
|
// or writeFillRect(x, y, w, 1, color); |
|
drawFastHLine(x, y, w, color); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Write a rectangle completely with one color, overwrite in |
|
subclasses if startWrite is defined! |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param w Width in pixels |
|
@param h Height in pixels |
|
@param color 16-bit 5-6-5 Color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::writeFillRect(int16_t x, int16_t y, int16_t w, int16_t h, |
|
uint16_t color) { |
|
// Overwrite in subclasses if desired! |
|
fillRect(x, y, w, h, color); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief End a display-writing routine, overwrite in subclasses if |
|
startWrite is defined! |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::endWrite() {} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a perfectly vertical line (this is often optimized in a |
|
subclass!) |
|
@param x Top-most x coordinate |
|
@param y Top-most y coordinate |
|
@param h Height in pixels |
|
@param color 16-bit 5-6-5 Color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::drawFastVLine(int16_t x, int16_t y, int16_t h, |
|
uint16_t color) { |
|
startWrite(); |
|
writeLine(x, y, x, y + h - 1, color); |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a perfectly horizontal line (this is often optimized in a |
|
subclass!) |
|
@param x Left-most x coordinate |
|
@param y Left-most y coordinate |
|
@param w Width in pixels |
|
@param color 16-bit 5-6-5 Color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::drawFastHLine(int16_t x, int16_t y, int16_t w, |
|
uint16_t color) { |
|
startWrite(); |
|
writeLine(x, y, x + w - 1, y, color); |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Fill a rectangle completely with one color. Update in subclasses if |
|
desired! |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param w Width in pixels |
|
@param h Height in pixels |
|
@param color 16-bit 5-6-5 Color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::fillRect(int16_t x, int16_t y, int16_t w, int16_t h, |
|
uint16_t color) { |
|
startWrite(); |
|
for (int16_t i = x; i < x + w; i++) { |
|
writeFastVLine(i, y, h, color); |
|
} |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Fill the screen completely with one color. Update in subclasses if |
|
desired! |
|
@param color 16-bit 5-6-5 Color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::fillScreen(uint16_t color) { |
|
fillRect(0, 0, _width, _height, color); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a line |
|
@param x0 Start point x coordinate |
|
@param y0 Start point y coordinate |
|
@param x1 End point x coordinate |
|
@param y1 End point y coordinate |
|
@param color 16-bit 5-6-5 Color to draw with |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, |
|
uint16_t color) { |
|
// Update in subclasses if desired! |
|
if (x0 == x1) { |
|
if (y0 > y1) |
|
_swap_int16_t(y0, y1); |
|
drawFastVLine(x0, y0, y1 - y0 + 1, color); |
|
} else if (y0 == y1) { |
|
if (x0 > x1) |
|
_swap_int16_t(x0, x1); |
|
drawFastHLine(x0, y0, x1 - x0 + 1, color); |
|
} else { |
|
startWrite(); |
|
writeLine(x0, y0, x1, y1, color); |
|
endWrite(); |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a circle outline |
|
@param x0 Center-point x coordinate |
|
@param y0 Center-point y coordinate |
|
@param r Radius of circle |
|
@param color 16-bit 5-6-5 Color to draw with |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::drawCircle(int16_t x0, int16_t y0, int16_t r, |
|
uint16_t color) { |
|
#if defined(ESP8266) |
|
yield(); |
|
#endif |
|
int16_t f = 1 - r; |
|
int16_t ddF_x = 1; |
|
int16_t ddF_y = -2 * r; |
|
int16_t x = 0; |
|
int16_t y = r; |
|
|
|
startWrite(); |
|
writePixel(x0, y0 + r, color); |
|
writePixel(x0, y0 - r, color); |
|
writePixel(x0 + r, y0, color); |
|
writePixel(x0 - r, y0, color); |
|
|
|
while (x < y) { |
|
if (f >= 0) { |
|
y--; |
|
ddF_y += 2; |
|
f += ddF_y; |
|
} |
|
x++; |
|
ddF_x += 2; |
|
f += ddF_x; |
|
|
|
writePixel(x0 + x, y0 + y, color); |
|
writePixel(x0 - x, y0 + y, color); |
|
writePixel(x0 + x, y0 - y, color); |
|
writePixel(x0 - x, y0 - y, color); |
|
writePixel(x0 + y, y0 + x, color); |
|
writePixel(x0 - y, y0 + x, color); |
|
writePixel(x0 + y, y0 - x, color); |
|
writePixel(x0 - y, y0 - x, color); |
|
} |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Quarter-circle drawer, used to do circles and roundrects |
|
@param x0 Center-point x coordinate |
|
@param y0 Center-point y coordinate |
|
@param r Radius of circle |
|
@param cornername Mask bit #1 or bit #2 to indicate which quarters of |
|
the circle we're doing |
|
@param color 16-bit 5-6-5 Color to draw with |
|
*/ |
|
/**************************************************************************/ |
|
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) { |
|
writePixel(x0 + x, y0 + y, color); |
|
writePixel(x0 + y, y0 + x, color); |
|
} |
|
if (cornername & 0x2) { |
|
writePixel(x0 + x, y0 - y, color); |
|
writePixel(x0 + y, y0 - x, color); |
|
} |
|
if (cornername & 0x8) { |
|
writePixel(x0 - y, y0 + x, color); |
|
writePixel(x0 - x, y0 + y, color); |
|
} |
|
if (cornername & 0x1) { |
|
writePixel(x0 - y, y0 - x, color); |
|
writePixel(x0 - x, y0 - y, color); |
|
} |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a circle with filled color |
|
@param x0 Center-point x coordinate |
|
@param y0 Center-point y coordinate |
|
@param r Radius of circle |
|
@param color 16-bit 5-6-5 Color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::fillCircle(int16_t x0, int16_t y0, int16_t r, |
|
uint16_t color) { |
|
startWrite(); |
|
writeFastVLine(x0, y0 - r, 2 * r + 1, color); |
|
fillCircleHelper(x0, y0, r, 3, 0, color); |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Quarter-circle drawer with fill, used for circles and roundrects |
|
@param x0 Center-point x coordinate |
|
@param y0 Center-point y coordinate |
|
@param r Radius of circle |
|
@param corners Mask bits indicating which quarters we're doing |
|
@param delta Offset from center-point, used for round-rects |
|
@param color 16-bit 5-6-5 Color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::fillCircleHelper(int16_t x0, int16_t y0, int16_t r, |
|
uint8_t corners, 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; |
|
int16_t px = x; |
|
int16_t py = y; |
|
|
|
delta++; // Avoid some +1's in the loop |
|
|
|
while (x < y) { |
|
if (f >= 0) { |
|
y--; |
|
ddF_y += 2; |
|
f += ddF_y; |
|
} |
|
x++; |
|
ddF_x += 2; |
|
f += ddF_x; |
|
// These checks avoid double-drawing certain lines, important |
|
// for the SSD1306 library which has an INVERT drawing mode. |
|
if (x < (y + 1)) { |
|
if (corners & 1) |
|
writeFastVLine(x0 + x, y0 - y, 2 * y + delta, color); |
|
if (corners & 2) |
|
writeFastVLine(x0 - x, y0 - y, 2 * y + delta, color); |
|
} |
|
if (y != py) { |
|
if (corners & 1) |
|
writeFastVLine(x0 + py, y0 - px, 2 * px + delta, color); |
|
if (corners & 2) |
|
writeFastVLine(x0 - py, y0 - px, 2 * px + delta, color); |
|
py = y; |
|
} |
|
px = x; |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a rectangle with no fill color |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param w Width in pixels |
|
@param h Height in pixels |
|
@param color 16-bit 5-6-5 Color to draw with |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::drawRect(int16_t x, int16_t y, int16_t w, int16_t h, |
|
uint16_t color) { |
|
startWrite(); |
|
writeFastHLine(x, y, w, color); |
|
writeFastHLine(x, y + h - 1, w, color); |
|
writeFastVLine(x, y, h, color); |
|
writeFastVLine(x + w - 1, y, h, color); |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a rounded rectangle with no fill color |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param w Width in pixels |
|
@param h Height in pixels |
|
@param r Radius of corner rounding |
|
@param color 16-bit 5-6-5 Color to draw with |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::drawRoundRect(int16_t x, int16_t y, int16_t w, int16_t h, |
|
int16_t r, uint16_t color) { |
|
int16_t max_radius = ((w < h) ? w : h) / 2; // 1/2 minor axis |
|
if (r > max_radius) |
|
r = max_radius; |
|
// smarter version |
|
startWrite(); |
|
writeFastHLine(x + r, y, w - 2 * r, color); // Top |
|
writeFastHLine(x + r, y + h - 1, w - 2 * r, color); // Bottom |
|
writeFastVLine(x, y + r, h - 2 * r, color); // Left |
|
writeFastVLine(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); |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a rounded rectangle with fill color |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param w Width in pixels |
|
@param h Height in pixels |
|
@param r Radius of corner rounding |
|
@param color 16-bit 5-6-5 Color to draw/fill with |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::fillRoundRect(int16_t x, int16_t y, int16_t w, int16_t h, |
|
int16_t r, uint16_t color) { |
|
int16_t max_radius = ((w < h) ? w : h) / 2; // 1/2 minor axis |
|
if (r > max_radius) |
|
r = max_radius; |
|
// smarter version |
|
startWrite(); |
|
writeFillRect(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); |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a triangle with no fill color |
|
@param x0 Vertex #0 x coordinate |
|
@param y0 Vertex #0 y coordinate |
|
@param x1 Vertex #1 x coordinate |
|
@param y1 Vertex #1 y coordinate |
|
@param x2 Vertex #2 x coordinate |
|
@param y2 Vertex #2 y coordinate |
|
@param color 16-bit 5-6-5 Color to draw with |
|
*/ |
|
/**************************************************************************/ |
|
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); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a triangle with color-fill |
|
@param x0 Vertex #0 x coordinate |
|
@param y0 Vertex #0 y coordinate |
|
@param x1 Vertex #1 x coordinate |
|
@param y1 Vertex #1 y coordinate |
|
@param x2 Vertex #2 x coordinate |
|
@param y2 Vertex #2 y coordinate |
|
@param color 16-bit 5-6-5 Color to fill/draw with |
|
*/ |
|
/**************************************************************************/ |
|
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); |
|
} |
|
|
|
startWrite(); |
|
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; |
|
writeFastHLine(a, y0, b - a + 1, color); |
|
endWrite(); |
|
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); |
|
writeFastHLine(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 = (int32_t)dx12 * (y - y1); |
|
sb = (int32_t)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); |
|
writeFastHLine(a, y, b - a + 1, color); |
|
} |
|
endWrite(); |
|
} |
|
|
|
// BITMAP / XBITMAP / GRAYSCALE / RGB BITMAP FUNCTIONS --------------------- |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a PROGMEM-resident 1-bit image at the specified (x,y) |
|
position, using the specified foreground color (unset bits are transparent). |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param bitmap byte array with monochrome bitmap |
|
@param w Width of bitmap in pixels |
|
@param h Height of bitmap in pixels |
|
@param color 16-bit 5-6-5 Color to draw with |
|
*/ |
|
/**************************************************************************/ |
|
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 byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte |
|
uint8_t b = 0; |
|
|
|
startWrite(); |
|
for (int16_t j = 0; j < h; j++, y++) { |
|
for (int16_t i = 0; i < w; i++) { |
|
if (i & 7) |
|
b <<= 1; |
|
else |
|
b = pgm_read_byte(&bitmap[j * byteWidth + i / 8]); |
|
if (b & 0x80) |
|
writePixel(x + i, y, color); |
|
} |
|
} |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a PROGMEM-resident 1-bit image at the specified (x,y) |
|
position, using the specified foreground (for set bits) and background (unset |
|
bits) colors. |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param bitmap byte array with monochrome bitmap |
|
@param w Width of bitmap in pixels |
|
@param h Height of bitmap in pixels |
|
@param color 16-bit 5-6-5 Color to draw pixels with |
|
@param bg 16-bit 5-6-5 Color to draw background with |
|
*/ |
|
/**************************************************************************/ |
|
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 byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte |
|
uint8_t b = 0; |
|
|
|
startWrite(); |
|
for (int16_t j = 0; j < h; j++, y++) { |
|
for (int16_t i = 0; i < w; i++) { |
|
if (i & 7) |
|
b <<= 1; |
|
else |
|
b = pgm_read_byte(&bitmap[j * byteWidth + i / 8]); |
|
writePixel(x + i, y, (b & 0x80) ? color : bg); |
|
} |
|
} |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a RAM-resident 1-bit image at the specified (x,y) position, |
|
using the specified foreground color (unset bits are transparent). |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param bitmap byte array with monochrome bitmap |
|
@param w Width of bitmap in pixels |
|
@param h Height of bitmap in pixels |
|
@param color 16-bit 5-6-5 Color to draw with |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, |
|
int16_t h, uint16_t color) { |
|
|
|
int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte |
|
uint8_t b = 0; |
|
|
|
startWrite(); |
|
for (int16_t j = 0; j < h; j++, y++) { |
|
for (int16_t i = 0; i < w; i++) { |
|
if (i & 7) |
|
b <<= 1; |
|
else |
|
b = bitmap[j * byteWidth + i / 8]; |
|
if (b & 0x80) |
|
writePixel(x + i, y, color); |
|
} |
|
} |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a RAM-resident 1-bit image at the specified (x,y) position, |
|
using the specified foreground (for set bits) and background (unset bits) |
|
colors. |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param bitmap byte array with monochrome bitmap |
|
@param w Width of bitmap in pixels |
|
@param h Height of bitmap in pixels |
|
@param color 16-bit 5-6-5 Color to draw pixels with |
|
@param bg 16-bit 5-6-5 Color to draw background with |
|
*/ |
|
/**************************************************************************/ |
|
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 byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte |
|
uint8_t b = 0; |
|
|
|
startWrite(); |
|
for (int16_t j = 0; j < h; j++, y++) { |
|
for (int16_t i = 0; i < w; i++) { |
|
if (i & 7) |
|
b <<= 1; |
|
else |
|
b = bitmap[j * byteWidth + i / 8]; |
|
writePixel(x + i, y, (b & 0x80) ? color : bg); |
|
} |
|
} |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw PROGMEM-resident 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. |
|
There is no RAM-resident version of this function; if generating bitmaps |
|
in RAM, use the format defined by drawBitmap() and call that instead. |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param bitmap byte array with monochrome bitmap |
|
@param w Width of bitmap in pixels |
|
@param h Height of bitmap in pixels |
|
@param color 16-bit 5-6-5 Color to draw pixels with |
|
*/ |
|
/**************************************************************************/ |
|
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 byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte |
|
uint8_t b = 0; |
|
|
|
startWrite(); |
|
for (int16_t j = 0; j < h; j++, y++) { |
|
for (int16_t i = 0; i < w; i++) { |
|
if (i & 7) |
|
b >>= 1; |
|
else |
|
b = pgm_read_byte(&bitmap[j * byteWidth + i / 8]); |
|
// Nearly identical to drawBitmap(), only the bit order |
|
// is reversed here (left-to-right = LSB to MSB): |
|
if (b & 0x01) |
|
writePixel(x + i, y, color); |
|
} |
|
} |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a PROGMEM-resident 8-bit image (grayscale) at the specified |
|
(x,y) pos. Specifically for 8-bit display devices such as IS31FL3731; no |
|
color reduction/expansion is performed. |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param bitmap byte array with grayscale bitmap |
|
@param w Width of bitmap in pixels |
|
@param h Height of bitmap in pixels |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y, |
|
const uint8_t bitmap[], int16_t w, |
|
int16_t h) { |
|
startWrite(); |
|
for (int16_t j = 0; j < h; j++, y++) { |
|
for (int16_t i = 0; i < w; i++) { |
|
writePixel(x + i, y, (uint8_t)pgm_read_byte(&bitmap[j * w + i])); |
|
} |
|
} |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a RAM-resident 8-bit image (grayscale) at the specified (x,y) |
|
pos. Specifically for 8-bit display devices such as IS31FL3731; no color |
|
reduction/expansion is performed. |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param bitmap byte array with grayscale bitmap |
|
@param w Width of bitmap in pixels |
|
@param h Height of bitmap in pixels |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y, uint8_t *bitmap, |
|
int16_t w, int16_t h) { |
|
startWrite(); |
|
for (int16_t j = 0; j < h; j++, y++) { |
|
for (int16_t i = 0; i < w; i++) { |
|
writePixel(x + i, y, bitmap[j * w + i]); |
|
} |
|
} |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a PROGMEM-resident 8-bit image (grayscale) with a 1-bit mask |
|
(set bits = opaque, unset bits = clear) at the specified (x,y) position. |
|
BOTH buffers (grayscale and mask) must be PROGMEM-resident. |
|
Specifically for 8-bit display devices such as IS31FL3731; no color |
|
reduction/expansion is performed. |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param bitmap byte array with grayscale bitmap |
|
@param mask byte array with mask bitmap |
|
@param w Width of bitmap in pixels |
|
@param h Height of bitmap in pixels |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y, |
|
const uint8_t bitmap[], |
|
const uint8_t mask[], int16_t w, |
|
int16_t h) { |
|
int16_t bw = (w + 7) / 8; // Bitmask scanline pad = whole byte |
|
uint8_t b = 0; |
|
startWrite(); |
|
for (int16_t j = 0; j < h; j++, y++) { |
|
for (int16_t i = 0; i < w; i++) { |
|
if (i & 7) |
|
b <<= 1; |
|
else |
|
b = pgm_read_byte(&mask[j * bw + i / 8]); |
|
if (b & 0x80) { |
|
writePixel(x + i, y, (uint8_t)pgm_read_byte(&bitmap[j * w + i])); |
|
} |
|
} |
|
} |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a RAM-resident 8-bit image (grayscale) with a 1-bit mask |
|
(set bits = opaque, unset bits = clear) at the specified (x,y) position. |
|
BOTH buffers (grayscale and mask) must be RAM-residentt, no mix-and-match |
|
Specifically for 8-bit display devices such as IS31FL3731; no color |
|
reduction/expansion is performed. |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param bitmap byte array with grayscale bitmap |
|
@param mask byte array with mask bitmap |
|
@param w Width of bitmap in pixels |
|
@param h Height of bitmap in pixels |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::drawGrayscaleBitmap(int16_t x, int16_t y, uint8_t *bitmap, |
|
uint8_t *mask, int16_t w, int16_t h) { |
|
int16_t bw = (w + 7) / 8; // Bitmask scanline pad = whole byte |
|
uint8_t b = 0; |
|
startWrite(); |
|
for (int16_t j = 0; j < h; j++, y++) { |
|
for (int16_t i = 0; i < w; i++) { |
|
if (i & 7) |
|
b <<= 1; |
|
else |
|
b = mask[j * bw + i / 8]; |
|
if (b & 0x80) { |
|
writePixel(x + i, y, bitmap[j * w + i]); |
|
} |
|
} |
|
} |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a PROGMEM-resident 16-bit image (RGB 5/6/5) at the specified |
|
(x,y) position. For 16-bit display devices; no color reduction performed. |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param bitmap byte array with 16-bit color bitmap |
|
@param w Width of bitmap in pixels |
|
@param h Height of bitmap in pixels |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y, const uint16_t bitmap[], |
|
int16_t w, int16_t h) { |
|
startWrite(); |
|
for (int16_t j = 0; j < h; j++, y++) { |
|
for (int16_t i = 0; i < w; i++) { |
|
writePixel(x + i, y, pgm_read_word(&bitmap[j * w + i])); |
|
} |
|
} |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a RAM-resident 16-bit image (RGB 5/6/5) at the specified (x,y) |
|
position. For 16-bit display devices; no color reduction performed. |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param bitmap byte array with 16-bit color bitmap |
|
@param w Width of bitmap in pixels |
|
@param h Height of bitmap in pixels |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, |
|
int16_t w, int16_t h) { |
|
startWrite(); |
|
for (int16_t j = 0; j < h; j++, y++) { |
|
for (int16_t i = 0; i < w; i++) { |
|
writePixel(x + i, y, bitmap[j * w + i]); |
|
} |
|
} |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a PROGMEM-resident 16-bit image (RGB 5/6/5) with a 1-bit mask |
|
(set bits = opaque, unset bits = clear) at the specified (x,y) position. BOTH |
|
buffers (color and mask) must be PROGMEM-resident. For 16-bit display |
|
devices; no color reduction performed. |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param bitmap byte array with 16-bit color bitmap |
|
@param mask byte array with monochrome mask bitmap |
|
@param w Width of bitmap in pixels |
|
@param h Height of bitmap in pixels |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y, const uint16_t bitmap[], |
|
const uint8_t mask[], int16_t w, int16_t h) { |
|
int16_t bw = (w + 7) / 8; // Bitmask scanline pad = whole byte |
|
uint8_t b = 0; |
|
startWrite(); |
|
for (int16_t j = 0; j < h; j++, y++) { |
|
for (int16_t i = 0; i < w; i++) { |
|
if (i & 7) |
|
b <<= 1; |
|
else |
|
b = pgm_read_byte(&mask[j * bw + i / 8]); |
|
if (b & 0x80) { |
|
writePixel(x + i, y, pgm_read_word(&bitmap[j * w + i])); |
|
} |
|
} |
|
} |
|
endWrite(); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a RAM-resident 16-bit image (RGB 5/6/5) with a 1-bit mask (set |
|
bits = opaque, unset bits = clear) at the specified (x,y) position. BOTH |
|
buffers (color and mask) must be RAM-resident. For 16-bit display devices; no |
|
color reduction performed. |
|
@param x Top left corner x coordinate |
|
@param y Top left corner y coordinate |
|
@param bitmap byte array with 16-bit color bitmap |
|
@param mask byte array with monochrome mask bitmap |
|
@param w Width of bitmap in pixels |
|
@param h Height of bitmap in pixels |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::drawRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, |
|
uint8_t *mask, int16_t w, int16_t h) { |
|
int16_t bw = (w + 7) / 8; // Bitmask scanline pad = whole byte |
|
uint8_t b = 0; |
|
startWrite(); |
|
for (int16_t j = 0; j < h; j++, y++) { |
|
for (int16_t i = 0; i < w; i++) { |
|
if (i & 7) |
|
b <<= 1; |
|
else |
|
b = mask[j * bw + i / 8]; |
|
if (b & 0x80) { |
|
writePixel(x + i, y, bitmap[j * w + i]); |
|
} |
|
} |
|
} |
|
endWrite(); |
|
} |
|
|
|
// TEXT- AND CHARACTER-HANDLING FUNCTIONS ---------------------------------- |
|
|
|
// Draw a character |
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a single character |
|
@param x Bottom left corner x coordinate |
|
@param y Bottom left corner y coordinate |
|
@param c The 8-bit font-indexed character (likely ascii) |
|
@param color 16-bit 5-6-5 Color to draw chraracter with |
|
@param bg 16-bit 5-6-5 Color to fill background with (if same as color, |
|
no background) |
|
@param size Font magnification level, 1 is 'original' size |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::drawChar(int16_t x, int16_t y, unsigned char c, |
|
uint16_t color, uint16_t bg, uint8_t size) { |
|
drawChar(x, y, c, color, bg, size, size); |
|
} |
|
|
|
// Draw a character |
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a single character |
|
@param x Bottom left corner x coordinate |
|
@param y Bottom left corner y coordinate |
|
@param c The 8-bit font-indexed character (likely ascii) |
|
@param color 16-bit 5-6-5 Color to draw chraracter with |
|
@param bg 16-bit 5-6-5 Color to fill background with (if same as color, |
|
no background) |
|
@param size_x Font magnification level in X-axis, 1 is 'original' size |
|
@param size_y Font magnification level in Y-axis, 1 is 'original' size |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::drawChar(int16_t x, int16_t y, unsigned char c, |
|
uint16_t color, uint16_t bg, uint8_t size_x, |
|
uint8_t size_y) { |
|
|
|
if (!gfxFont) { // 'Classic' built-in font |
|
|
|
if ((x >= _width) || // Clip right |
|
(y >= _height) || // Clip bottom |
|
((x + 6 * size_x - 1) < 0) || // Clip left |
|
((y + 8 * size_y - 1) < 0)) // Clip top |
|
return; |
|
|
|
if (!_cp437 && (c >= 176)) |
|
c++; // Handle 'classic' charset behavior |
|
|
|
startWrite(); |
|
for (int8_t i = 0; i < 5; i++) { // Char bitmap = 5 columns |
|
uint8_t line = pgm_read_byte(&font[c * 5 + i]); |
|
for (int8_t j = 0; j < 8; j++, line >>= 1) { |
|
if (line & 1) { |
|
if (size_x == 1 && size_y == 1) |
|
writePixel(x + i, y + j, color); |
|
else |
|
writeFillRect(x + i * size_x, y + j * size_y, size_x, size_y, |
|
color); |
|
} else if (bg != color) { |
|
if (size_x == 1 && size_y == 1) |
|
writePixel(x + i, y + j, bg); |
|
else |
|
writeFillRect(x + i * size_x, y + j * size_y, size_x, size_y, bg); |
|
} |
|
} |
|
} |
|
if (bg != color) { // If opaque, draw vertical line for last column |
|
if (size_x == 1 && size_y == 1) |
|
writeFastVLine(x + 5, y, 8, bg); |
|
else |
|
writeFillRect(x + 5 * size_x, y, size_x, 8 * size_y, bg); |
|
} |
|
endWrite(); |
|
|
|
} 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 -= (uint8_t)pgm_read_byte(&gfxFont->first); |
|
GFXglyph *glyph = pgm_read_glyph_ptr(gfxFont, c); |
|
uint8_t *bitmap = pgm_read_bitmap_ptr(gfxFont); |
|
|
|
uint16_t bo = pgm_read_word(&glyph->bitmapOffset); |
|
uint8_t w = pgm_read_byte(&glyph->width), h = pgm_read_byte(&glyph->height); |
|
int8_t xo = pgm_read_byte(&glyph->xOffset), |
|
yo = pgm_read_byte(&glyph->yOffset); |
|
uint8_t xx, yy, bits = 0, bit = 0; |
|
int16_t xo16 = 0, yo16 = 0; |
|
|
|
if (size_x > 1 || size_y > 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. |
|
|
|
startWrite(); |
|
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_x == 1 && size_y == 1) { |
|
writePixel(x + xo + xx, y + yo + yy, color); |
|
} else { |
|
writeFillRect(x + (xo16 + xx) * size_x, y + (yo16 + yy) * size_y, |
|
size_x, size_y, color); |
|
} |
|
} |
|
bits <<= 1; |
|
} |
|
} |
|
endWrite(); |
|
|
|
} // End classic vs custom font |
|
} |
|
/**************************************************************************/ |
|
/*! |
|
@brief Print one byte/character of data, used to support print() |
|
@param c The 8-bit ascii character to write |
|
*/ |
|
/**************************************************************************/ |
|
size_t Adafruit_GFX::write(uint8_t c) { |
|
if (!gfxFont) { // 'Classic' built-in font |
|
|
|
if (c == '\n') { // Newline? |
|
cursor_x = 0; // Reset x to zero, |
|
cursor_y += textsize_y * 8; // advance y one line |
|
} else if (c != '\r') { // Ignore carriage returns |
|
if (wrap && ((cursor_x + textsize_x * 6) > _width)) { // Off right? |
|
cursor_x = 0; // Reset x to zero, |
|
cursor_y += textsize_y * 8; // advance y one line |
|
} |
|
drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize_x, |
|
textsize_y); |
|
cursor_x += textsize_x * 6; // Advance x one char |
|
} |
|
|
|
} else { // Custom font |
|
|
|
if (c == '\n') { |
|
cursor_x = 0; |
|
cursor_y += |
|
(int16_t)textsize_y * (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))) { |
|
GFXglyph *glyph = pgm_read_glyph_ptr(gfxFont, c - first); |
|
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_x * (xo + w)) > _width)) { |
|
cursor_x = 0; |
|
cursor_y += (int16_t)textsize_y * |
|
(uint8_t)pgm_read_byte(&gfxFont->yAdvance); |
|
} |
|
drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize_x, |
|
textsize_y); |
|
} |
|
cursor_x += |
|
(uint8_t)pgm_read_byte(&glyph->xAdvance) * (int16_t)textsize_x; |
|
} |
|
} |
|
} |
|
return 1; |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Set text 'magnification' size. Each increase in s makes 1 pixel |
|
that much bigger. |
|
@param s Desired text size. 1 is default 6x8, 2 is 12x16, 3 is 18x24, etc |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::setTextSize(uint8_t s) { setTextSize(s, s); } |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Set text 'magnification' size. Each increase in s makes 1 pixel |
|
that much bigger. |
|
@param s_x Desired text width magnification level in X-axis. 1 is default |
|
@param s_y Desired text width magnification level in Y-axis. 1 is default |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::setTextSize(uint8_t s_x, uint8_t s_y) { |
|
textsize_x = (s_x > 0) ? s_x : 1; |
|
textsize_y = (s_y > 0) ? s_y : 1; |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Set rotation setting for display |
|
@param x 0 thru 3 corresponding to 4 cardinal rotations |
|
*/ |
|
/**************************************************************************/ |
|
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; |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Set the font to display when print()ing, either custom or default |
|
@param f The GFXfont object, if NULL use built in 6x8 font |
|
*/ |
|
/**************************************************************************/ |
|
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; |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Helper to determine size of a character with current font/size. |
|
Broke this out as it's used by both the PROGMEM- and RAM-resident |
|
getTextBounds() functions. |
|
@param c The ASCII character in question |
|
@param x Pointer to x location of character. Value is modified by |
|
this function to advance to next character. |
|
@param y Pointer to y location of character. Value is modified by |
|
this function to advance to next character. |
|
@param minx Pointer to minimum X coordinate, passed in to AND returned |
|
by this function -- this is used to incrementally build a |
|
bounding rectangle for a string. |
|
@param miny Pointer to minimum Y coord, passed in AND returned. |
|
@param maxx Pointer to maximum X coord, passed in AND returned. |
|
@param maxy Pointer to maximum Y coord, passed in AND returned. |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::charBounds(unsigned char c, int16_t *x, int16_t *y, |
|
int16_t *minx, int16_t *miny, int16_t *maxx, |
|
int16_t *maxy) { |
|
|
|
if (gfxFont) { |
|
|
|
if (c == '\n') { // Newline? |
|
*x = 0; // Reset x to zero, advance y by one line |
|
*y += textsize_y * (uint8_t)pgm_read_byte(&gfxFont->yAdvance); |
|
} else if (c != '\r') { // Not a carriage return; is normal char |
|
uint8_t first = pgm_read_byte(&gfxFont->first), |
|
last = pgm_read_byte(&gfxFont->last); |
|
if ((c >= first) && (c <= last)) { // Char present in this font? |
|
GFXglyph *glyph = pgm_read_glyph_ptr(gfxFont, c - first); |
|
uint8_t gw = pgm_read_byte(&glyph->width), |
|
gh = 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); |
|
if (wrap && ((*x + (((int16_t)xo + gw) * textsize_x)) > _width)) { |
|
*x = 0; // Reset x to zero, advance y by one line |
|
*y += textsize_y * (uint8_t)pgm_read_byte(&gfxFont->yAdvance); |
|
} |
|
int16_t tsx = (int16_t)textsize_x, tsy = (int16_t)textsize_y, |
|
x1 = *x + xo * tsx, y1 = *y + yo * tsy, x2 = x1 + gw * tsx - 1, |
|
y2 = y1 + gh * tsy - 1; |
|
if (x1 < *minx) |
|
*minx = x1; |
|
if (y1 < *miny) |
|
*miny = y1; |
|
if (x2 > *maxx) |
|
*maxx = x2; |
|
if (y2 > *maxy) |
|
*maxy = y2; |
|
*x += xa * tsx; |
|
} |
|
} |
|
|
|
} else { // Default font |
|
|
|
if (c == '\n') { // Newline? |
|
*x = 0; // Reset x to zero, |
|
*y += textsize_y * 8; // advance y one line |
|
// min/max x/y unchaged -- that waits for next 'normal' character |
|
} else if (c != '\r') { // Normal char; ignore carriage returns |
|
if (wrap && ((*x + textsize_x * 6) > _width)) { // Off right? |
|
*x = 0; // Reset x to zero, |
|
*y += textsize_y * 8; // advance y one line |
|
} |
|
int x2 = *x + textsize_x * 6 - 1, // Lower-right pixel of char |
|
y2 = *y + textsize_y * 8 - 1; |
|
if (x2 > *maxx) |
|
*maxx = x2; // Track max x, y |
|
if (y2 > *maxy) |
|
*maxy = y2; |
|
if (*x < *minx) |
|
*minx = *x; // Track min x, y |
|
if (*y < *miny) |
|
*miny = *y; |
|
*x += textsize_x * 6; // Advance x one char |
|
} |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Helper to determine size of a string with current font/size. |
|
Pass string and a cursor position, returns UL corner and W,H. |
|
@param str The ASCII string to measure |
|
@param x The current cursor X |
|
@param y The current cursor Y |
|
@param x1 The boundary X coordinate, returned by function |
|
@param y1 The boundary Y coordinate, returned by function |
|
@param w The boundary width, returned by function |
|
@param h The boundary height, returned by function |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::getTextBounds(const 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 |
|
int16_t minx = 0x7FFF, miny = 0x7FFF, maxx = -1, maxy = -1; // Bound rect |
|
// Bound rect is intentionally initialized inverted, so 1st char sets it |
|
|
|
*x1 = x; // Initial position is value passed in |
|
*y1 = y; |
|
*w = *h = 0; // Initial size is zero |
|
|
|
while ((c = *str++)) { |
|
// charBounds() modifies x/y to advance for each character, |
|
// and min/max x/y are updated to incrementally build bounding rect. |
|
charBounds(c, &x, &y, &minx, &miny, &maxx, &maxy); |
|
} |
|
|
|
if (maxx >= minx) { // If legit string bounds were found... |
|
*x1 = minx; // Update x1 to least X coord, |
|
*w = maxx - minx + 1; // And w to bound rect width |
|
} |
|
if (maxy >= miny) { // Same for height |
|
*y1 = miny; |
|
*h = maxy - miny + 1; |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Helper to determine size of a string with current font/size. Pass |
|
string and a cursor position, returns UL corner and W,H. |
|
@param str The ascii string to measure (as an arduino String() class) |
|
@param x The current cursor X |
|
@param y The current cursor Y |
|
@param x1 The boundary X coordinate, set by function |
|
@param y1 The boundary Y coordinate, set by function |
|
@param w The boundary width, set by function |
|
@param h The boundary height, set by function |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::getTextBounds(const String &str, int16_t x, int16_t y, |
|
int16_t *x1, int16_t *y1, uint16_t *w, |
|
uint16_t *h) { |
|
if (str.length() != 0) { |
|
getTextBounds(const_cast<char *>(str.c_str()), x, y, x1, y1, w, h); |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Helper to determine size of a PROGMEM string with current |
|
font/size. Pass string and a cursor position, returns UL corner and W,H. |
|
@param str The flash-memory ascii string to measure |
|
@param x The current cursor X |
|
@param y The current cursor Y |
|
@param x1 The boundary X coordinate, set by function |
|
@param y1 The boundary Y coordinate, set by function |
|
@param w The boundary width, set by function |
|
@param h The boundary height, set by function |
|
*/ |
|
/**************************************************************************/ |
|
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; |
|
|
|
int16_t minx = _width, miny = _height, maxx = -1, maxy = -1; |
|
|
|
while ((c = pgm_read_byte(s++))) |
|
charBounds(c, &x, &y, &minx, &miny, &maxx, &maxy); |
|
|
|
if (maxx >= minx) { |
|
*x1 = minx; |
|
*w = maxx - minx + 1; |
|
} |
|
if (maxy >= miny) { |
|
*y1 = miny; |
|
*h = maxy - miny + 1; |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Invert the display (ideally using built-in hardware command) |
|
@param i True if you want to invert, false to make 'normal' |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX::invertDisplay(bool i) { |
|
// Do nothing, must be subclassed if supported by hardware |
|
(void)i; // disable -Wunused-parameter warning |
|
} |
|
|
|
/***************************************************************************/ |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Create a simple drawn button UI element |
|
*/ |
|
/**************************************************************************/ |
|
Adafruit_GFX_Button::Adafruit_GFX_Button(void) { _gfx = 0; } |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Initialize button with our desired color/size/settings |
|
@param gfx Pointer to our display so we can draw to it! |
|
@param x The X coordinate of the center of the button |
|
@param y The Y coordinate of the center of the button |
|
@param w Width of the buttton |
|
@param h Height of the buttton |
|
@param outline Color of the outline (16-bit 5-6-5 standard) |
|
@param fill Color of the button fill (16-bit 5-6-5 standard) |
|
@param textcolor Color of the button label (16-bit 5-6-5 standard) |
|
@param label Ascii string of the text inside the button |
|
@param textsize The font magnification of the label text |
|
*/ |
|
/**************************************************************************/ |
|
// Classic initButton() function: pass center & size |
|
void Adafruit_GFX_Button::initButton(Adafruit_GFX *gfx, int16_t x, int16_t y, |
|
uint16_t w, uint16_t h, uint16_t outline, |
|
uint16_t fill, uint16_t textcolor, |
|
char *label, uint8_t textsize) { |
|
// Tweak arguments and pass to the newer initButtonUL() function... |
|
initButtonUL(gfx, x - (w / 2), y - (h / 2), w, h, outline, fill, textcolor, |
|
label, textsize); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Initialize button with our desired color/size/settings |
|
@param gfx Pointer to our display so we can draw to it! |
|
@param x The X coordinate of the center of the button |
|
@param y The Y coordinate of the center of the button |
|
@param w Width of the buttton |
|
@param h Height of the buttton |
|
@param outline Color of the outline (16-bit 5-6-5 standard) |
|
@param fill Color of the button fill (16-bit 5-6-5 standard) |
|
@param textcolor Color of the button label (16-bit 5-6-5 standard) |
|
@param label Ascii string of the text inside the button |
|
@param textsize_x The font magnification in X-axis of the label text |
|
@param textsize_y The font magnification in Y-axis of the label text |
|
*/ |
|
/**************************************************************************/ |
|
// Classic initButton() function: pass center & size |
|
void Adafruit_GFX_Button::initButton(Adafruit_GFX *gfx, int16_t x, int16_t y, |
|
uint16_t w, uint16_t h, uint16_t outline, |
|
uint16_t fill, uint16_t textcolor, |
|
char *label, uint8_t textsize_x, |
|
uint8_t textsize_y) { |
|
// Tweak arguments and pass to the newer initButtonUL() function... |
|
initButtonUL(gfx, x - (w / 2), y - (h / 2), w, h, outline, fill, textcolor, |
|
label, textsize_x, textsize_y); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Initialize button with our desired color/size/settings, with |
|
upper-left coordinates |
|
@param gfx Pointer to our display so we can draw to it! |
|
@param x1 The X coordinate of the Upper-Left corner of the button |
|
@param y1 The Y coordinate of the Upper-Left corner of the button |
|
@param w Width of the buttton |
|
@param h Height of the buttton |
|
@param outline Color of the outline (16-bit 5-6-5 standard) |
|
@param fill Color of the button fill (16-bit 5-6-5 standard) |
|
@param textcolor Color of the button label (16-bit 5-6-5 standard) |
|
@param label Ascii string of the text inside the button |
|
@param textsize The font magnification of the label text |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX_Button::initButtonUL(Adafruit_GFX *gfx, int16_t x1, |
|
int16_t y1, uint16_t w, uint16_t h, |
|
uint16_t outline, uint16_t fill, |
|
uint16_t textcolor, char *label, |
|
uint8_t textsize) { |
|
initButtonUL(gfx, x1, y1, w, h, outline, fill, textcolor, label, textsize, |
|
textsize); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Initialize button with our desired color/size/settings, with |
|
upper-left coordinates |
|
@param gfx Pointer to our display so we can draw to it! |
|
@param x1 The X coordinate of the Upper-Left corner of the button |
|
@param y1 The Y coordinate of the Upper-Left corner of the button |
|
@param w Width of the buttton |
|
@param h Height of the buttton |
|
@param outline Color of the outline (16-bit 5-6-5 standard) |
|
@param fill Color of the button fill (16-bit 5-6-5 standard) |
|
@param textcolor Color of the button label (16-bit 5-6-5 standard) |
|
@param label Ascii string of the text inside the button |
|
@param textsize_x The font magnification in X-axis of the label text |
|
@param textsize_y The font magnification in Y-axis of the label text |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX_Button::initButtonUL(Adafruit_GFX *gfx, int16_t x1, |
|
int16_t y1, uint16_t w, uint16_t h, |
|
uint16_t outline, uint16_t fill, |
|
uint16_t textcolor, char *label, |
|
uint8_t textsize_x, uint8_t textsize_y) { |
|
_x1 = x1; |
|
_y1 = y1; |
|
_w = w; |
|
_h = h; |
|
_outlinecolor = outline; |
|
_fillcolor = fill; |
|
_textcolor = textcolor; |
|
_textsize_x = textsize_x; |
|
_textsize_y = textsize_y; |
|
_gfx = gfx; |
|
strncpy(_label, label, 9); |
|
_label[9] = 0; // strncpy does not place a null at the end. |
|
// When 'label' is >9 characters, _label is not terminated. |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw the button on the screen |
|
@param inverted Whether to draw with fill/text swapped to indicate |
|
'pressed' |
|
*/ |
|
/**************************************************************************/ |
|
void Adafruit_GFX_Button::drawButton(bool inverted) { |
|
uint16_t fill, outline, text; |
|
|
|
if (!inverted) { |
|
fill = _fillcolor; |
|
outline = _outlinecolor; |
|
text = _textcolor; |
|
} else { |
|
fill = _textcolor; |
|
outline = _outlinecolor; |
|
text = _fillcolor; |
|
} |
|
|
|
uint8_t r = min(_w, _h) / 4; // Corner radius |
|
_gfx->fillRoundRect(_x1, _y1, _w, _h, r, fill); |
|
_gfx->drawRoundRect(_x1, _y1, _w, _h, r, outline); |
|
|
|
_gfx->setCursor(_x1 + (_w / 2) - (strlen(_label) * 3 * _textsize_x), |
|
_y1 + (_h / 2) - (4 * _textsize_y)); |
|
_gfx->setTextColor(text); |
|
_gfx->setTextSize(_textsize_x, _textsize_y); |
|
_gfx->print(_label); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Helper to let us know if a coordinate is within the bounds of the |
|
button |
|
@param x The X coordinate to check |
|
@param y The Y coordinate to check |
|
@returns True if within button graphics outline |
|
*/ |
|
/**************************************************************************/ |
|
bool Adafruit_GFX_Button::contains(int16_t x, int16_t y) { |
|
return ((x >= _x1) && (x < (int16_t)(_x1 + _w)) && (y >= _y1) && |
|
(y < (int16_t)(_y1 + _h))); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Query whether the button was pressed since we last checked state |
|
@returns True if was not-pressed before, now is. |
|
*/ |
|
/**************************************************************************/ |
|
bool Adafruit_GFX_Button::justPressed() { return (currstate && !laststate); } |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Query whether the button was released since we last checked state |
|
@returns True if was pressed before, now is not. |
|
*/ |
|
/**************************************************************************/ |
|
bool Adafruit_GFX_Button::justReleased() { return (!currstate && laststate); } |
|
|
|
// ------------------------------------------------------------------------- |
|
|
|
// GFXcanvas1, GFXcanvas8 and GFXcanvas16 (currently a WIP, don't get too |
|
// comfy with the implementation) provide 1-, 8- and 16-bit offscreen |
|
// canvases, the address of which can be passed to drawBitmap() or |
|
// pushColors() (the latter appears only in a couple of GFX-subclassed TFT |
|
// libraries 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 the others are much more likely to |
|
// require at least a Mega or various recent ARM-type boards (recommended, |
|
// as the text+bitmap draw can be pokey). GFXcanvas1 requires 1 bit per |
|
// pixel (rounded up to nearest byte per scanline), GFXcanvas8 is 1 byte |
|
// per pixel (no scanline pad), and GFXcanvas16 uses 2 bytes per pixel (no |
|
// scanline pad). |
|
// NOT EXTENSIVELY TESTED YET. MAY CONTAIN WORST BUGS KNOWN TO HUMANKIND. |
|
|
|
#ifdef __AVR__ |
|
// Bitmask tables of 0x80>>X and ~(0x80>>X), because X>>Y is slow on AVR |
|
const uint8_t PROGMEM GFXcanvas1::GFXsetBit[] = {0x80, 0x40, 0x20, 0x10, |
|
0x08, 0x04, 0x02, 0x01}; |
|
const uint8_t PROGMEM GFXcanvas1::GFXclrBit[] = {0x7F, 0xBF, 0xDF, 0xEF, |
|
0xF7, 0xFB, 0xFD, 0xFE}; |
|
#endif |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Instatiate a GFX 1-bit canvas context for graphics |
|
@param w Display width, in pixels |
|
@param h Display height, in pixels |
|
*/ |
|
/**************************************************************************/ |
|
GFXcanvas1::GFXcanvas1(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) { |
|
uint32_t bytes = ((w + 7) / 8) * h; |
|
if ((buffer = (uint8_t *)malloc(bytes))) { |
|
memset(buffer, 0, bytes); |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Delete the canvas, free memory |
|
*/ |
|
/**************************************************************************/ |
|
GFXcanvas1::~GFXcanvas1(void) { |
|
if (buffer) |
|
free(buffer); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a pixel to the canvas framebuffer |
|
@param x x coordinate |
|
@param y y coordinate |
|
@param color Binary (on or off) color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
void GFXcanvas1::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; |
|
} |
|
|
|
uint8_t *ptr = &buffer[(x / 8) + y * ((WIDTH + 7) / 8)]; |
|
#ifdef __AVR__ |
|
if (color) |
|
*ptr |= pgm_read_byte(&GFXsetBit[x & 7]); |
|
else |
|
*ptr &= pgm_read_byte(&GFXclrBit[x & 7]); |
|
#else |
|
if (color) |
|
*ptr |= 0x80 >> (x & 7); |
|
else |
|
*ptr &= ~(0x80 >> (x & 7)); |
|
#endif |
|
} |
|
} |
|
|
|
/**********************************************************************/ |
|
/*! |
|
@brief Get the pixel color value at a given coordinate |
|
@param x x coordinate |
|
@param y y coordinate |
|
@returns The desired pixel's binary color value, either 0x1 (on) or 0x0 |
|
(off) |
|
*/ |
|
/**********************************************************************/ |
|
bool GFXcanvas1::getPixel(int16_t x, int16_t y) const { |
|
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; |
|
} |
|
return getRawPixel(x, y); |
|
} |
|
|
|
/**********************************************************************/ |
|
/*! |
|
@brief Get the pixel color value at a given, unrotated coordinate. |
|
This method is intended for hardware drivers to get pixel value |
|
in physical coordinates. |
|
@param x x coordinate |
|
@param y y coordinate |
|
@returns The desired pixel's binary color value, either 0x1 (on) or 0x0 |
|
(off) |
|
*/ |
|
/**********************************************************************/ |
|
bool GFXcanvas1::getRawPixel(int16_t x, int16_t y) const { |
|
if ((x < 0) || (y < 0) || (x >= WIDTH) || (y >= HEIGHT)) |
|
return 0; |
|
if (buffer) { |
|
uint8_t *ptr = &buffer[(x / 8) + y * ((WIDTH + 7) / 8)]; |
|
|
|
#ifdef __AVR__ |
|
return ((*ptr) & pgm_read_byte(&GFXsetBit[x & 7])) != 0; |
|
#else |
|
return ((*ptr) & (0x80 >> (x & 7))) != 0; |
|
#endif |
|
} |
|
return 0; |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Fill the framebuffer completely with one color |
|
@param color Binary (on or off) color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
void GFXcanvas1::fillScreen(uint16_t color) { |
|
if (buffer) { |
|
uint32_t bytes = ((WIDTH + 7) / 8) * HEIGHT; |
|
memset(buffer, color ? 0xFF : 0x00, bytes); |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Speed optimized vertical line drawing |
|
@param x Line horizontal start point |
|
@param y Line vertical start point |
|
@param h Length of vertical line to be drawn, including first point |
|
@param color Color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
void GFXcanvas1::drawFastVLine(int16_t x, int16_t y, int16_t h, |
|
uint16_t color) { |
|
|
|
if (h < 0) { // Convert negative heights to positive equivalent |
|
h *= -1; |
|
y -= h - 1; |
|
if (y < 0) { |
|
h += y; |
|
y = 0; |
|
} |
|
} |
|
|
|
// Edge rejection (no-draw if totally off canvas) |
|
if ((x < 0) || (x >= width()) || (y >= height()) || ((y + h - 1) < 0)) { |
|
return; |
|
} |
|
|
|
if (y < 0) { // Clip top |
|
h += y; |
|
y = 0; |
|
} |
|
if (y + h > height()) { // Clip bottom |
|
h = height() - y; |
|
} |
|
|
|
if (getRotation() == 0) { |
|
drawFastRawVLine(x, y, h, color); |
|
} else if (getRotation() == 1) { |
|
int16_t t = x; |
|
x = WIDTH - 1 - y; |
|
y = t; |
|
x -= h - 1; |
|
drawFastRawHLine(x, y, h, color); |
|
} else if (getRotation() == 2) { |
|
x = WIDTH - 1 - x; |
|
y = HEIGHT - 1 - y; |
|
|
|
y -= h - 1; |
|
drawFastRawVLine(x, y, h, color); |
|
} else if (getRotation() == 3) { |
|
int16_t t = x; |
|
x = y; |
|
y = HEIGHT - 1 - t; |
|
drawFastRawHLine(x, y, h, color); |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Speed optimized horizontal line drawing |
|
@param x Line horizontal start point |
|
@param y Line vertical start point |
|
@param w Length of horizontal line to be drawn, including first point |
|
@param color Color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
void GFXcanvas1::drawFastHLine(int16_t x, int16_t y, int16_t w, |
|
uint16_t color) { |
|
if (w < 0) { // Convert negative widths to positive equivalent |
|
w *= -1; |
|
x -= w - 1; |
|
if (x < 0) { |
|
w += x; |
|
x = 0; |
|
} |
|
} |
|
|
|
// Edge rejection (no-draw if totally off canvas) |
|
if ((y < 0) || (y >= height()) || (x >= width()) || ((x + w - 1) < 0)) { |
|
return; |
|
} |
|
|
|
if (x < 0) { // Clip left |
|
w += x; |
|
x = 0; |
|
} |
|
if (x + w >= width()) { // Clip right |
|
w = width() - x; |
|
} |
|
|
|
if (getRotation() == 0) { |
|
drawFastRawHLine(x, y, w, color); |
|
} else if (getRotation() == 1) { |
|
int16_t t = x; |
|
x = WIDTH - 1 - y; |
|
y = t; |
|
drawFastRawVLine(x, y, w, color); |
|
} else if (getRotation() == 2) { |
|
x = WIDTH - 1 - x; |
|
y = HEIGHT - 1 - y; |
|
|
|
x -= w - 1; |
|
drawFastRawHLine(x, y, w, color); |
|
} else if (getRotation() == 3) { |
|
int16_t t = x; |
|
x = y; |
|
y = HEIGHT - 1 - t; |
|
y -= w - 1; |
|
drawFastRawVLine(x, y, w, color); |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Speed optimized vertical line drawing into the raw canvas buffer |
|
@param x Line horizontal start point |
|
@param y Line vertical start point |
|
@param h length of vertical line to be drawn, including first point |
|
@param color Binary (on or off) color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
void GFXcanvas1::drawFastRawVLine(int16_t x, int16_t y, int16_t h, |
|
uint16_t color) { |
|
// x & y already in raw (rotation 0) coordinates, no need to transform. |
|
int16_t row_bytes = ((WIDTH + 7) / 8); |
|
uint8_t *ptr = &buffer[(x / 8) + y * row_bytes]; |
|
|
|
if (color > 0) { |
|
#ifdef __AVR__ |
|
uint8_t bit_mask = pgm_read_byte(&GFXsetBit[x & 7]); |
|
#else |
|
uint8_t bit_mask = (0x80 >> (x & 7)); |
|
#endif |
|
for (int16_t i = 0; i < h; i++) { |
|
*ptr |= bit_mask; |
|
ptr += row_bytes; |
|
} |
|
} else { |
|
#ifdef __AVR__ |
|
uint8_t bit_mask = pgm_read_byte(&GFXclrBit[x & 7]); |
|
#else |
|
uint8_t bit_mask = ~(0x80 >> (x & 7)); |
|
#endif |
|
for (int16_t i = 0; i < h; i++) { |
|
*ptr &= bit_mask; |
|
ptr += row_bytes; |
|
} |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Speed optimized horizontal line drawing into the raw canvas buffer |
|
@param x Line horizontal start point |
|
@param y Line vertical start point |
|
@param w length of horizontal line to be drawn, including first point |
|
@param color Binary (on or off) color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
void GFXcanvas1::drawFastRawHLine(int16_t x, int16_t y, int16_t w, |
|
uint16_t color) { |
|
// x & y already in raw (rotation 0) coordinates, no need to transform. |
|
int16_t rowBytes = ((WIDTH + 7) / 8); |
|
uint8_t *ptr = &buffer[(x / 8) + y * rowBytes]; |
|
size_t remainingWidthBits = w; |
|
|
|
// check to see if first byte needs to be partially filled |
|
if ((x & 7) > 0) { |
|
// create bit mask for first byte |
|
uint8_t startByteBitMask = 0x00; |
|
for (int8_t i = (x & 7); ((i < 8) && (remainingWidthBits > 0)); i++) { |
|
#ifdef __AVR__ |
|
startByteBitMask |= pgm_read_byte(&GFXsetBit[i]); |
|
#else |
|
startByteBitMask |= (0x80 >> i); |
|
#endif |
|
remainingWidthBits--; |
|
} |
|
if (color > 0) { |
|
*ptr |= startByteBitMask; |
|
} else { |
|
*ptr &= ~startByteBitMask; |
|
} |
|
|
|
ptr++; |
|
} |
|
|
|
// do the next remainingWidthBits bits |
|
if (remainingWidthBits > 0) { |
|
size_t remainingWholeBytes = remainingWidthBits / 8; |
|
size_t lastByteBits = remainingWidthBits % 8; |
|
uint8_t wholeByteColor = color > 0 ? 0xFF : 0x00; |
|
|
|
memset(ptr, wholeByteColor, remainingWholeBytes); |
|
|
|
if (lastByteBits > 0) { |
|
uint8_t lastByteBitMask = 0x00; |
|
for (size_t i = 0; i < lastByteBits; i++) { |
|
#ifdef __AVR__ |
|
lastByteBitMask |= pgm_read_byte(&GFXsetBit[i]); |
|
#else |
|
lastByteBitMask |= (0x80 >> i); |
|
#endif |
|
} |
|
ptr += remainingWholeBytes; |
|
|
|
if (color > 0) { |
|
*ptr |= lastByteBitMask; |
|
} else { |
|
*ptr &= ~lastByteBitMask; |
|
} |
|
} |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Instatiate a GFX 8-bit canvas context for graphics |
|
@param w Display width, in pixels |
|
@param h Display height, in pixels |
|
*/ |
|
/**************************************************************************/ |
|
GFXcanvas8::GFXcanvas8(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) { |
|
uint32_t bytes = w * h; |
|
if ((buffer = (uint8_t *)malloc(bytes))) { |
|
memset(buffer, 0, bytes); |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Delete the canvas, free memory |
|
*/ |
|
/**************************************************************************/ |
|
GFXcanvas8::~GFXcanvas8(void) { |
|
if (buffer) |
|
free(buffer); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a pixel to the canvas framebuffer |
|
@param x x coordinate |
|
@param y y coordinate |
|
@param color 8-bit Color to fill with. Only lower byte of uint16_t is used. |
|
*/ |
|
/**************************************************************************/ |
|
void GFXcanvas8::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; |
|
} |
|
} |
|
|
|
/**********************************************************************/ |
|
/*! |
|
@brief Get the pixel color value at a given coordinate |
|
@param x x coordinate |
|
@param y y coordinate |
|
@returns The desired pixel's 8-bit color value |
|
*/ |
|
/**********************************************************************/ |
|
uint8_t GFXcanvas8::getPixel(int16_t x, int16_t y) const { |
|
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; |
|
} |
|
return getRawPixel(x, y); |
|
} |
|
|
|
/**********************************************************************/ |
|
/*! |
|
@brief Get the pixel color value at a given, unrotated coordinate. |
|
This method is intended for hardware drivers to get pixel value |
|
in physical coordinates. |
|
@param x x coordinate |
|
@param y y coordinate |
|
@returns The desired pixel's 8-bit color value |
|
*/ |
|
/**********************************************************************/ |
|
uint8_t GFXcanvas8::getRawPixel(int16_t x, int16_t y) const { |
|
if ((x < 0) || (y < 0) || (x >= WIDTH) || (y >= HEIGHT)) |
|
return 0; |
|
if (buffer) { |
|
return buffer[x + y * WIDTH]; |
|
} |
|
return 0; |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Fill the framebuffer completely with one color |
|
@param color 8-bit Color to fill with. Only lower byte of uint16_t is used. |
|
*/ |
|
/**************************************************************************/ |
|
void GFXcanvas8::fillScreen(uint16_t color) { |
|
if (buffer) { |
|
memset(buffer, color, WIDTH * HEIGHT); |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Speed optimized vertical line drawing |
|
@param x Line horizontal start point |
|
@param y Line vertical start point |
|
@param h Length of vertical line to be drawn, including first point |
|
@param color 8-bit Color to fill with. Only lower byte of uint16_t is |
|
used. |
|
*/ |
|
/**************************************************************************/ |
|
void GFXcanvas8::drawFastVLine(int16_t x, int16_t y, int16_t h, |
|
uint16_t color) { |
|
if (h < 0) { // Convert negative heights to positive equivalent |
|
h *= -1; |
|
y -= h - 1; |
|
if (y < 0) { |
|
h += y; |
|
y = 0; |
|
} |
|
} |
|
|
|
// Edge rejection (no-draw if totally off canvas) |
|
if ((x < 0) || (x >= width()) || (y >= height()) || ((y + h - 1) < 0)) { |
|
return; |
|
} |
|
|
|
if (y < 0) { // Clip top |
|
h += y; |
|
y = 0; |
|
} |
|
if (y + h > height()) { // Clip bottom |
|
h = height() - y; |
|
} |
|
|
|
if (getRotation() == 0) { |
|
drawFastRawVLine(x, y, h, color); |
|
} else if (getRotation() == 1) { |
|
int16_t t = x; |
|
x = WIDTH - 1 - y; |
|
y = t; |
|
x -= h - 1; |
|
drawFastRawHLine(x, y, h, color); |
|
} else if (getRotation() == 2) { |
|
x = WIDTH - 1 - x; |
|
y = HEIGHT - 1 - y; |
|
|
|
y -= h - 1; |
|
drawFastRawVLine(x, y, h, color); |
|
} else if (getRotation() == 3) { |
|
int16_t t = x; |
|
x = y; |
|
y = HEIGHT - 1 - t; |
|
drawFastRawHLine(x, y, h, color); |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Speed optimized horizontal line drawing |
|
@param x Line horizontal start point |
|
@param y Line vertical start point |
|
@param w Length of horizontal line to be drawn, including 1st point |
|
@param color 8-bit Color to fill with. Only lower byte of uint16_t is |
|
used. |
|
*/ |
|
/**************************************************************************/ |
|
void GFXcanvas8::drawFastHLine(int16_t x, int16_t y, int16_t w, |
|
uint16_t color) { |
|
|
|
if (w < 0) { // Convert negative widths to positive equivalent |
|
w *= -1; |
|
x -= w - 1; |
|
if (x < 0) { |
|
w += x; |
|
x = 0; |
|
} |
|
} |
|
|
|
// Edge rejection (no-draw if totally off canvas) |
|
if ((y < 0) || (y >= height()) || (x >= width()) || ((x + w - 1) < 0)) { |
|
return; |
|
} |
|
|
|
if (x < 0) { // Clip left |
|
w += x; |
|
x = 0; |
|
} |
|
if (x + w >= width()) { // Clip right |
|
w = width() - x; |
|
} |
|
|
|
if (getRotation() == 0) { |
|
drawFastRawHLine(x, y, w, color); |
|
} else if (getRotation() == 1) { |
|
int16_t t = x; |
|
x = WIDTH - 1 - y; |
|
y = t; |
|
drawFastRawVLine(x, y, w, color); |
|
} else if (getRotation() == 2) { |
|
x = WIDTH - 1 - x; |
|
y = HEIGHT - 1 - y; |
|
|
|
x -= w - 1; |
|
drawFastRawHLine(x, y, w, color); |
|
} else if (getRotation() == 3) { |
|
int16_t t = x; |
|
x = y; |
|
y = HEIGHT - 1 - t; |
|
y -= w - 1; |
|
drawFastRawVLine(x, y, w, color); |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Speed optimized vertical line drawing into the raw canvas buffer |
|
@param x Line horizontal start point |
|
@param y Line vertical start point |
|
@param h length of vertical line to be drawn, including first point |
|
@param color 8-bit Color to fill with. Only lower byte of uint16_t is |
|
used. |
|
*/ |
|
/**************************************************************************/ |
|
void GFXcanvas8::drawFastRawVLine(int16_t x, int16_t y, int16_t h, |
|
uint16_t color) { |
|
// x & y already in raw (rotation 0) coordinates, no need to transform. |
|
uint8_t *buffer_ptr = buffer + y * WIDTH + x; |
|
for (int16_t i = 0; i < h; i++) { |
|
(*buffer_ptr) = color; |
|
buffer_ptr += WIDTH; |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Speed optimized horizontal line drawing into the raw canvas buffer |
|
@param x Line horizontal start point |
|
@param y Line vertical start point |
|
@param w length of horizontal line to be drawn, including first point |
|
@param color 8-bit Color to fill with. Only lower byte of uint16_t is |
|
used. |
|
*/ |
|
/**************************************************************************/ |
|
void GFXcanvas8::drawFastRawHLine(int16_t x, int16_t y, int16_t w, |
|
uint16_t color) { |
|
// x & y already in raw (rotation 0) coordinates, no need to transform. |
|
memset(buffer + y * WIDTH + x, color, w); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Instatiate a GFX 16-bit canvas context for graphics |
|
@param w Display width, in pixels |
|
@param h Display height, in pixels |
|
*/ |
|
/**************************************************************************/ |
|
GFXcanvas16::GFXcanvas16(uint16_t w, uint16_t h) : Adafruit_GFX(w, h) { |
|
uint32_t bytes = w * h * 2; |
|
if ((buffer = (uint16_t *)malloc(bytes))) { |
|
memset(buffer, 0, bytes); |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Delete the canvas, free memory |
|
*/ |
|
/**************************************************************************/ |
|
GFXcanvas16::~GFXcanvas16(void) { |
|
if (buffer) |
|
free(buffer); |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Draw a pixel to the canvas framebuffer |
|
@param x x coordinate |
|
@param y y coordinate |
|
@param color 16-bit 5-6-5 Color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
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; |
|
} |
|
} |
|
|
|
/**********************************************************************/ |
|
/*! |
|
@brief Get the pixel color value at a given coordinate |
|
@param x x coordinate |
|
@param y y coordinate |
|
@returns The desired pixel's 16-bit 5-6-5 color value |
|
*/ |
|
/**********************************************************************/ |
|
uint16_t GFXcanvas16::getPixel(int16_t x, int16_t y) const { |
|
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; |
|
} |
|
return getRawPixel(x, y); |
|
} |
|
|
|
/**********************************************************************/ |
|
/*! |
|
@brief Get the pixel color value at a given, unrotated coordinate. |
|
This method is intended for hardware drivers to get pixel value |
|
in physical coordinates. |
|
@param x x coordinate |
|
@param y y coordinate |
|
@returns The desired pixel's 16-bit 5-6-5 color value |
|
*/ |
|
/**********************************************************************/ |
|
uint16_t GFXcanvas16::getRawPixel(int16_t x, int16_t y) const { |
|
if ((x < 0) || (y < 0) || (x >= WIDTH) || (y >= HEIGHT)) |
|
return 0; |
|
if (buffer) { |
|
return buffer[x + y * WIDTH]; |
|
} |
|
return 0; |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Fill the framebuffer completely with one color |
|
@param color 16-bit 5-6-5 Color to fill with |
|
*/ |
|
/**************************************************************************/ |
|
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 { |
|
uint32_t i, pixels = WIDTH * HEIGHT; |
|
for (i = 0; i < pixels; i++) |
|
buffer[i] = color; |
|
} |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Reverses the "endian-ness" of each 16-bit pixel within the |
|
canvas; little-endian to big-endian, or big-endian to little. |
|
Most microcontrollers (such as SAMD) are little-endian, while |
|
most displays tend toward big-endianness. All the drawing |
|
functions (including RGB bitmap drawing) take care of this |
|
automatically, but some specialized code (usually involving |
|
DMA) can benefit from having pixel data already in the |
|
display-native order. Note that this does NOT convert to a |
|
SPECIFIC endian-ness, it just flips the bytes within each word. |
|
*/ |
|
/**************************************************************************/ |
|
void GFXcanvas16::byteSwap(void) { |
|
if (buffer) { |
|
uint32_t i, pixels = WIDTH * HEIGHT; |
|
for (i = 0; i < pixels; i++) |
|
buffer[i] = __builtin_bswap16(buffer[i]); |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Speed optimized vertical line drawing |
|
@param x Line horizontal start point |
|
@param y Line vertical start point |
|
@param h length of vertical line to be drawn, including first point |
|
@param color color 16-bit 5-6-5 Color to draw line with |
|
*/ |
|
/**************************************************************************/ |
|
void GFXcanvas16::drawFastVLine(int16_t x, int16_t y, int16_t h, |
|
uint16_t color) { |
|
if (h < 0) { // Convert negative heights to positive equivalent |
|
h *= -1; |
|
y -= h - 1; |
|
if (y < 0) { |
|
h += y; |
|
y = 0; |
|
} |
|
} |
|
|
|
// Edge rejection (no-draw if totally off canvas) |
|
if ((x < 0) || (x >= width()) || (y >= height()) || ((y + h - 1) < 0)) { |
|
return; |
|
} |
|
|
|
if (y < 0) { // Clip top |
|
h += y; |
|
y = 0; |
|
} |
|
if (y + h > height()) { // Clip bottom |
|
h = height() - y; |
|
} |
|
|
|
if (getRotation() == 0) { |
|
drawFastRawVLine(x, y, h, color); |
|
} else if (getRotation() == 1) { |
|
int16_t t = x; |
|
x = WIDTH - 1 - y; |
|
y = t; |
|
x -= h - 1; |
|
drawFastRawHLine(x, y, h, color); |
|
} else if (getRotation() == 2) { |
|
x = WIDTH - 1 - x; |
|
y = HEIGHT - 1 - y; |
|
|
|
y -= h - 1; |
|
drawFastRawVLine(x, y, h, color); |
|
} else if (getRotation() == 3) { |
|
int16_t t = x; |
|
x = y; |
|
y = HEIGHT - 1 - t; |
|
drawFastRawHLine(x, y, h, color); |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Speed optimized horizontal line drawing |
|
@param x Line horizontal start point |
|
@param y Line vertical start point |
|
@param w Length of horizontal line to be drawn, including 1st point |
|
@param color Color 16-bit 5-6-5 Color to draw line with |
|
*/ |
|
/**************************************************************************/ |
|
void GFXcanvas16::drawFastHLine(int16_t x, int16_t y, int16_t w, |
|
uint16_t color) { |
|
if (w < 0) { // Convert negative widths to positive equivalent |
|
w *= -1; |
|
x -= w - 1; |
|
if (x < 0) { |
|
w += x; |
|
x = 0; |
|
} |
|
} |
|
|
|
// Edge rejection (no-draw if totally off canvas) |
|
if ((y < 0) || (y >= height()) || (x >= width()) || ((x + w - 1) < 0)) { |
|
return; |
|
} |
|
|
|
if (x < 0) { // Clip left |
|
w += x; |
|
x = 0; |
|
} |
|
if (x + w >= width()) { // Clip right |
|
w = width() - x; |
|
} |
|
|
|
if (getRotation() == 0) { |
|
drawFastRawHLine(x, y, w, color); |
|
} else if (getRotation() == 1) { |
|
int16_t t = x; |
|
x = WIDTH - 1 - y; |
|
y = t; |
|
drawFastRawVLine(x, y, w, color); |
|
} else if (getRotation() == 2) { |
|
x = WIDTH - 1 - x; |
|
y = HEIGHT - 1 - y; |
|
|
|
x -= w - 1; |
|
drawFastRawHLine(x, y, w, color); |
|
} else if (getRotation() == 3) { |
|
int16_t t = x; |
|
x = y; |
|
y = HEIGHT - 1 - t; |
|
y -= w - 1; |
|
drawFastRawVLine(x, y, w, color); |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Speed optimized vertical line drawing into the raw canvas buffer |
|
@param x Line horizontal start point |
|
@param y Line vertical start point |
|
@param h length of vertical line to be drawn, including first point |
|
@param color color 16-bit 5-6-5 Color to draw line with |
|
*/ |
|
/**************************************************************************/ |
|
void GFXcanvas16::drawFastRawVLine(int16_t x, int16_t y, int16_t h, |
|
uint16_t color) { |
|
// x & y already in raw (rotation 0) coordinates, no need to transform. |
|
uint16_t *buffer_ptr = buffer + y * WIDTH + x; |
|
for (int16_t i = 0; i < h; i++) { |
|
(*buffer_ptr) = color; |
|
buffer_ptr += WIDTH; |
|
} |
|
} |
|
|
|
/**************************************************************************/ |
|
/*! |
|
@brief Speed optimized horizontal line drawing into the raw canvas buffer |
|
@param x Line horizontal start point |
|
@param y Line vertical start point |
|
@param w length of horizontal line to be drawn, including first point |
|
@param color color 16-bit 5-6-5 Color to draw line with |
|
*/ |
|
/**************************************************************************/ |
|
void GFXcanvas16::drawFastRawHLine(int16_t x, int16_t y, int16_t w, |
|
uint16_t color) { |
|
// x & y already in raw (rotation 0) coordinates, no need to transform. |
|
uint32_t buffer_index = y * WIDTH + x; |
|
for (uint32_t i = buffer_index; i < buffer_index + w; i++) { |
|
buffer[i] = color; |
|
} |
|
}
|
|
|