forked from Bodmer/TFT_eSPI
Bodmer
0e0fd75277
The library has been cleaned up as it has got a bit untidy due to the large number of small incremental changes. 4bit Sprite examples renaed to be consistent with others. alphaBlend example moved to generic folder (alphaBlend fn was moved to TFT_eSPI class). Added sections + explanatory comments to functions prototypes. Temporary comments added for potential gotchas for noobs when using DMA. spi_begin/end functions renamed to reflect functionality. Old fns retained for backwards compatibility with user setup.h files.
183 lines
8.6 KiB
C++
183 lines
8.6 KiB
C++
/***************************************************************************************
|
|
// The following class creates Sprites in RAM, graphics can then be drawn in the Sprite
|
|
// and rendered quickly onto the TFT screen. The class inherits the graphics functions
|
|
// from the TFT_eSPI class. Some functions are overridden by this class so that the
|
|
// graphics are written to the Sprite rather than the TFT.
|
|
***************************************************************************************/
|
|
|
|
// pushRotated support - Bitwise truncation of fixed point integer value V scaled by S
|
|
//#define truncateFP(V,S) ((V + (V < 0 ? -1<<(S-1) : 0))>>S)
|
|
#define truncateFP(V,S) ((V + (V < 0 ? -1<<(S-1) : 1<<(S-1)))>>S)
|
|
|
|
class TFT_eSprite : public TFT_eSPI {
|
|
|
|
public:
|
|
|
|
TFT_eSprite(TFT_eSPI *tft);
|
|
|
|
// Create a sprite of width x height pixels, return a pointer to the RAM area
|
|
// Sketch can cast returned value to (uint16_t*) for 16 bit depth if needed
|
|
// RAM required is:
|
|
// - 1 bit per pixel for 1 bit colour depth
|
|
// - 1 byte per pixel for 8 bit colour
|
|
// - 2 bytes per pixel for 16 bit color depth
|
|
~TFT_eSprite(void);
|
|
|
|
void* createSprite(int16_t width, int16_t height, uint8_t frames = 1);
|
|
|
|
// Delete the sprite to free up the RAM
|
|
void deleteSprite(void);
|
|
|
|
// Select the frame buffer for graphics write (for 2 colour ePaper and DMA toggle buffer)
|
|
// Returns a pointer to the Sprite frame buffer
|
|
void* frameBuffer(int8_t f);
|
|
|
|
// Set or get the colour depth to 4, 8 or 16 bits. Can be used to change depth an existing
|
|
// sprite, but clears it to black, returns a new pointer if sprite is re-created.
|
|
void* setColorDepth(int8_t b);
|
|
int8_t getColorDepth(void);
|
|
|
|
// Set the palette for a 4 bit depth sprite. Only the first 16 colours in the map are used.
|
|
void createPalette(uint16_t *palette, int colors = 16); // Palette in RAM
|
|
void createPalette(const uint16_t *palette, int colors = 16); // Palette in FLASH
|
|
|
|
// Set a single palette index to the given color
|
|
void setPaletteColor(uint8_t index, uint16_t color);
|
|
|
|
// Get the color at the given palette index
|
|
uint16_t getPaletteColor(uint8_t index);
|
|
|
|
// Set foreground and background colours for 1 bit per pixel Sprite
|
|
void setBitmapColor(uint16_t fg, uint16_t bg);
|
|
|
|
void drawPixel(int32_t x, int32_t y, uint32_t color);
|
|
|
|
void drawChar(int32_t x, int32_t y, uint16_t c, uint32_t color, uint32_t bg, uint8_t font),
|
|
|
|
// Fill Sprite with a colour
|
|
fillSprite(uint32_t color),
|
|
|
|
// Define a window to push 16 bit colour pixels into in a raster order
|
|
// Colours are converted to the set Sprite colour bit depth
|
|
setWindow(int32_t x0, int32_t y0, int32_t x1, int32_t y1),
|
|
// Push a color (aka singe pixel) to the screen
|
|
pushColor(uint32_t color),
|
|
// Push len colors (pixels) to the screen
|
|
pushColor(uint32_t color, uint16_t len),
|
|
// Push a pixel preformatted as a 8 or 16 bit colour (avoids conversion overhead)
|
|
writeColor(uint16_t color),
|
|
|
|
// Set the scroll zone, top left corner at x,y with defined width and height
|
|
// The colour (optional, black is default) is used to fill the gap after the scroll
|
|
setScrollRect(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t color = TFT_BLACK),
|
|
// Scroll the defined zone dx,dy pixels. Negative values left,up, positive right,down
|
|
// dy is optional (default is then no up/down scroll).
|
|
// The sprite coordinate frame does not move because pixels are moved
|
|
scroll(int16_t dx, int16_t dy = 0),
|
|
|
|
// Draw lines
|
|
drawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t color),
|
|
drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t color),
|
|
drawFastHLine(int32_t x, int32_t y, int32_t w, uint32_t color),
|
|
|
|
// Fill a rectangular area with a color (aka draw a filled rectangle)
|
|
fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color);
|
|
|
|
// Set the sprite text cursor position for print class (does not change the TFT screen cursor)
|
|
//setCursor(int16_t x, int16_t y); // Not needed, so uses TFT class function
|
|
|
|
// Set the coordinate rotation of the Sprite (for 1bpp Sprites only)
|
|
// Note: this uses coordinate rotation and is primarily for ePaper which does not support
|
|
// CGRAM rotation (like TFT drivers do) within the displays internal hardware
|
|
void setRotation(uint8_t rotation);
|
|
uint8_t getRotation(void);
|
|
|
|
// Push a rotated copy of Sprite to TFT with optional transparent colour
|
|
bool pushRotated(int16_t angle, int32_t transp = -1); // Using fixed point maths
|
|
bool pushRotatedHP(int16_t angle, int32_t transp = -1); // Using higher precision floating point maths
|
|
// Push a rotated copy of Sprite to another different Sprite with optional transparent colour
|
|
bool pushRotated(TFT_eSprite *spr, int16_t angle, int32_t transp = -1); // Using fixed point maths
|
|
bool pushRotatedHP(TFT_eSprite *spr, int16_t angle, int32_t transp = -1); // Using higher precision floating point maths
|
|
// Set and get the pivot point for this Sprite
|
|
void setPivot(int16_t x, int16_t y);
|
|
int16_t getPivotX(void),
|
|
getPivotY(void);
|
|
|
|
// Get the bounding box for a rotated copy of this Sprite
|
|
void getRotatedBounds(float sina, float cosa, int16_t w, int16_t h, int16_t xp, int16_t yp,
|
|
int16_t *min_x, int16_t *min_y, int16_t *max_x, int16_t *max_y);
|
|
|
|
// Read the colour of a pixel at x,y and return value in 565 format
|
|
uint16_t readPixel(int32_t x0, int32_t y0);
|
|
|
|
// return the color map index of the pixel at x,y (used when scrolling)
|
|
uint8_t readPixelValue(int32_t x, int32_t y);
|
|
|
|
// Write an image (colour bitmap) to the sprite. Not implemented for _bpp == 4.
|
|
void pushImage(int32_t x0, int32_t y0, int32_t w, int32_t h, uint16_t *data);
|
|
void pushImage(int32_t x0, int32_t y0, int32_t w, int32_t h, const uint16_t *data);
|
|
|
|
// Swap the byte order for pushImage() - corrects different image endianness
|
|
void setSwapBytes(bool swap);
|
|
bool getSwapBytes(void);
|
|
|
|
// Push the sprite to the TFT screen, this fn calls pushImage() in the TFT class.
|
|
// Optionally a "transparent" colour can be defined, pixels of that colour will not be rendered
|
|
void pushSprite(int32_t x, int32_t y);
|
|
void pushSprite(int32_t x, int32_t y, uint16_t transparent);
|
|
|
|
int16_t drawChar(uint16_t uniCode, int32_t x, int32_t y, uint8_t font),
|
|
drawChar(uint16_t uniCode, int32_t x, int32_t y);
|
|
|
|
// Return the width and height of the sprite
|
|
int16_t width(void),
|
|
height(void);
|
|
|
|
// Used by print class to print text to cursor position
|
|
size_t write(uint8_t);
|
|
|
|
// Functions associated with anti-aliased fonts
|
|
void drawGlyph(uint16_t code);
|
|
void printToSprite(String string);
|
|
void printToSprite(char *cbuffer, uint16_t len);
|
|
int16_t printToSprite(int16_t x, int16_t y, uint16_t index);
|
|
|
|
private:
|
|
|
|
TFT_eSPI *_tft;
|
|
|
|
// Reserve memory for the Sprite and return a pointer
|
|
void* callocSprite(int16_t width, int16_t height, uint8_t frames = 1);
|
|
|
|
protected:
|
|
|
|
uint8_t _bpp; // bits per pixel (1, 8 or 16)
|
|
uint16_t *_img; // pointer to 16 bit sprite
|
|
uint8_t *_img8; // pointer to 8 bit sprite
|
|
uint8_t *_img4; // pointer to 4 bit sprite (uses color map)
|
|
uint8_t *_img8_1; // pointer to frame 1
|
|
uint8_t *_img8_2; // pointer to frame 2
|
|
|
|
uint16_t *_colorMap; // color map: 16 entries, used with 4 bit color map.
|
|
|
|
int16_t _xpivot; // x pivot point coordinate
|
|
int16_t _ypivot; // y pivot point coordinate
|
|
|
|
bool _created; // A Sprite has been created and memory reserved
|
|
bool _gFont = false;
|
|
|
|
// int32_t _icursor_x, _icursor_y;
|
|
uint8_t _rotation = 0;
|
|
int32_t _xs, _ys, _xe, _ye, _xptr, _yptr; // for setWindow
|
|
int32_t _sx, _sy; // x,y for scroll zone
|
|
uint32_t _sw, _sh; // w,h for scroll zone
|
|
uint32_t _scolor; // gap fill colour for scroll zone
|
|
|
|
bool _iswapBytes; // Swap the byte order for Sprite pushImage()
|
|
|
|
int32_t _iwidth, _iheight; // Sprite memory image bit width and height (swapped during rotations)
|
|
int32_t _dwidth, _dheight; // Real display width and height (for <8bpp Sprites)
|
|
int32_t _bitwidth; // Sprite image bit width for drawPixel (for <8bpp Sprites, not swapped)
|
|
|
|
};
|