/**************************************************************************************
 // 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.
 // Coded by Bodmer, see license file in root folder
 ***************************************************************************************/
 /***************************************************************************************
 // Color bytes are swapped when writing to RAM, this introduces a small overhead but
 // there is a nett performance gain by using swapped bytes.
 ***************************************************************************************/
 
 /***************************************************************************************
 ** Function name:           TFT_eSprite
 ** Description:             Class constructor
 ***************************************************************************************/
 TFT_eSprite::TFT_eSprite(TFT_eSPI *tft)
 {
   _tft = tft;     // Pointer to tft class so we can call member functions
 
   _iwidth    = 0; // Initialise width and height to 0 (it does not exist yet)
   _iheight   = 0;
   _bpp = 16;
   _swapBytes = false;   // Do not swap pushImage colour bytes by default
 
   _created = false;
   _vpOoB   = true;
 
   _xs = 0;  // window bounds for pushColor
   _ys = 0;
   _xe = 0;
   _ye = 0;
 
   _xptr = 0; // pushColor coordinate
   _yptr = 0;
 
   _colorMap = nullptr;
 
   _psram_enable = true;
   
   // Ensure end_tft_write() does nothing in inherited functions.
   lockTransaction = true;
 }
 
 
 /***************************************************************************************
 ** Function name:           createSprite
 ** Description:             Create a sprite (bitmap) of defined width and height
 ***************************************************************************************/
 // cast returned value to (uint8_t*) for 8 bit or (uint16_t*) for 16 bit colours
 void* TFT_eSprite::createSprite(int16_t w, int16_t h, uint8_t frames)
 {
 
   if ( _created ) return _img8_1;
 
   if ( w < 1 || h < 1 ) return nullptr;
 
   _iwidth  = _dwidth  = _bitwidth = w;
   _iheight = _dheight = h;
 
   cursor_x = 0;
   cursor_y = 0;
 
   // Default scroll rectangle and gap fill colour
   _sx = 0;
   _sy = 0;
   _sw = w;
   _sh = h;
   _scolor = TFT_BLACK;
 
   _img8   = (uint8_t*) callocSprite(w, h, frames);
   _img8_1 = _img8;
   _img8_2 = _img8;
   _img    = (uint16_t*) _img8;
   _img4   = _img8;
 
   if ( (_bpp == 16) && (frames > 1) ) {
     _img8_2 = _img8 + (w * h * 2 + 1);
   }
 
   // ESP32 only 16bpp check
   //if (esp_ptr_dma_capable(_img8_1)) Serial.println("DMA capable Sprite pointer _img8_1");
   //else Serial.println("Not a DMA capable Sprite pointer _img8_1");
   //if (esp_ptr_dma_capable(_img8_2)) Serial.println("DMA capable Sprite pointer _img8_2");
   //else Serial.println("Not a DMA capable Sprite pointer _img8_2");
 
   if ( (_bpp == 8) && (frames > 1) ) {
     _img8_2 = _img8 + (w * h + 1);
   }
 
   if ( (_bpp == 4) && (_colorMap == nullptr)) createPalette(default_4bit_palette);
 
   // This is to make it clear what pointer size is expected to be used
   // but casting in the user sketch is needed due to the use of void*
   if ( (_bpp == 1) && (frames > 1) )
   {
     w = (w+7) & 0xFFF8;
     _img8_2 = _img8 + ( (w>>3) * h + 1 );
   }
 
   if (_img8)
   {
     _created = true;
     rotation = 0;
     setViewport(0, 0, _dwidth, _dheight);
     setPivot(_iwidth/2, _iheight/2);
     return _img8_1;
   }
 
   return nullptr;
 }
 
 
 /***************************************************************************************
 ** Function name:           getPointer
 ** Description:             Returns pointer to start of sprite memory area
 ***************************************************************************************/
 void* TFT_eSprite::getPointer(void)
 {
   if (!_created) return nullptr;
   return _img8_1;
 }
 
 
 /***************************************************************************************
 ** Function name:           created
 ** Description:             Returns true if sprite has been created
 ***************************************************************************************/
 bool TFT_eSprite::created(void)
 {
   return _created;
 }
 
 
 /***************************************************************************************
 ** Function name:           ~TFT_eSprite
 ** Description:             Class destructor
 ***************************************************************************************/
 TFT_eSprite::~TFT_eSprite(void)
 {
   deleteSprite();
 
 #ifdef SMOOTH_FONT
   if(fontLoaded) unloadFont();
 #endif
 }
 
 
 /***************************************************************************************
 ** Function name:           callocSprite
 ** Description:             Allocate a memory area for the Sprite and return pointer
 ***************************************************************************************/
 void* TFT_eSprite::callocSprite(int16_t w, int16_t h, uint8_t frames)
 {
   // Add one extra "off screen" pixel to point out-of-bounds setWindow() coordinates
   // this means push/writeColor functions do not need additional bounds checks and
   // hence will run faster in normal circumstances.
   uint8_t* ptr8 = nullptr;
 
   if (frames > 2) frames = 2; // Currently restricted to 2 frame buffers
   if (frames < 1) frames = 1;
 
   if (_bpp == 16)
   {
 #if defined (ESP32) && defined (CONFIG_SPIRAM_SUPPORT)
     if ( psramFound() && _psram_enable && !_tft->DMA_Enabled)
     {
       ptr8 = ( uint8_t*) ps_calloc(frames * w * h + frames, sizeof(uint16_t));
       //Serial.println("PSRAM");
     }
     else
 #endif
     {
       ptr8 = ( uint8_t*) calloc(frames * w * h + frames, sizeof(uint16_t));
       //Serial.println("Normal RAM");
     }
   }
 
   else if (_bpp == 8)
   {
 #if defined (ESP32) && defined (CONFIG_SPIRAM_SUPPORT)
     if ( psramFound() && _psram_enable ) ptr8 = ( uint8_t*) ps_calloc(frames * w * h + frames, sizeof(uint8_t));
     else
 #endif
     ptr8 = ( uint8_t*) calloc(frames * w * h + frames, sizeof(uint8_t));
   }
 
   else if (_bpp == 4)
   {
     w = (w+1) & 0xFFFE; // width needs to be multiple of 2, with an extra "off screen" pixel
     _iwidth = w;
 #if defined (ESP32) && defined (CONFIG_SPIRAM_SUPPORT)
     if ( psramFound() && _psram_enable ) ptr8 = ( uint8_t*) ps_calloc(((frames * w * h) >> 1) + frames, sizeof(uint8_t));
     else
 #endif
     ptr8 = ( uint8_t*) calloc(((frames * w * h) >> 1) + frames, sizeof(uint8_t));
   }
 
   else // Must be 1 bpp
   {
     //_dwidth   Display width+height in pixels always in rotation 0 orientation
     //_dheight  Not swapped for sprite rotations
     // Note: for 1bpp _iwidth and _iheight are swapped during Sprite rotations
 
     w =  (w+7) & 0xFFF8; // width should be the multiple of 8 bits to be compatible with epdpaint
     _iwidth = w;         // _iwidth is rounded up to be multiple of 8, so might not be = _dwidth
     _bitwidth = w;       // _bitwidth will not be rotated whereas _iwidth may be
 
 #if defined (ESP32) && defined (CONFIG_SPIRAM_SUPPORT)
     if ( psramFound() && _psram_enable ) ptr8 = ( uint8_t*) ps_calloc(frames * (w>>3) * h + frames, sizeof(uint8_t));
     else
 #endif
     ptr8 = ( uint8_t*) calloc(frames * (w>>3) * h + frames, sizeof(uint8_t));
   }
 
   return ptr8;
 }
 
 
 /***************************************************************************************
 ** Function name:           createPalette (from RAM array)
 ** Description:             Set a palette for a 4-bit per pixel sprite
 ***************************************************************************************/
 void TFT_eSprite::createPalette(uint16_t colorMap[], uint8_t colors)
 {
   if (!_created) return;
 
   if (colorMap == nullptr)
   {
     // Create a color map using the default FLASH map
     createPalette(default_4bit_palette);
     return;
   }
 
   // Allocate and clear memory for 16 color map
   if (_colorMap == nullptr) _colorMap = (uint16_t *)calloc(16, sizeof(uint16_t));
 
   if (colors > 16) colors = 16;
 
   // Copy map colors
   for (uint8_t i = 0; i < colors; i++)
   {
     _colorMap[i] = colorMap[i];
   }
 }
 
 
 /***************************************************************************************
 ** Function name:           createPalette (from FLASH array)
 ** Description:             Set a palette for a 4-bit per pixel sprite
 ***************************************************************************************/
 void TFT_eSprite::createPalette(const uint16_t colorMap[], uint8_t colors)
 {
   if (!_created) return;
 
   if (colorMap == nullptr)
   {
     // Create a color map using the default FLASH map
     colorMap = default_4bit_palette;
   }
 
   // Allocate and clear memory for 16 color map
   if (_colorMap == nullptr) _colorMap = (uint16_t *)calloc(16, sizeof(uint16_t));
 
   if (colors > 16) colors = 16;
 
   // Copy map colors
   for (uint8_t i = 0; i < colors; i++)
   {
     _colorMap[i] = pgm_read_word(colorMap++);
   }
 }
 
 
 /***************************************************************************************
 ** Function name:           frameBuffer
 ** Description:             For 1 bpp Sprites, select the frame used for graphics
 ***************************************************************************************/
 // Frames are numbered 1 and 2
 void* TFT_eSprite::frameBuffer(int8_t f)
 {
   if (!_created) return nullptr;
 
   if ( f == 2 ) _img8 = _img8_2;
   else          _img8 = _img8_1;
 
   if (_bpp == 16) _img = (uint16_t*)_img8;
 
   //if (_bpp == 8) _img8 = _img8;
 
   if (_bpp == 4) _img4 = _img8;
 
   return _img8;
 }
 
 
 /***************************************************************************************
 ** Function name:           setColorDepth
 ** Description:             Set bits per pixel for colour (1, 8 or 16)
 ***************************************************************************************/
 void* TFT_eSprite::setColorDepth(int8_t b)
 {
   // Do not re-create the sprite if the colour depth does not change
   if (_bpp == b) return _img8_1;
 
   // Validate the new colour depth
   if ( b > 8 ) _bpp = 16;  // Bytes per pixel
   else if ( b > 4 ) _bpp = 8;
   else if ( b > 1 ) _bpp = 4;
   else _bpp = 1;
 
   // Can't change an existing sprite's colour depth so delete and create a new one
   if (_created) {
     deleteSprite();
     return createSprite(_dwidth, _dheight);
   }
 
   return nullptr;
 }
 
 
 /***************************************************************************************
 ** Function name:           getColorDepth
 ** Description:             Get bits per pixel for colour (1, 8 or 16)
 ***************************************************************************************/
 int8_t TFT_eSprite::getColorDepth(void)
 {
   if (_created) return _bpp;
   else return 0;
 }
 
 
 /***************************************************************************************
 ** Function name:           setBitmapColor
 ** Description:             Set the 1bpp foreground foreground and background colour
 ***************************************************************************************/
 void TFT_eSprite::setBitmapColor(uint16_t c, uint16_t b)
 {
   if (c == b) b = ~c;
   _tft->bitmap_fg = c;
   _tft->bitmap_bg = b;
 }
 
 
 /***************************************************************************************
 ** Function name:           setPaletteColor
 ** Description:             Set the 4bpp palette color at the given index
 ***************************************************************************************/
 void TFT_eSprite::setPaletteColor(uint8_t index, uint16_t color)
 {
   if (_colorMap == nullptr || index > 15) return; // out of bounds
 
   _colorMap[index] = color;
 }
 
 
 /***************************************************************************************
 ** Function name:           getPaletteColor
 ** Description:             Return the palette color at 4bpp index, or 0 on error.
 ***************************************************************************************/
 uint16_t TFT_eSprite::getPaletteColor(uint8_t index)
 {
   if (_colorMap == nullptr || index > 15) return 0; // out of bounds
 
   return _colorMap[index];
 }
 
 
 /***************************************************************************************
 ** Function name:           deleteSprite
 ** Description:             Delete the sprite to free up memory (RAM)
 ***************************************************************************************/
 void TFT_eSprite::deleteSprite(void)
 {
   if (_colorMap != nullptr)
   {
     free(_colorMap);
     _colorMap = nullptr;
   }
 
   if (_created)
   {
     free(_img8_1);
     _img8 = nullptr;
     _created = false;
     _vpOoB   = true;  // TFT_eSPI class write() uses this to check for valid sprite
   }
 }
 
 
 /***************************************************************************************
 ** Function name:           pushRotated - Fast fixed point integer maths version
 ** Description:             Push rotated Sprite to TFT screen
 ***************************************************************************************/
 #define FP_SCALE 10
 bool TFT_eSprite::pushRotated(int16_t angle, uint32_t transp)
 {
   if ( !_created || _tft->_vpOoB) return false;
 
   // Bounding box parameters
   int16_t min_x;
   int16_t min_y;
   int16_t max_x;
   int16_t max_y;
 
   // Get the bounding box of this rotated source Sprite relative to Sprite pivot
   if ( !getRotatedBounds(angle, &min_x, &min_y, &max_x, &max_y) ) return false;
 
   uint16_t sline_buffer[max_x - min_x + 1];
 
   int32_t xt = min_x - _tft->_xPivot;
   int32_t yt = min_y - _tft->_yPivot;
   uint32_t xe = _dwidth << FP_SCALE;
   uint32_t ye = _dheight << FP_SCALE;
   uint16_t tpcolor = (uint16_t)transp;
 
   if (transp != 0x00FFFFFF) {
     if (_bpp == 4) tpcolor = _colorMap[transp & 0x0F];
     tpcolor = tpcolor>>8 | tpcolor<<8; // Working with swapped color bytes
   }
   _tft->startWrite(); // Avoid transaction overhead for every tft pixel
 
   // Scan destination bounding box and fetch transformed pixels from source Sprite
   for (int32_t y = min_y; y <= max_y; y++, yt++) {
     int32_t x = min_x;
     uint32_t xs = (_cosra * xt - (_sinra * yt - (_xPivot << FP_SCALE)) + (1 << (FP_SCALE - 1)));
     uint32_t ys = (_sinra * xt + (_cosra * yt + (_yPivot << FP_SCALE)) + (1 << (FP_SCALE - 1)));
 
     while ((xs >= xe || ys >= ye) && x < max_x) { x++; xs += _cosra; ys += _sinra; }
     if (x == max_x) continue;
 
     uint32_t pixel_count = 0;
     do {
       uint32_t rp;
       int32_t xp = xs >> FP_SCALE;
       int32_t yp = ys >> FP_SCALE;
       if (_bpp == 16) {rp = _img[xp + yp * _iwidth]; }
       else { rp = readPixel(xp, yp); rp = (uint16_t)(rp>>8 | rp<<8); }
       if (transp != 0x00FFFFFF && tpcolor == rp) {
         if (pixel_count) {
           // TFT window is already clipped, so this is faster than pushImage()
           _tft->setWindow(x - pixel_count, y, x - 1, y);
           _tft->pushPixels(sline_buffer, pixel_count);
           pixel_count = 0;
         }
       }
       else {
         sline_buffer[pixel_count++] = rp;
       }
     } while (++x < max_x && (xs += _cosra) < xe && (ys += _sinra) < ye);
     if (pixel_count) {
       // TFT window is already clipped, so this is faster than pushImage()
       _tft->setWindow(x - pixel_count, y, x - 1, y);
       _tft->pushPixels(sline_buffer, pixel_count);
     }
   }
 
   _tft->endWrite(); // End transaction
 
   return true;
 }
 
 
 /***************************************************************************************
 ** Function name:           pushRotated - Fast fixed point integer maths version
 ** Description:             Push a rotated copy of the Sprite to another Sprite
 ***************************************************************************************/
 // Not compatible with 4bpp
 bool TFT_eSprite::pushRotated(TFT_eSprite *spr, int16_t angle, uint32_t transp)
 {
   if ( !_created  || _bpp == 4) return false; // Check this Sprite is created
   if ( !spr->_created  || spr->_bpp == 4) return false;  // Ckeck destination Sprite is created
 
   // Bounding box parameters
   int16_t min_x;
   int16_t min_y;
   int16_t max_x;
   int16_t max_y;
 
   // Get the bounding box of this rotated source Sprite
   if ( !getRotatedBounds(spr, angle, &min_x, &min_y, &max_x, &max_y) ) return false;
 
   uint16_t sline_buffer[max_x - min_x + 1];
 
   int32_t xt = min_x - spr->_xPivot;
   int32_t yt = min_y - spr->_yPivot;
   uint32_t xe = _dwidth << FP_SCALE;
   uint32_t ye = _dheight << FP_SCALE;
   uint16_t tpcolor = (uint16_t)transp;
   
   if (transp != 0x00FFFFFF) {
     if (_bpp == 4) tpcolor = _colorMap[transp & 0x0F];
     tpcolor = tpcolor>>8 | tpcolor<<8; // Working with swapped color bytes
   }
 
   bool oldSwapBytes = spr->getSwapBytes();
   spr->setSwapBytes(false);
 
   // Scan destination bounding box and fetch transformed pixels from source Sprite
   for (int32_t y = min_y; y <= max_y; y++, yt++) {
     int32_t x = min_x;
     uint32_t xs = (_cosra * xt - (_sinra * yt - (_xPivot << FP_SCALE)) + (1 << (FP_SCALE - 1)));
     uint32_t ys = (_sinra * xt + (_cosra * yt + (_yPivot << FP_SCALE)) + (1 << (FP_SCALE - 1)));
 
     while ((xs >= xe || ys >= ye) && x < max_x) { x++; xs += _cosra; ys += _sinra; }
     if (x == max_x) continue;
 
     uint32_t pixel_count = 0;
     do {
       uint32_t rp;
       int32_t xp = xs >> FP_SCALE;
       int32_t yp = ys >> FP_SCALE;
       if (_bpp == 16) rp = _img[xp + yp * _iwidth];
       else { rp = readPixel(xp, yp); rp = (uint16_t)(rp>>8 | rp<<8); }
       if (transp != 0x00FFFFFF && tpcolor == rp) {
         if (pixel_count) {
           spr->pushImage(x - pixel_count, y, pixel_count, 1, sline_buffer);
           pixel_count = 0;
         }
       }
       else {
         sline_buffer[pixel_count++] = rp;
       }
     } while (++x < max_x && (xs += _cosra) < xe && (ys += _sinra) < ye);
     if (pixel_count) spr->pushImage(x - pixel_count, y, pixel_count, 1, sline_buffer);
   }
   spr->setSwapBytes(oldSwapBytes);
   return true;
 }
 
 
 /***************************************************************************************
 ** Function name:           getRotatedBounds
 ** Description:             Get TFT bounding box of a rotated Sprite wrt pivot
 ***************************************************************************************/
 bool TFT_eSprite::getRotatedBounds(int16_t angle, int16_t *min_x, int16_t *min_y,
                                                   int16_t *max_x, int16_t *max_y)
 {
   // Get the bounding box of this rotated source Sprite relative to Sprite pivot
   getRotatedBounds(angle, width(), height(), _xPivot, _yPivot, min_x, min_y, max_x, max_y);
 
   // Move bounding box so source Sprite pivot coincides with TFT pivot
   *min_x += _tft->_xPivot;
   *max_x += _tft->_xPivot;
   *min_y += _tft->_yPivot;
   *max_y += _tft->_yPivot;
 
   // Return if bounding box is outside of TFT viewport
   if (*min_x > _tft->_vpW) return false;
   if (*min_y > _tft->_vpH) return false;
   if (*max_x < _tft->_vpX) return false;
   if (*max_y < _tft->_vpY) return false;
 
   // Clip bounding box to be within TFT viewport
   if (*min_x < _tft->_vpX) *min_x = _tft->_vpX;
   if (*min_y < _tft->_vpY) *min_y = _tft->_vpY;
   if (*max_x > _tft->_vpW) *max_x = _tft->_vpW;
   if (*max_y > _tft->_vpH) *max_y = _tft->_vpH;
 
   return true;
 }
 
 
 /***************************************************************************************
 ** Function name:           getRotatedBounds
 ** Description:             Get destination Sprite bounding box of a rotated Sprite wrt pivot
 ***************************************************************************************/
 bool TFT_eSprite::getRotatedBounds(TFT_eSprite *spr, int16_t angle, int16_t *min_x, int16_t *min_y,
                                                                     int16_t *max_x, int16_t *max_y)
 {
   // Get the bounding box of this rotated source Sprite relative to Sprite pivot
   getRotatedBounds(angle, width(), height(), _xPivot, _yPivot, min_x, min_y, max_x, max_y);
 
   // Move bounding box so source Sprite pivot coincides with destination Sprite pivot
   *min_x += spr->_xPivot;
   *max_x += spr->_xPivot;
   *min_y += spr->_yPivot;
   *max_y += spr->_yPivot;
 
   // Test only to show bounding box
   // spr->fillSprite(TFT_BLACK);
   // spr->drawRect(min_x, min_y, max_x - min_x + 1, max_y - min_y + 1, TFT_GREEN);
 
   // Return if bounding box is completely outside of destination Sprite
   if (*min_x > spr->width()) return true;
   if (*min_y > spr->height()) return true;
   if (*max_x < 0) return true;
   if (*max_y < 0) return true;
 
   // Clip bounding box to Sprite boundaries
   // Clipping to a viewport will be done by destination Sprite pushImage function
   if (*min_x < 0) min_x = 0;
   if (*min_y < 0) min_y = 0;
   if (*max_x > spr->width())  *max_x = spr->width();
   if (*max_y > spr->height()) *max_y = spr->height();
 
   return true;
 }
 
 
 /***************************************************************************************
 ** Function name:           rotatedBounds
 ** Description:             Get bounding box of a rotated Sprite wrt pivot
 ***************************************************************************************/
 void TFT_eSprite::getRotatedBounds(int16_t angle, 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)
 {
   // Trig values for the rotation
   float radAngle = -angle * 0.0174532925; // Convert degrees to radians
   float sina = sin(radAngle);
   float cosa = cos(radAngle);
 
   w -= xp; // w is now right edge coordinate relative to xp
   h -= yp; // h is now bottom edge coordinate relative to yp
 
   // Calculate new corner coordinates
   int16_t x0 = -xp * cosa - yp * sina;
   int16_t y0 =  xp * sina - yp * cosa;
 
   int16_t x1 =  w * cosa - yp * sina;
   int16_t y1 = -w * sina - yp * cosa;
 
   int16_t x2 =  h * sina + w * cosa;
   int16_t y2 =  h * cosa - w * sina;
 
   int16_t x3 =  h * sina - xp * cosa;
   int16_t y3 =  h * cosa + xp * sina;
 
   // Find bounding box extremes, enlarge box to accomodate rounding errors
   *min_x = x0-2;
   if (x1 < *min_x) *min_x = x1-2;
   if (x2 < *min_x) *min_x = x2-2;
   if (x3 < *min_x) *min_x = x3-2;
 
   *max_x = x0+2;
   if (x1 > *max_x) *max_x = x1+2;
   if (x2 > *max_x) *max_x = x2+2;
   if (x3 > *max_x) *max_x = x3+2;
 
   *min_y = y0-2;
   if (y1 < *min_y) *min_y = y1-2;
   if (y2 < *min_y) *min_y = y2-2;
   if (y3 < *min_y) *min_y = y3-2;
 
   *max_y = y0+2;
   if (y1 > *max_y) *max_y = y1+2;
   if (y2 > *max_y) *max_y = y2+2;
   if (y3 > *max_y) *max_y = y3+2;
 
   _sinra = round(sina * (1<<FP_SCALE));
   _cosra = round(cosa * (1<<FP_SCALE));
 }
 
 
 /***************************************************************************************
 ** Function name:           pushSprite
 ** Description:             Push the sprite to the TFT at x, y
 ***************************************************************************************/
 void TFT_eSprite::pushSprite(int32_t x, int32_t y)
 {
   if (!_created) return;
 
   if (_bpp == 16)
   {
     bool oldSwapBytes = _tft->getSwapBytes();
     _tft->setSwapBytes(false);
     _tft->pushImage(x, y, _dwidth, _dheight, _img );
     _tft->setSwapBytes(oldSwapBytes);
   }
   else if (_bpp == 4)
   {
     _tft->pushImage(x, y, _dwidth, _dheight, _img4, false, _colorMap);
   }
   else _tft->pushImage(x, y, _dwidth, _dheight, _img8, (bool)(_bpp == 8));
 }
 
 
 /***************************************************************************************
 ** Function name:           pushSprite
 ** Description:             Push the sprite to the TFT at x, y with transparent colour
 ***************************************************************************************/
 void TFT_eSprite::pushSprite(int32_t x, int32_t y, uint16_t transp)
 {
   if (!_created) return;
 
   if (_bpp == 16)
   {
     bool oldSwapBytes = _tft->getSwapBytes();
     _tft->setSwapBytes(false);
     _tft->pushImage(x, y, _dwidth, _dheight, _img, transp );
     _tft->setSwapBytes(oldSwapBytes);
   }
   else if (_bpp == 8)
   {
     transp = (uint8_t)((transp & 0xE000)>>8 | (transp & 0x0700)>>6 | (transp & 0x0018)>>3);
     _tft->pushImage(x, y, _dwidth, _dheight, _img8, (uint8_t)transp, (bool)true);
   }
   else if (_bpp == 4)
   {
     _tft->pushImage(x, y, _dwidth, _dheight, _img4, (uint8_t)(transp & 0x0F), false, _colorMap);
   }
   else _tft->pushImage(x, y, _dwidth, _dheight, _img8, 0, (bool)false);
 }
 
 
 /***************************************************************************************
 ** Function name:           pushToSprite
 ** Description:             Push the sprite to another sprite at x, y
 ***************************************************************************************/
 // Note: The following sprite to sprite colour depths are currently supported:
 //    Source    Destination
 //    16bpp  -> 16bpp
 //    16bpp  ->  8bpp
 //     8bpp  ->  8bpp
 //     4bpp  ->  4bpp (note: color translation depends on the 2 sprites palette colors)
 //     1bpp  ->  1bpp (note: color translation depends on the 2 sprites bitmap colors)
 
 bool TFT_eSprite::pushToSprite(TFT_eSprite *dspr, int32_t x, int32_t y)
 {
   if (!_created) return false;
   if (!dspr->created()) return false;
 
   // Check destination sprite compatibility
   int8_t ds_bpp = dspr->getColorDepth();
   if (_bpp == 16 && ds_bpp != 16 && ds_bpp !=  8) return false;
   if (_bpp ==  8 && ds_bpp !=  8) return false;
   if (_bpp ==  4 && ds_bpp !=  4) return false;
   if (_bpp ==  1 && ds_bpp !=  1) return false;
 
   bool oldSwapBytes = dspr->getSwapBytes();
   dspr->setSwapBytes(false);
   dspr->pushImage(x, y, _dwidth, _dheight, _img, _bpp);
   dspr->setSwapBytes(oldSwapBytes);
 
   return true;
 }
 
 
 /***************************************************************************************
 ** Function name:           pushToSprite
 ** Description:             Push the sprite to another sprite at x, y with transparent colour
 ***************************************************************************************/
 // Note: The following sprite to sprite colour depths are currently supported:
 //    Source    Destination
 //    16bpp  -> 16bpp
 //    16bpp  ->  8bpp
 //     8bpp  ->  8bpp
 //     1bpp  ->  1bpp
 
 bool TFT_eSprite::pushToSprite(TFT_eSprite *dspr, int32_t x, int32_t y, uint16_t transp)
 {
   if ( !_created  || !dspr->_created) return false; // Check Sprites exist
 
   // Check destination sprite compatibility
   int8_t ds_bpp = dspr->getColorDepth();
   if (_bpp == 16 && ds_bpp != 16 && ds_bpp !=  8) return false;
   if (_bpp ==  8 && ds_bpp !=  8) return false;
   if (_bpp ==  4 || ds_bpp ==  4) return false;
   if (_bpp ==  1 && ds_bpp !=  1) return false;
 
   bool oldSwapBytes = dspr->getSwapBytes();
   uint16_t sline_buffer[width()];
 
   transp = transp>>8 | transp<<8;
 
   // Scan destination bounding box and fetch transformed pixels from source Sprite
   for (int32_t ys = 0; ys < height(); ys++) {
     int32_t ox = x;
     uint32_t pixel_count = 0;
 
     for (int32_t xs = 0; xs < width(); xs++) {
       uint16_t rp = 0;
       if (_bpp == 16) rp = _img[xs + ys * width()];
       else { rp = readPixel(xs, ys); rp = rp>>8 | rp<<8; }
       //dspr->drawPixel(xs, ys, rp);
 
       if (transp == rp) {
         if (pixel_count) {
           dspr->pushImage(ox, y, pixel_count, 1, sline_buffer, _bpp);
           ox += pixel_count;
           pixel_count = 0;
         }
         ox++;
       }
       else {
         sline_buffer[pixel_count++] = rp;
       }
     }
     if (pixel_count) dspr->pushImage(ox, y, pixel_count, 1, sline_buffer);
     y++;
   }
   dspr->setSwapBytes(oldSwapBytes);
   return true;
 }
 
 
 /***************************************************************************************
 ** Function name:           pushSprite
 ** Description:             Push a cropped sprite to the TFT at tx, ty
 ***************************************************************************************/
 bool TFT_eSprite::pushSprite(int32_t tx, int32_t ty, int32_t sx, int32_t sy, int32_t sw, int32_t sh)
 {
   if (!_created) return false;
 
   // Perform window boundary checks and crop if needed
   setWindow(sx, sy, sx + sw - 1, sy + sh - 1);
 
   /* These global variables are now populated for the sprite
   _xs = x start coordinate
   _ys = y start coordinate
   _xe = x end coordinate (inclusive)
   _ye = y end coordinate (inclusive)
   */
 
   // Calculate new sprite window bounding box width and height
   sw = _xe - _xs + 1;
   sh = _ye - _ys + 1;
 
   if (_ys >= _iheight) return false;
 
   if (_bpp == 16)
   {
     bool oldSwapBytes = _tft->getSwapBytes();
     _tft->setSwapBytes(false);
 
     // Check if a faster block copy to screen is possible
     if ( sx == 0 && sw == _dwidth)
       _tft->pushImage(tx, ty, sw, sh, _img + _iwidth * _ys );
     else // Render line by line
       while (sh--)
         _tft->pushImage(tx, ty++, sw, 1, _img + _xs + _iwidth * _ys++ );
 
     _tft->setSwapBytes(oldSwapBytes);
   }
   else if (_bpp == 8)
   {
     // Check if a faster block copy to screen is possible
     if ( sx == 0 && sw == _dwidth)
       _tft->pushImage(tx, ty, sw, sh, _img8 + _iwidth * _ys, (bool)true );
     else // Render line by line
     while (sh--)
       _tft->pushImage(tx, ty++, sw, 1, _img8 + _xs + _iwidth * _ys++, (bool)true );
   }
   else if (_bpp == 4)
   {
     // Check if a faster block copy to screen is possible
     if ( sx == 0 && sw == _dwidth)
       _tft->pushImage(tx, ty, sw, sh, _img4 + (_iwidth>>1) * _ys, false, _colorMap );
     else // Render line by line
     {
       int32_t ds = _xs&1; // Odd x start pixel
 
       int32_t de = 0;     // Odd x end pixel
       if ((sw > ds) && (_xe&1)) de = 1;
 
       uint32_t dm = 0;     // Midsection pixel count
       if (sw > (ds+de)) dm = sw - ds - de;
       sw--;
 
       uint32_t yp = (_xs + ds + _iwidth * _ys)>>1;
       _tft->startWrite();
       while (sh--)
       {
         if (ds) _tft->drawPixel(tx, ty, readPixel(_xs, _ys) );
         if (dm) _tft->pushImage(tx + ds, ty, dm, 1, _img4 + yp, false, _colorMap );
         if (de) _tft->drawPixel(tx + sw, ty, readPixel(_xe, _ys) );
         _ys++;
         ty++;
         yp += (_iwidth>>1);
       }
       _tft->endWrite();
     }
   }
   else // 1bpp
   {
     // Check if a faster block copy to screen is possible
     if ( sx == 0 && sw == _dwidth)
       _tft->pushImage(tx, ty, sw, sh, _img8 + (_bitwidth>>3) * _ys, (bool)false );
     else // Render line by line
     {
       _tft->startWrite();
       while (sh--)
       {
         _tft->pushImage(tx, ty++, sw, 1, _img8 + (_bitwidth>>3) * _ys++, (bool)false );
       }
       _tft->endWrite();
     }
   }
 
   return true;
 }
 
 
 /***************************************************************************************
 ** Function name:           readPixelValue
 ** Description:             Read the color map index of a pixel at defined coordinates
 ***************************************************************************************/
 uint16_t TFT_eSprite::readPixelValue(int32_t x, int32_t y)
 {
   if (_vpOoB  || !_created) return 0xFF;
 
   x+= _xDatum;
   y+= _yDatum;
 
   // Range checking
   if ((x < _vpX) || (y < _vpY) ||(x >= _vpW) || (y >= _vpH)) return 0xFF;
 
   if (_bpp == 16)
   {
     // Return the pixel colour
     return readPixel(x - _xDatum, y - _yDatum);
   }
 
   if (_bpp == 8)
   {
     // Return the pixel byte value
     return _img8[x + y * _iwidth];
   }
 
   if (_bpp == 4)
   {
     if (x >= _dwidth) return 0xFF;
     if ((x & 0x01) == 0)
       return _img4[((x+y*_iwidth)>>1)] >> 4;   // even index = bits 7 .. 4
     else
       return _img4[((x+y*_iwidth)>>1)] & 0x0F; // odd index = bits 3 .. 0.
   }
 
   if (_bpp == 1)
   {
     // Note: _dwidth and _dheight bounds not checked (rounded up -iwidth and _iheight used)
     if (rotation == 1)
     {
       uint16_t tx = x;
       x = _dheight - y - 1;
       y = tx;
     }
     else if (rotation == 2)
     {
       x = _dwidth - x - 1;
       y = _dheight - y - 1;
     }
     else if (rotation == 3)
     {
       uint16_t tx = x;
       x = y;
       y = _dwidth - tx - 1;
     }
     // Return 1 or 0
     return (_img8[(x + y * _bitwidth)>>3] >> (7-(x & 0x7))) & 0x01;
   }
 
   return 0;
 }
 
 /***************************************************************************************
 ** Function name:           readPixel
 ** Description:             Read 565 colour of a pixel at defined coordinates
 ***************************************************************************************/
 uint16_t TFT_eSprite::readPixel(int32_t x, int32_t y)
 {
   if (_vpOoB  || !_created) return 0xFFFF;
 
   x+= _xDatum;
   y+= _yDatum;
 
   // Range checking
   if ((x < _vpX) || (y < _vpY) ||(x >= _vpW) || (y >= _vpH)) return 0xFFFF;
 
   if (_bpp == 16)
   {
     uint16_t color = _img[x + y * _iwidth];
     return (color >> 8) | (color << 8);
   }
 
   if (_bpp == 8)
   {
     uint16_t color = _img8[x + y * _iwidth];
     if (color != 0)
     {
     uint8_t  blue[] = {0, 11, 21, 31};
       color =   (color & 0xE0)<<8 | (color & 0xC0)<<5
               | (color & 0x1C)<<6 | (color & 0x1C)<<3
               | blue[color & 0x03];
     }
     return color;
   }
 
   if (_bpp == 4)
   {
     if (x >= _dwidth) return 0xFFFF;
     uint16_t color;
     if ((x & 0x01) == 0)
       color = _colorMap[_img4[((x+y*_iwidth)>>1)] >> 4];   // even index = bits 7 .. 4
     else
       color = _colorMap[_img4[((x+y*_iwidth)>>1)] & 0x0F]; // odd index = bits 3 .. 0.
     return color;
   }
 
   // Note: Must be 1bpp
   // _dwidth and _dheight bounds not checked (rounded up -iwidth and _iheight used)
   if (rotation == 1)
   {
     uint16_t tx = x;
     x = _dheight - y - 1;
     y = tx;
   }
   else if (rotation == 2)
   {
     x = _dwidth - x - 1;
     y = _dheight - y - 1;
   }
   else if (rotation == 3)
   {
     uint16_t tx = x;
     x = y;
     y = _dwidth - tx - 1;
   }
 
   uint16_t color = (_img8[(x + y * _bitwidth)>>3] << (x & 0x7)) & 0x80;
 
   if (color) return _tft->bitmap_fg;
   else       return _tft->bitmap_bg;
 }
 
 
 /***************************************************************************************
 ** Function name:           pushImage
 ** Description:             push image into a defined area of a sprite
 ***************************************************************************************/
 void  TFT_eSprite::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t *data, uint8_t sbpp)
 {
   if (data == nullptr || !_created) return;
 
   PI_CLIP;
 
   if (_bpp == 16) // Plot a 16 bpp image into a 16 bpp Sprite
   {
     // Pointer within original image
     uint8_t *ptro = (uint8_t *)data + ((dx + dy * w) << 1);
     // Pointer within sprite image
     uint8_t *ptrs = (uint8_t *)_img + ((x + y * _iwidth) << 1);
 
     if(_swapBytes)
     {
       while (dh--)
       {
         // Fast copy with a 1 byte shift
         memcpy(ptrs+1, ptro, (dw<<1) - 1);
         // Now correct just the even numbered bytes
         for (int32_t xp = 0; xp < (dw<<1); xp+=2)
         {
           ptrs[xp] = ptro[xp+1];;
         }
         ptro += w<<1;
         ptrs += _iwidth<<1;
       }
     }
     else
     {
       while (dh--)
       {
         memcpy(ptrs, ptro, dw<<1);
         ptro += w << 1;
         ptrs += _iwidth << 1;
       }
     }
   }
   else if (_bpp == 8 && sbpp == 8) // Plot a 8 bpp image into a 8 bpp Sprite
   {
     // Pointer within original image
     uint8_t *ptro = (uint8_t *)data + (dx + dy * w);
     // Pointer within sprite image
     uint8_t *ptrs = (uint8_t *)_img + (x + y * _iwidth);
 
     while (dh--)
     {
       memcpy(ptrs, ptro, dw);
       ptro += w;
       ptrs += _iwidth;
     }
   }
   else if (_bpp == 8) // Plot a 16 bpp image into a 8 bpp Sprite
   {
     uint16_t lastColor = 0;
     uint8_t  color8    = 0;
     for (int32_t yp = dy; yp < dy + dh; yp++)
     {
       int32_t xyw = x + y * _iwidth;
       int32_t dxypw = dx + yp * w;
       for (int32_t xp = dx; xp < dx + dw; xp++)
       {
         uint16_t color = data[dxypw++];
         if (color != lastColor) {
           // When data source is a sprite, the bytes are already swapped
           if(!_swapBytes) color8 = (uint8_t)((color & 0xE0) | (color & 0x07)<<2 | (color & 0x1800)>>11);
           else color8 = (uint8_t)((color & 0xE000)>>8 | (color & 0x0700)>>6 | (color & 0x0018)>>3);
         }
         lastColor = color;
         _img8[xyw++] = color8;
       }
       y++;
     }
   }
   else if (_bpp == 4)
   {
     // The image is assumed to be 4 bit, where each byte corresponds to two pixels.
     // much faster when aligned to a byte boundary, because the alternative is slower, requiring
     // tedious bit operations.
 
     int sWidth = (_iwidth >> 1);
     uint8_t *ptr = (uint8_t *)data;
 
     if ((x & 0x01) == 0 && (dx & 0x01) == 0 && (dw & 0x01) == 0)
     {
       x = (x >> 1) + y * sWidth;
       dw = (dw >> 1);
       dx = (dx >> 1) + dy * (w>>1);
       while (dh--)
       {
         memcpy(_img4 + x, ptr + dx, dw);
         dx += (w >> 1);
         x += sWidth;
       }
     }
     else  // not optimized
     {
       for (int32_t yp = dy; yp < dy + dh; yp++)
       {
         int32_t ox = x;
         for (int32_t xp = dx; xp < dx + dw; xp++)
         {
           uint32_t color;
           if ((xp & 0x01) == 0)
             color = (ptr[((xp+yp*w)>>1)] & 0xF0) >> 4; // even index = bits 7 .. 4
           else
             color = ptr[((xp-1+yp*w)>>1)] & 0x0F;      // odd index = bits 3 .. 0.
           drawPixel(ox, y, color);
           ox++;
         }
         y++;
       }
     }
   }
 
   else // 1bpp
   {
     // Plot a 1bpp image into a 1bpp Sprite
     uint32_t ww =  (w+7)>>3; // Width of source image line in bytes
     uint8_t *ptr = (uint8_t *)data;
     for (int32_t yp = dy;  yp < dy + dh; yp++)
     {
       uint32_t yw = yp * ww;              // Byte starting the line containing source pixel
       int32_t ox = x;
       for (int32_t xp = dx; xp < dx + dw; xp++)
       {
         uint16_t readPixel = (ptr[(xp>>3) + yw] & (0x80 >> (xp & 0x7)) );
         drawPixel(ox++, y, readPixel);
       }
       y++;
     }
   }
 }
 
 
 /***************************************************************************************
 ** Function name:           pushImage
 ** Description:             push 565 colour FLASH (PROGMEM) image into a defined area
 ***************************************************************************************/
 void  TFT_eSprite::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, const uint16_t *data)
 {
 #ifdef ESP32
   pushImage(x, y, w, h, (uint16_t*) data);
 #else
   // Partitioned memory FLASH processor
   if (data == nullptr || !_created) return;
 
   PI_CLIP;
 
   if (_bpp == 16) // Plot a 16 bpp image into a 16 bpp Sprite
   {
     for (int32_t yp = dy; yp < dy + dh; yp++)
     {
       int32_t ox = x;
       for (int32_t xp = dx; xp < dx + dw; xp++)
       {
         uint16_t color = pgm_read_word(data + xp + yp * w);
         if(_swapBytes) color = color<<8 | color>>8;
         _img[ox + y * _iwidth] = color;
         ox++;
       }
       y++;
     }
   }
 
   else if (_bpp == 8) // Plot a 16 bpp image into a 8 bpp Sprite
   {
     for (int32_t yp = dy; yp < dy + dh; yp++)
     {
       int32_t ox = x;
       for (int32_t xp = dx; xp < dx + dw; xp++)
       {
         uint16_t color = pgm_read_word(data + xp + yp * w);
         if(_swapBytes) color = color<<8 | color>>8;
         _img8[ox + y * _iwidth] = (uint8_t)((color & 0xE000)>>8 | (color & 0x0700)>>6 | (color & 0x0018)>>3);
         ox++;
       }
       y++;
     }
   }
 
   else if (_bpp == 4)
   {
     #ifdef TFT_eSPI_DEBUG
     Serial.println("TFT_eSprite::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, const uint16_t *data) not implemented");
     #endif
     return;
   }
 
   else // Plot a 1bpp image into a 1bpp Sprite
   {
     x-= _xDatum;   // Remove offsets, drawPixel will add
     y-= _yDatum;
     uint16_t bsw =  (w+7) >> 3; // Width in bytes of source image line
     uint8_t *ptr = ((uint8_t*)data) + dy * bsw;
     
     while (dh--) {
       int32_t odx = dx;
       int32_t ox  = x;
       while (odx < dx + dw) {
         uint8_t pbyte = pgm_read_byte(ptr + (odx>>3));
         uint8_t mask = 0x80 >> (odx & 7);
         while (mask) {
           uint8_t p = pbyte & mask;
           mask = mask >> 1;
           drawPixel(ox++, y, p);
           odx++;
         }
       }
       ptr += bsw;
       y++;
     }
   }
 #endif // if ESP32 check
 }
 
 
 /***************************************************************************************
 ** Function name:           setWindow
 ** Description:             Set the bounds of a window in the sprite
 ***************************************************************************************/
 // Intentionally not constrained to viewport area, does not manage 1bpp rotations
 void TFT_eSprite::setWindow(int32_t x0, int32_t y0, int32_t x1, int32_t y1)
 {
   if (x0 > x1) transpose(x0, x1);
   if (y0 > y1) transpose(y0, y1);
   
   int32_t w = width();
   int32_t h = height();
 
   if ((x0 >= w) || (x1 < 0) || (y0 >= h) || (y1 < 0))
   { // Point to that extra "off screen" pixel
     _xs = 0;
     _ys = _dheight;
     _xe = 0;
     _ye = _dheight;
   }
   else
   {
     if (x0 < 0) x0 = 0;
     if (x1 >= w) x1 = w - 1;
     if (y0 < 0) y0 = 0;
     if (y1 >= h) y1 = h - 1;
 
     _xs = x0;
     _ys = y0;
     _xe = x1;
     _ye = y1;
   }
 
   _xptr = _xs;
   _yptr = _ys;
 }
 
 
 /***************************************************************************************
 ** Function name:           pushColor
 ** Description:             Send a new pixel to the set window
 ***************************************************************************************/
 void TFT_eSprite::pushColor(uint16_t color)
 {
   if (!_created ) return;
 
   // Write the colour to RAM in set window
   if (_bpp == 16)
     _img [_xptr + _yptr * _iwidth] = (uint16_t) (color >> 8) | (color << 8);
 
   else  if (_bpp == 8)
     _img8[_xptr + _yptr * _iwidth] = (uint8_t )((color & 0xE000)>>8 | (color & 0x0700)>>6 | (color & 0x0018)>>3);
 
   else if (_bpp == 4)
   {
     uint8_t c = (uint8_t)color & 0x0F;
     if ((_xptr & 0x01) == 0) {
       _img4[(_xptr + _yptr * _iwidth)>>1] = (c << 4) | (_img4[(_xptr + _yptr * _iwidth)>>1] & 0x0F);  // new color is in bits 7 .. 4
     }
     else {
       _img4[(_xptr + _yptr * _iwidth)>>1] = (_img4[(_xptr + _yptr * _iwidth)>>1] & 0xF0) | c; // new color is the low bits
     }
   }
 
   else drawPixel(_xptr, _yptr, color);
 
   // Increment x
   _xptr++;
 
   // Wrap on x and y to start, increment y if needed
   if (_xptr > _xe)
   {
     _xptr = _xs;
     _yptr++;
     if (_yptr > _ye) _yptr = _ys;
   }
 
 }
 
 
 /***************************************************************************************
 ** Function name:           pushColor
 ** Description:             Send a "len" new pixels to the set window
 ***************************************************************************************/
 void TFT_eSprite::pushColor(uint16_t color, uint32_t len)
 {
   if (!_created ) return;
 
   uint16_t pixelColor;
 
   if (_bpp == 16)
     pixelColor = (uint16_t) (color >> 8) | (color << 8);
 
   else  if (_bpp == 8)
     pixelColor = (color & 0xE000)>>8 | (color & 0x0700)>>6 | (color & 0x0018)>>3;
 
   else pixelColor = (uint16_t) color; // for 1bpp or 4bpp
 
   while(len--) writeColor(pixelColor);
 }
 
 
 /***************************************************************************************
 ** Function name:           writeColor
 ** Description:             Write a pixel with pre-formatted colour to the set window
 ***************************************************************************************/
 void TFT_eSprite::writeColor(uint16_t color)
 {
   if (!_created ) return;
 
   // Write 16 bit RGB 565 encoded colour to RAM
   if (_bpp == 16) _img [_xptr + _yptr * _iwidth] = color;
 
   // Write 8 bit RGB 332 encoded colour to RAM
   else if (_bpp == 8) _img8[_xptr + _yptr * _iwidth] = (uint8_t) color;
 
   else if (_bpp == 4)
   {
     uint8_t c = (uint8_t)color & 0x0F;
     if ((_xptr & 0x01) == 0)
       _img4[(_xptr + _yptr * _iwidth)>>1] = (c << 4) | (_img4[(_xptr + _yptr * _iwidth)>>1] & 0x0F);  // new color is in bits 7 .. 4
     else
       _img4[(_xptr + _yptr * _iwidth)>>1] = (_img4[(_xptr + _yptr * _iwidth)>>1] & 0xF0) | c; // new color is the low bits (x is odd)
   }
 
   else drawPixel(_xptr, _yptr, color);
 
   // Increment x
   _xptr++;
 
   // Wrap on x and y to start, increment y if needed
   if (_xptr > _xe)
   {
     _xptr = _xs;
     _yptr++;
     if (_yptr > _ye) _yptr = _ys;
   }
 }
 
 
 /***************************************************************************************
 ** Function name:           setScrollRect
 ** Description:             Set scroll area within the sprite and the gap fill colour
 ***************************************************************************************/
 // Intentionally not constrained to viewport area
 void TFT_eSprite::setScrollRect(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t color)
 {
   if ((x >= _iwidth) || (y >= _iheight) || !_created ) return;
 
   if (x < 0) { w += x; x = 0; }
   if (y < 0) { h += y; y = 0; }
 
   if ((x + w) > _iwidth ) w = _iwidth  - x;
   if ((y + h) > _iheight) h = _iheight - y;
 
   if ( w < 1 || h < 1) return;
 
   _sx = x;
   _sy = y;
   _sw = w;
   _sh = h;
 
   _scolor = color;
 }
 
 
 /***************************************************************************************
 ** Function name:           scroll
 ** Description:             Scroll dx,dy pixels, positive right,down, negative left,up
 ***************************************************************************************/
 void TFT_eSprite::scroll(int16_t dx, int16_t dy)
 {
   if (abs(dx) >= _sw || abs(dy) >= _sh)
   {
     fillRect (_sx, _sy, _sw, _sh, _scolor);
     return;
   }
 
   // Fetch the scroll area width and height set by setScrollRect()
   uint32_t w  = _sw - abs(dx); // line width to copy
   uint32_t h  = _sh - abs(dy); // lines to copy
   int32_t iw  = _iwidth;       // rounded up width of sprite
 
   // Fetch the x,y origin set by setScrollRect()
   uint32_t tx = _sx; // to x
   uint32_t fx = _sx; // from x
   uint32_t ty = _sy; // to y
   uint32_t fy = _sy; // from y
 
   // Adjust for x delta
   if (dx <= 0) fx -= dx;
   else tx += dx;
 
   // Adjust for y delta
   if (dy <= 0) fy -= dy;
   else
   { // Scrolling down so start copy from bottom
     ty = ty + _sh - 1; // "To" pointer
     iw = -iw;          // Pointer moves backwards
     fy = ty - dy;      // "From" pointer
   }
 
   // Calculate "from y" and "to y" pointers in RAM
   uint32_t fyp = fx + fy * _iwidth;
   uint32_t typ = tx + ty * _iwidth;
 
   // Now move the pixels in RAM
   if (_bpp == 16)
   {
     while (h--)
     { // move pixel lines (to, from, byte count)
       memmove( _img + typ, _img + fyp, w<<1);
       typ += iw;
       fyp += iw;
     }
   }
   else if (_bpp == 8)
   {
     while (h--)
     { // move pixel lines (to, from, byte count)
       memmove( _img8 + typ, _img8 + fyp, w);
       typ += iw;
       fyp += iw;
     }
   }
   else if (_bpp == 4)
   {
     // could optimize for scrolling by even # pixels using memove (later)
     if (dx >  0) { tx += w; fx += w; } // Start from right edge
     while (h--)
     { // move pixels one by one
       for (uint16_t xp = 0; xp < w; xp++)
       {
         if (dx <= 0) drawPixel(tx + xp, ty, readPixelValue(fx + xp, fy));
         if (dx >  0) drawPixel(tx - xp, ty, readPixelValue(fx - xp, fy));
       }
       if (dy <= 0)  { ty++; fy++; }
       else  { ty--; fy--; }
     }
   }
   else if (_bpp == 1 )
   {
     if (dx >  0) { tx += w; fx += w; } // Start from right edge
     while (h--)
     { // move pixels one by one
       for (uint16_t xp = 0; xp < w; xp++)
       {
         if (dx <= 0) drawPixel(tx + xp, ty, readPixelValue(fx + xp, fy));
         if (dx >  0) drawPixel(tx - xp, ty, readPixelValue(fx - xp, fy));
       }
       if (dy <= 0)  { ty++; fy++; }
       else  { ty--; fy--; }
     }
   }
   else return; // Not 1, 4, 8 or 16 bpp
 
   // Fill the gap left by the scrolling
   if (dx > 0) fillRect(_sx, _sy, dx, _sh, _scolor);
   if (dx < 0) fillRect(_sx + _sw + dx, _sy, -dx, _sh, _scolor);
   if (dy > 0) fillRect(_sx, _sy, _sw, dy, _scolor);
   if (dy < 0) fillRect(_sx, _sy + _sh + dy, _sw, -dy, _scolor);
 }
 
 
 /***************************************************************************************
 ** Function name:           fillSprite
 ** Description:             Fill the whole sprite with defined colour
 ***************************************************************************************/
 void TFT_eSprite::fillSprite(uint32_t color)
 {
   if (!_created || _vpOoB) return;
 
   // Use memset if possible as it is super fast
   if(_xDatum == 0 && _yDatum == 0  &&  _xWidth == width())
   {
     if(_bpp == 16) {
       if ( (uint8_t)color == (uint8_t)(color>>8) ) {
         memset(_img,  (uint8_t)color, _iwidth * _yHeight * 2);
       }
       else fillRect(_vpX, _vpY, _xWidth, _yHeight, color);
     }
     else if (_bpp == 8)
     {
       color = (color & 0xE000)>>8 | (color & 0x0700)>>6 | (color & 0x0018)>>3;
       memset(_img8, (uint8_t)color, _iwidth * _yHeight);
     }
     else if (_bpp == 4)
     {
       uint8_t c = ((color & 0x0F) | (((color & 0x0F) << 4) & 0xF0));
       memset(_img4, c, (_iwidth * _yHeight) >> 1);
     }
     else if (_bpp == 1)
     {
       if(color) memset(_img8, 0xFF, (_bitwidth>>3) * _dheight + 1);
       else      memset(_img8, 0x00, (_bitwidth>>3) * _dheight + 1);
     }
   }
   else fillRect(_vpX - _xDatum, _vpY - _yDatum, _xWidth, _yHeight, color);
 }
 
 
 /***************************************************************************************
 ** Function name:           width
 ** Description:             Return the width of sprite
 ***************************************************************************************/
 // Return the size of the sprite
 int16_t TFT_eSprite::width(void)
 {
   if (!_created ) return 0;
 
   if (_bpp > 1) {
     if (_vpDatum) return _xWidth;
     return _dwidth;
   }
 
   if (rotation & 1) {
     if (_vpDatum) return _xWidth;
     return _dheight;
   }
 
   if (_vpDatum) return _xWidth;
   return _dwidth;
 }
 
 
 /***************************************************************************************
 ** Function name:           height
 ** Description:             Return the height of sprite
 ***************************************************************************************/
 int16_t TFT_eSprite::height(void)
 {
   if (!_created ) return 0;
 
   if (_bpp > 1) {
     if (_vpDatum) return _yHeight;
     return _dheight;
   }
 
   if (rotation & 1) {
     if (_vpDatum) return _yHeight;
     return _dwidth;
   }
 
   if (_vpDatum) return _yHeight;
   return _dheight;
 }
 
 
 /***************************************************************************************
 ** Function name:           setRotation
 ** Description:             Rotate coordinate frame for 1bpp sprite
 ***************************************************************************************/
 // Does nothing for 4, 8 and 16 bpp sprites.
 void TFT_eSprite::setRotation(uint8_t r)
 {
   if (_bpp != 1) return;
 
   rotation = r;
   
   if (rotation&1) {
     resetViewport();
   }
   else {
     resetViewport();
   }
 }
 
 
 /***************************************************************************************
 ** Function name:           getRotation
 ** Description:             Get rotation for 1bpp sprite
 ***************************************************************************************/
 uint8_t TFT_eSprite::getRotation(void)
 {
   return rotation;
 }
 
 
 /***************************************************************************************
 ** Function name:           drawPixel
 ** Description:             push a single pixel at an arbitrary position
 ***************************************************************************************/
 void TFT_eSprite::drawPixel(int32_t x, int32_t y, uint32_t color)
 {
   if (!_created || _vpOoB) return;
 
   x+= _xDatum;
   y+= _yDatum;
 
   // Range checking
   if ((x < _vpX) || (y < _vpY) ||(x >= _vpW) || (y >= _vpH)) return;
 
   if (_bpp == 16)
   {
     color = (color >> 8) | (color << 8);
     _img[x+y*_iwidth] = (uint16_t) color;
   }
   else if (_bpp == 8)
   {
     _img8[x+y*_iwidth] = (uint8_t)((color & 0xE000)>>8 | (color & 0x0700)>>6 | (color & 0x0018)>>3);
   }
   else if (_bpp == 4)
   {
     uint8_t c = color & 0x0F;
     int index = (x+y*_iwidth)>>1;;
     if ((x & 0x01) == 0) {
       _img4[index] = (uint8_t)((c << 4) | (_img4[index] & 0x0F));
     }
     else {
       _img4[index] =  (uint8_t)(c | (_img4[index] & 0xF0));
     }
   }
   else // 1 bpp
   {
     if (rotation == 1)
     {
       uint16_t tx = x;
       x = _dwidth - y - 1;
       y = tx;
     }
     else if (rotation == 2)
     {
       x = _dwidth - x - 1;
       y = _dheight - y - 1;
     }
     else if (rotation == 3)
     {
       uint16_t tx = x;
       x = y;
       y = _dheight - tx - 1;
     }
 
     if (color) _img8[(x + y * _bitwidth)>>3] |=  (0x80 >> (x & 0x7));
     else       _img8[(x + y * _bitwidth)>>3] &= ~(0x80 >> (x & 0x7));
   }
 }
 
 
 /***************************************************************************************
 ** Function name:           drawLine
 ** Description:             draw a line between 2 arbitrary points
 ***************************************************************************************/
 void TFT_eSprite::drawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t color)
 {
   if (!_created || _vpOoB) return;
 
   //_xDatum and _yDatum Not added here, it is added by drawPixel & drawFastxLine
 
   bool steep = abs(y1 - y0) > abs(x1 - x0);
   if (steep) {
     transpose(x0, y0);
     transpose(x1, y1);
   }
 
   if (x0 > x1) {
     transpose(x0, x1);
     transpose(y0, y1);
   }
 
   int32_t dx = x1 - x0, dy = abs(y1 - y0);;
 
   int32_t err = dx >> 1, ystep = -1, xs = x0, dlen = 0;
 
   if (y0 < y1) ystep = 1;
 
   // Split into steep and not steep for FastH/V separation
   if (steep) {
     for (; x0 <= x1; x0++) {
       dlen++;
       err -= dy;
       if (err < 0) {
         err += dx;
         if (dlen == 1) drawPixel(y0, xs, color);
         else drawFastVLine(y0, xs, dlen, color);
         dlen = 0; y0 += ystep; xs = x0 + 1;
       }
     }
     if (dlen) drawFastVLine(y0, xs, dlen, color);
   }
   else
   {
     for (; x0 <= x1; x0++) {
       dlen++;
       err -= dy;
       if (err < 0) {
         err += dx;
         if (dlen == 1) drawPixel(xs, y0, color);
         else drawFastHLine(xs, y0, dlen, color);
         dlen = 0; y0 += ystep; xs = x0 + 1;
       }
     }
     if (dlen) drawFastHLine(xs, y0, dlen, color);
   }
 }
 
 
 /***************************************************************************************
 ** Function name:           drawFastVLine
 ** Description:             draw a vertical line
 ***************************************************************************************/
 void TFT_eSprite::drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t color)
 {
   if (!_created || _vpOoB) return;
 
   x+= _xDatum;
   y+= _yDatum;
 
   // Clipping
   if ((x < _vpX) || (x >= _vpW) || (y >= _vpH)) return;
 
   if (y < _vpY) { h += y - _vpY; y = _vpY; }
 
   if ((y + h) > _vpH) h = _vpH - y;
 
   if (h < 1) return;
 
   if (_bpp == 16)
   {
     color = (color >> 8) | (color << 8);
     int32_t yp = x + _iwidth * y;
     while (h--) {_img[yp] = (uint16_t) color; yp += _iwidth;}
   }
   else if (_bpp == 8)
   {
     color = (color & 0xE000)>>8 | (color & 0x0700)>>6 | (color & 0x0018)>>3;
     while (h--) _img8[x + _iwidth * y++] = (uint8_t) color;
   }
   else if (_bpp == 4)
   {
     if ((x & 0x01) == 0)
     {
       uint8_t c = (uint8_t) (color & 0xF) << 4;
       while (h--) {
         _img4[(x + _iwidth * y)>>1] = (uint8_t) (c | (_img4[(x + _iwidth * y)>>1] & 0x0F));
         y++;
       }
     }
     else {
       uint8_t c = (uint8_t)color & 0xF;
       while (h--) {
         _img4[(x + _iwidth * y)>>1] = (uint8_t) (c | (_img4[(x + _iwidth * y)>>1] & 0xF0)); // x is odd; new color goes into the low bits.
         y++;
       }
     }
   }
   else
   {
     x -= _xDatum; // Remove any offset as it will be added by drawPixel
     y -= _yDatum;
     while (h--)
     {
       drawPixel(x, y++, color);
     }
   }
 }
 
 
 /***************************************************************************************
 ** Function name:           drawFastHLine
 ** Description:             draw a horizontal line
 ***************************************************************************************/
 void TFT_eSprite::drawFastHLine(int32_t x, int32_t y, int32_t w, uint32_t color)
 {
   if (!_created || _vpOoB) return;
 
   x+= _xDatum;
   y+= _yDatum;
 
   // Clipping
   if ((y < _vpY) || (x >= _vpW) || (y >= _vpH)) return;
 
   if (x < _vpX) { w += x - _vpX; x = _vpX; }
 
   if ((x + w) > _vpW) w = _vpW - x;
 
   if (w < 1) return;
 
   if (_bpp == 16)
   {
     color = (color >> 8) | (color << 8);
     while (w--) _img[_iwidth * y + x++] = (uint16_t) color;
   }
   else if (_bpp == 8)
   {
     color = (color & 0xE000)>>8 | (color & 0x0700)>>6 | (color & 0x0018)>>3;
     memset(_img8+_iwidth * y + x, (uint8_t)color, w);
   }
   else if (_bpp == 4)
   {
     uint8_t c = (uint8_t)color & 0x0F;
     uint8_t c2 = (c | ((c << 4) & 0xF0));
     if ((x & 0x01) == 1)
     {
       drawPixel(x - _xDatum, y - _yDatum, color);
       x++; w--;
       if (w < 1)
         return;
     }
 
     if (((w + x) & 0x01) == 1)
     {
       // handle the extra one at the other end
       drawPixel(x - _xDatum + w - 1, y - _yDatum, color);
       w--;
       if (w < 1) return;
     }
     memset(_img4 + ((_iwidth * y + x) >> 1), c2, (w >> 1));
   }
   else {
     x -= _xDatum; // Remove any offset as it will be added by drawPixel
     y -= _yDatum;
 
     while (w--)
     {
       drawPixel(x++, y, color);
     }
   }
 }
 
 
 /***************************************************************************************
 ** Function name:           fillRect
 ** Description:             draw a filled rectangle
 ***************************************************************************************/
 void TFT_eSprite::fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color)
 {
   if (!_created || _vpOoB) return;
 
   x+= _xDatum;
   y+= _yDatum;
 
   // Clipping
   if ((x >= _vpW) || (y >= _vpH)) return;
 
   if (x < _vpX) { w += x - _vpX; x = _vpX; }
   if (y < _vpY) { h += y - _vpY; y = _vpY; }
 
   if ((x + w) > _vpW) w = _vpW - x;
   if ((y + h) > _vpH) h = _vpH - y;
 
   if ((w < 1) || (h < 1)) return;
 
   int32_t yp = _iwidth * y + x;
 
   if (_bpp == 16)
   {
     color = (color >> 8) | (color << 8);
     uint32_t iw = w;
     int32_t ys = yp;
     if(h--)  {while (iw--) _img[yp++] = (uint16_t) color;}
     yp = ys;
     while (h--)
     {
       yp += _iwidth;
       memcpy( _img+yp, _img+ys, w<<1);
     }
   }
   else if (_bpp == 8)
   {
     color = (color & 0xE000)>>8 | (color & 0x0700)>>6 | (color & 0x0018)>>3;
     while (h--)
     {
       memset(_img8 + yp, (uint8_t)color, w);
       yp += _iwidth;
     }
   }
   else if (_bpp == 4)
   {
     uint8_t c1 = (uint8_t)color & 0x0F;
     uint8_t c2 = c1 | ((c1 << 4) & 0xF0);
     if ((x & 0x01) == 0 && (w & 0x01) == 0)
     {
       yp = (yp >> 1);
       while (h--)
       {
         memset(_img4 + yp, c2, (w>>1));
         yp += (_iwidth >> 1);
       }
     }
     else if ((x & 0x01) == 0)
     {
 
       // same as above but you have a hangover on the right.
       yp = (yp >> 1);
       while (h--)
       {
         if (w > 1)
           memset(_img4 + yp, c2, (w-1)>>1);
         // handle the rightmost pixel by calling drawPixel
         drawPixel(x+w-1-_xDatum, y+h-_yDatum, c1);
         yp += (_iwidth >> 1);
       }
     }
     else if ((w & 0x01) == 1)
     {
       yp = (yp + 1) >> 1;
       while (h--) {
         drawPixel(x-_xDatum, y+h-_yDatum, color & 0x0F);
         if (w > 1)
           memset(_img4 + yp, c2, (w-1)>>1);
         // same as above but you have a hangover on the left instead
         yp += (_iwidth >> 1);
       }
     }
     else
     {
       yp = (yp + 1) >> 1;
       while (h--) {
         drawPixel(x-_xDatum, y+h-_yDatum, color & 0x0F);
         if (w > 1) drawPixel(x+w-1-_xDatum, y+h-_yDatum, color & 0x0F);
         if (w > 2)
           memset(_img4 + yp, c2, (w-2)>>1);
         // maximal hacking, single pixels on left and right.
         yp += (_iwidth >> 1);
       }
     }
   }
   else
   {
     x -= _xDatum;
     y -= _yDatum;
     while (h--)
     {
       int32_t ww = w;
       int32_t xx = x;
       while (ww--) drawPixel(xx++, y, color);
       y++;
     }
   }
 }
 
 
 /***************************************************************************************
 ** Function name:           drawChar
 ** Description:             draw a single character in the Adafruit GLCD or freefont
 ***************************************************************************************/
 void TFT_eSprite::drawChar(int32_t x, int32_t y, uint16_t c, uint32_t color, uint32_t bg, uint8_t size)
 {
   if ( _vpOoB || !_created ) return;
 
   if ((x >= _vpW - _xDatum) || // Clip right
       (y >= _vpH - _yDatum))   // Clip bottom
     return;
 
   if (c < 32) return;
 #ifdef LOAD_GLCD
 //>>>>>>>>>>>>>>>>>>
 #ifdef LOAD_GFXFF
   if(!gfxFont) { // 'Classic' built-in font
 #endif
 //>>>>>>>>>>>>>>>>>>
 
   if (((x + 6 * size - 1) < (_vpX - _xDatum)) || // Clip left
       ((y + 8 * size - 1) < (_vpY - _yDatum)))   // Clip top
     return;
 
   bool fillbg = (bg != color);
 
   if ((size==1) && fillbg)
   {
     uint8_t column[6];
     uint8_t mask = 0x1;
 
     for (int8_t i = 0; i < 5; i++ ) column[i] = pgm_read_byte(font + (c * 5) + i);
     column[5] = 0;
 
     int8_t j, k;
     for (j = 0; j < 8; j++) {
       for (k = 0; k < 5; k++ ) {
         if (column[k] & mask) {
           drawPixel(x + k, y + j, color);
         }
         else {
           drawPixel(x + k, y + j, bg);
         }
       }
 
       mask <<= 1;
 
       drawPixel(x + k, y + j, bg);
     }
   }
   else
   {
     for (int8_t i = 0; i < 6; i++ ) {
       uint8_t line;
       if (i == 5)
         line = 0x0;
       else
         line = pgm_read_byte(font + (c * 5) + i);
 
       if (size == 1) // default size
       {
         for (int8_t j = 0; j < 8; j++) {
           if (line & 0x1) drawPixel(x + i, y + j, color);
           line >>= 1;
         }
       }
       else {  // big size
         for (int8_t j = 0; j < 8; j++) {
           if (line & 0x1) fillRect(x + (i * size), y + (j * size), size, size, color);
           else if (fillbg) fillRect(x + i * size, y + j * size, size, size, bg);
           line >>= 1;
         }
       }
     }
   }
 
 //>>>>>>>>>>>>>>>>>>>>>>>>>>>
 #ifdef LOAD_GFXFF
   } else { // Custom font
 #endif
 //>>>>>>>>>>>>>>>>>>>>>>>>>>>
 #endif // LOAD_GLCD
 
 #ifdef LOAD_GFXFF
     // Filter out bad characters not present in font
     if ((c >= pgm_read_word(&gfxFont->first)) && (c <= pgm_read_word(&gfxFont->last )))
     {
 //>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
       c -= pgm_read_word(&gfxFont->first);
       GFXglyph *glyph  = &(((GFXglyph *)pgm_read_dword(&gfxFont->glyph))[c]);
 
       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);
 
       if (((x + xo + w * size - 1) < (_vpX - _xDatum)) || // Clip left
           ((y + yo + h * size - 1) < (_vpY - _yDatum)))   // Clip top
         return;
 
       uint8_t  *bitmap = (uint8_t *)pgm_read_dword(&gfxFont->bitmap);
       uint32_t bo = pgm_read_word(&glyph->bitmapOffset);
 
       uint8_t  xx, yy, bits=0, bit=0;
       //uint8_t  xa = pgm_read_byte(&glyph->xAdvance);
       int16_t  xo16 = 0, yo16 = 0;
 
       if(size > 1) {
         xo16 = xo;
         yo16 = yo;
       }
 
       uint16_t hpc = 0; // Horizontal foreground pixel count
       for(yy=0; yy<h; yy++) {
         for(xx=0; xx<w; xx++) {
           if(bit == 0) {
             bits = pgm_read_byte(&bitmap[bo++]);
             bit  = 0x80;
           }
           if(bits & bit) hpc++;
           else {
             if (hpc) {
               if(size == 1) drawFastHLine(x+xo+xx-hpc, y+yo+yy, hpc, color);
               else fillRect(x+(xo16+xx-hpc)*size, y+(yo16+yy)*size, size*hpc, size, color);
               hpc=0;
             }
           }
           bit >>= 1;
         }
         // Draw pixels for this line as we are about to increment yy
         if (hpc) {
           if(size == 1) drawFastHLine(x+xo+xx-hpc, y+yo+yy, hpc, color);
           else fillRect(x+(xo16+xx-hpc)*size, y+(yo16+yy)*size, size*hpc, size, color);
           hpc=0;
         }
       }
     }
 #endif
 
 
 #ifdef LOAD_GLCD
   #ifdef LOAD_GFXFF
   } // End classic vs custom font
   #endif
 #else
   #ifndef LOAD_GFXFF
     color = color;
     bg = bg;
     size = size;
   #endif
 #endif
 
 }
 
 
 /***************************************************************************************
 ** Function name:           drawChar
 ** Description:             draw a unicode glyph into the sprite
 ***************************************************************************************/
   // TODO: Rationalise with TFT_eSPI
   // Any UTF-8 decoding must be done before calling drawChar()
 int16_t TFT_eSprite::drawChar(uint16_t uniCode, int32_t x, int32_t y)
 {
   return drawChar(uniCode, x, y, textfont);
 }
 
   // Any UTF-8 decoding must be done before calling drawChar()
 int16_t TFT_eSprite::drawChar(uint16_t uniCode, int32_t x, int32_t y, uint8_t font)
 {
   if (_vpOoB || !uniCode) return 0;
 
   if (font==1) {
 #ifdef LOAD_GLCD
   #ifndef LOAD_GFXFF
     drawChar(x, y, uniCode, textcolor, textbgcolor, textsize);
     return 6 * textsize;
   #endif
 #else
   #ifndef LOAD_GFXFF
     return 0;
   #endif
 #endif
 
 #ifdef LOAD_GFXFF
     drawChar(x, y, uniCode, textcolor, textbgcolor, textsize);
     if(!gfxFont) { // 'Classic' built-in font
     #ifdef LOAD_GLCD
       return 6 * textsize;
     #else
       return 0;
     #endif
     }
     else {
       if((uniCode >= pgm_read_word(&gfxFont->first)) && (uniCode <= pgm_read_word(&gfxFont->last) )) {
         uint16_t   c2    = uniCode - pgm_read_word(&gfxFont->first);
         GFXglyph *glyph = &(((GFXglyph *)pgm_read_dword(&gfxFont->glyph))[c2]);
         return pgm_read_byte(&glyph->xAdvance) * textsize;
       }
       else {
         return 0;
       }
     }
 #endif
   }
 
   if ((font>1) && (font<9) && ((uniCode < 32) || (uniCode > 127))) return 0;
 
   int32_t width  = 0;
   int32_t height = 0;
   uint32_t flash_address = 0;
   uniCode -= 32;
 
 #ifdef LOAD_FONT2
   if (font == 2) {
     flash_address = pgm_read_dword(&chrtbl_f16[uniCode]);
     width = pgm_read_byte(widtbl_f16 + uniCode);
     height = chr_hgt_f16;
   }
   #ifdef LOAD_RLE
   else
   #endif
 #endif
 
 #ifdef LOAD_RLE
   {
     if ((font>2) && (font<9)) {
       flash_address = pgm_read_dword( (const void*)(pgm_read_dword( &(fontdata[font].chartbl ) ) + uniCode*sizeof(void *)) );
       width = pgm_read_byte( (uint8_t *)pgm_read_dword( &(fontdata[font].widthtbl ) ) + uniCode );
       height= pgm_read_byte( &fontdata[font].height );
     }
   }
 #endif
 
   int32_t xd = x + _xDatum;
   int32_t yd = y + _yDatum;
 
   if ((xd + width * textsize < _vpX || xd >= _vpW) && (yd + height * textsize < _vpY || yd >= _vpH)) return width * textsize ;
 
   int32_t w = width;
   int32_t pX      = 0;
   int32_t pY      = y;
   uint8_t line = 0;
   bool clip = xd < _vpX || xd + width  * textsize >= _vpW || yd < _vpY || yd + height * textsize >= _vpH;
 
 #ifdef LOAD_FONT2 // chop out code if we do not need it
   if (font == 2) {
     w = w + 6; // Should be + 7 but we need to compensate for width increment
     w = w / 8;
 
     for (int32_t i = 0; i < height; i++)
     {
       if (textcolor != textbgcolor) fillRect(x, pY, width * textsize, textsize, textbgcolor);
 
       for (int32_t k = 0; k < w; k++)
       {
         line = pgm_read_byte((uint8_t *)flash_address + w * i + k);
         if (line) {
           if (textsize == 1) {
             pX = x + k * 8;
             if (line & 0x80) drawPixel(pX, pY, textcolor);
             if (line & 0x40) drawPixel(pX + 1, pY, textcolor);
             if (line & 0x20) drawPixel(pX + 2, pY, textcolor);
             if (line & 0x10) drawPixel(pX + 3, pY, textcolor);
             if (line & 0x08) drawPixel(pX + 4, pY, textcolor);
             if (line & 0x04) drawPixel(pX + 5, pY, textcolor);
             if (line & 0x02) drawPixel(pX + 6, pY, textcolor);
             if (line & 0x01) drawPixel(pX + 7, pY, textcolor);
           }
           else {
             pX = x + k * 8 * textsize;
             if (line & 0x80) fillRect(pX, pY, textsize, textsize, textcolor);
             if (line & 0x40) fillRect(pX + textsize, pY, textsize, textsize, textcolor);
             if (line & 0x20) fillRect(pX + 2 * textsize, pY, textsize, textsize, textcolor);
             if (line & 0x10) fillRect(pX + 3 * textsize, pY, textsize, textsize, textcolor);
             if (line & 0x08) fillRect(pX + 4 * textsize, pY, textsize, textsize, textcolor);
             if (line & 0x04) fillRect(pX + 5 * textsize, pY, textsize, textsize, textcolor);
             if (line & 0x02) fillRect(pX + 6 * textsize, pY, textsize, textsize, textcolor);
             if (line & 0x01) fillRect(pX + 7 * textsize, pY, textsize, textsize, textcolor);
           }
         }
       }
       pY += textsize;
     }
   }
 
   #ifdef LOAD_RLE
   else
   #endif
 #endif  //FONT2
 
 #ifdef LOAD_RLE  //674 bytes of code
   // Font is not 2 and hence is RLE encoded
   {
     w *= height; // Now w is total number of pixels in the character
     int16_t color = textcolor;
     if (_bpp == 16) color = (textcolor >> 8) | (textcolor << 8);
     else if (_bpp == 8) color = ((textcolor & 0xE000)>>8 | (textcolor & 0x0700)>>6 | (textcolor & 0x0018)>>3);
 
     int16_t bgcolor = textbgcolor;
     if (_bpp == 16) bgcolor = (textbgcolor >> 8) | (textbgcolor << 8);
     else if (_bpp == 8) bgcolor = ((textbgcolor & 0xE000)>>8 | (textbgcolor & 0x0700)>>6 | (textbgcolor & 0x0018)>>3);
 
     if (textcolor == textbgcolor && !clip && _bpp != 1) {
       int32_t px = 0, py = pY; // To hold character block start and end column and row values
       int32_t pc = 0; // Pixel count
       uint8_t np = textsize * textsize; // Number of pixels in a drawn pixel
 
       uint8_t tnp = 0; // Temporary copy of np for while loop
       uint8_t ts = textsize - 1; // Temporary copy of textsize
       // 16 bit pixel count so maximum font size is equivalent to 180x180 pixels in area
       // w is total number of pixels to plot to fill character block
       while (pc < w) {
         line = pgm_read_byte((uint8_t *)flash_address);
         flash_address++;
         if (line & 0x80) {
           line &= 0x7F;
           line++;
           if (ts) {
             px = xd + textsize * (pc % width); // Keep these px and py calculations outside the loop as they are slow
             py = yd + textsize * (pc / width);
           }
           else {
             px = xd + pc % width; // Keep these px and py calculations outside the loop as they are slow
             py = yd + pc / width;
           }
           while (line--) { // In this case the while(line--) is faster
             pc++; // This is faster than putting pc+=line before while()?
             setWindow(px, py, px + ts, py + ts);
 
             if (ts) {
               tnp = np;
               while (tnp--) writeColor(color);
             }
             else writeColor(color);
 
             px += textsize;
 
             if (px >= (xd + width * textsize)) {
               px = xd;
               py += textsize;
             }
           }
         }
         else {
           line++;
           pc += line;
         }
       }
     }
     else {
       // Text colour != background and textsize = 1 and character is within viewport area
       // so use faster drawing of characters and background using block write
       if (textcolor != textbgcolor && textsize == 1 && !clip && _bpp != 1)
       {
         setWindow(xd, yd, xd + width - 1, yd + height - 1);
 
         // Maximum font size is equivalent to 180x180 pixels in area
         while (w > 0) {
           line = pgm_read_byte((uint8_t *)flash_address++); // 8 bytes smaller when incrementing here
           if (line & 0x80) {
             line &= 0x7F;
             line++; w -= line;
             while (line--) writeColor(color);
           }
           else {
             line++; w -= line;
             while (line--) writeColor(bgcolor);
           }
         }
       }
       else
       {
         int32_t px = 0, py = 0;  // To hold character pixel coords
         int32_t tx = 0, ty = 0;  // To hold character TFT pixel coords
         int32_t pc = 0;          // Pixel count
         int32_t pl = 0;          // Pixel line length
         uint16_t pcol = 0;       // Pixel color
         bool     pf = true;      // Flag for plotting
         while (pc < w) {
           line = pgm_read_byte((uint8_t *)flash_address);
           flash_address++;
           if (line & 0x80) { pcol = textcolor; line &= 0x7F; pf = true;}
           else { pcol = textbgcolor; if (textcolor == textbgcolor) pf = false;}
           line++;
           px = pc % width;
           tx = x + textsize * px;
           py = pc / width;
           ty = y + textsize * py;
 
           pl = 0;
           pc += line;
           while (line--) {
             pl++;
             if ((px+pl) >= width) {
               if (pf) fillRect(tx, ty, pl * textsize, textsize, pcol);
               pl = 0;
               px = 0;
               tx = x;
               py ++;
               ty += textsize;
             }
           }
           if (pl && pf) fillRect(tx, ty, pl * textsize, textsize, pcol);
         }
       }
     }
   }
   // End of RLE font rendering
 #endif
 
 #if !defined (LOAD_FONT2) && !defined (LOAD_RLE)
   // Stop warnings
   flash_address = flash_address;
   w = w;
   pX = pX;
   pY = pY;
   line = line;
   clip = clip;
 #endif
 
   return width * textsize;    // x +
 }
 
 
 #ifdef SMOOTH_FONT
 /***************************************************************************************
 ** Function name:           drawGlyph
 ** Description:             Write a character to the sprite cursor position
 ***************************************************************************************/
 //
 void TFT_eSprite::drawGlyph(uint16_t code)
 {
   uint16_t fg = textcolor;
   uint16_t bg = textbgcolor;
   bool getBG  = false;
   if (fg == bg) getBG = true;
 
   // Check if cursor has moved
   if (last_cursor_x != cursor_x)
   {
     bg_cursor_x = cursor_x;
     last_cursor_x = cursor_x;
   }
 
   if (code < 0x21)
   {
     if (code == 0x20) {
       if (_fillbg) fillRect(bg_cursor_x, cursor_y, (cursor_x + gFont.spaceWidth) - bg_cursor_x, gFont.yAdvance, bg);
       cursor_x += gFont.spaceWidth;
       bg_cursor_x = cursor_x;
       last_cursor_x = cursor_x;
       return;
     }
 
     if (code == '\n') {
       cursor_x = 0;
       bg_cursor_x = 0;
       last_cursor_x = 0;
       cursor_y += gFont.yAdvance;
       if (textwrapY && (cursor_y >= height())) cursor_y = 0;
       return;
     }
   }
 
   uint16_t gNum = 0;
   bool found = getUnicodeIndex(code, &gNum);
 
   if (found)
   {
 
     bool newSprite = !_created;
 
     if (newSprite)
     {
       createSprite(gWidth[gNum], gFont.yAdvance);
       if(fg != bg) fillSprite(bg);
       cursor_x = -gdX[gNum];
       bg_cursor_x = cursor_x;
       last_cursor_x = cursor_x;
       cursor_y = 0;
     }
     else
     {
       if( textwrapX && ((cursor_x + gWidth[gNum] + gdX[gNum]) > width())) {
         cursor_y += gFont.yAdvance;
         cursor_x = 0;
         bg_cursor_x = 0;
         last_cursor_x = 0;
       }
 
       if( textwrapY && ((cursor_y + gFont.yAdvance) > height())) cursor_y = 0;
       if ( cursor_x == 0) cursor_x -= gdX[gNum];
     }
 
     uint8_t* pbuffer = nullptr;
     const uint8_t* gPtr = (const uint8_t*) gFont.gArray;
 
 #ifdef FONT_FS_AVAILABLE
     if (fs_font) {
       fontFile.seek(gBitmap[gNum], fs::SeekSet); // This is slow for a significant position shift!
       pbuffer =  (uint8_t*)malloc(gWidth[gNum]);
     }
 #endif
 
     int16_t cy = cursor_y + gFont.maxAscent - gdY[gNum];
     int16_t cx = cursor_x + gdX[gNum];
 
     //  if (cx > width() && bg_cursor_x > width()) return;
     //  if (cursor_y > height()) return;
 
     int16_t  fxs = cx;
     uint32_t fl = 0;
     int16_t  bxs = cx;
     uint32_t bl = 0;
     int16_t  bx = 0;
     uint8_t pixel = 0;
 
     int16_t fillwidth  = 0;
     int16_t fillheight = 0;
 
     // Fill area above glyph
     if (_fillbg) {
       fillwidth  = (cursor_x + gxAdvance[gNum]) - bg_cursor_x;
       if (fillwidth > 0) {
         fillheight = gFont.maxAscent - gdY[gNum];
         if (fillheight > 0) {
           fillRect(bg_cursor_x, cursor_y, fillwidth, fillheight, textbgcolor);
         }
       }
       else {
         // Could be negative
         fillwidth = 0;
       }
 
       // Fill any area to left of glyph                              
       if (bg_cursor_x < cx) fillRect(bg_cursor_x, cy, cx - bg_cursor_x, gHeight[gNum], textbgcolor);
       // Set x position in glyph area where background starts
       if (bg_cursor_x > cx) bx = bg_cursor_x - cx;
       // Fill any area to right of glyph
       if (cx + gWidth[gNum] < cursor_x + gxAdvance[gNum]) {
         fillRect(cx + gWidth[gNum], cy, (cursor_x + gxAdvance[gNum]) - (cx + gWidth[gNum]), gHeight[gNum], textbgcolor);
       }
     }
 
     for (int32_t y = 0; y < gHeight[gNum]; y++)
     {
 #ifdef FONT_FS_AVAILABLE
       if (fs_font) {
         fontFile.read(pbuffer, gWidth[gNum]);
       }
 #endif
 
       for (int32_t x = 0; x < gWidth[gNum]; x++)
       {
 #ifdef FONT_FS_AVAILABLE
         if (fs_font) pixel = pbuffer[x];
         else
 #endif
         pixel = pgm_read_byte(gPtr + gBitmap[gNum] + x + gWidth[gNum] * y);
 
         if (pixel)
         {
           if (bl) { drawFastHLine( bxs, y + cy, bl, bg); bl = 0; }
           if (pixel != 0xFF)
           {
             if (fl) {
               if (fl==1) drawPixel(fxs, y + cy, fg);
               else drawFastHLine( fxs, y + cy, fl, fg);
               fl = 0;
             }
             if (getBG) bg = readPixel(x + cx, y + cy);
             drawPixel(x + cx, y + cy, alphaBlend(pixel, fg, bg));
           }
           else
           {
             if (fl==0) fxs = x + cx;
             fl++;
           }
         }
         else
         {
           if (fl) { drawFastHLine( fxs, y + cy, fl, fg); fl = 0; }
           if (_fillbg) {
             if (x >= bx) {
               if (bl==0) bxs = x + cx;
               bl++;
             }
           }
         }
       }
       if (fl) { drawFastHLine( fxs, y + cy, fl, fg); fl = 0; }
       if (bl) { drawFastHLine( bxs, y + cy, bl, bg); bl = 0; }
     }
 
     // Fill area below glyph
     if (fillwidth > 0) {
       fillheight = (cursor_y + gFont.yAdvance) - (cy + gHeight[gNum]);
       if (fillheight > 0) {
         fillRect(bg_cursor_x, cy + gHeight[gNum], fillwidth, fillheight, textbgcolor);
       }
     }
 
     if (pbuffer) free(pbuffer);
     cursor_x += gxAdvance[gNum];
 
     if (newSprite)
     {
       pushSprite(cx, cursor_y);
       deleteSprite();
     }
   }
   else
   {
     // Not a Unicode in font so draw a rectangle and move on cursor
     drawRect(cursor_x, cursor_y + gFont.maxAscent - gFont.ascent, gFont.spaceWidth, gFont.ascent, fg);
     cursor_x += gFont.spaceWidth + 1;
   }
   bg_cursor_x = cursor_x;
   last_cursor_x = cursor_x;
 }
 
 
 /***************************************************************************************
 ** Function name:           printToSprite
 ** Description:             Write a string to the sprite cursor position
 ***************************************************************************************/
 void TFT_eSprite::printToSprite(String string)
 {
   if(!fontLoaded) return;
   printToSprite((char*)string.c_str(), string.length());
 }
 
 
 /***************************************************************************************
 ** Function name:           printToSprite
 ** Description:             Write a string to the sprite cursor position
 ***************************************************************************************/
 void TFT_eSprite::printToSprite(char *cbuffer, uint16_t len) //String string)
 {
   if(!fontLoaded) return;
 
   uint16_t n = 0;
   bool newSprite = !_created;
   int16_t  cursorX = _tft->cursor_x;
 
   if (newSprite)
   {
     int16_t sWidth = 0;
     uint16_t index = 0;
     bool     first = true;
     while (n < len)
     {
       uint16_t unicode = decodeUTF8((uint8_t*)cbuffer, &n, len - n);
       if (getUnicodeIndex(unicode, &index))
       {
         if (first) {
           first = false;
           sWidth -= gdX[index];
           cursorX += gdX[index];
         }
         if (n == len) sWidth += ( gWidth[index] + gdX[index]);
         else sWidth += gxAdvance[index];
       }
       else sWidth += gFont.spaceWidth + 1;
     }
 
     createSprite(sWidth, gFont.yAdvance);
 
     if (textcolor != textbgcolor) fillSprite(textbgcolor);
   }
 
   n = 0;
 
   while (n < len)
   {
     uint16_t unicode = decodeUTF8((uint8_t*)cbuffer, &n, len - n);
     //Serial.print("Decoded Unicode = 0x");Serial.println(unicode,HEX);
     //Serial.print("n = ");Serial.println(n);
     drawGlyph(unicode);
   }
 
   if (newSprite)
   { // The sprite had to be created so place at TFT cursor
     pushSprite(cursorX, _tft->cursor_y);
     deleteSprite();
   }
 }
 
 
 /***************************************************************************************
 ** Function name:           printToSprite
 ** Description:             Print character in a Sprite, create sprite if needed
 ***************************************************************************************/
 int16_t TFT_eSprite::printToSprite(int16_t x, int16_t y, uint16_t index)
 {
   bool newSprite = !_created;
   int16_t sWidth = gWidth[index];
 
   if (newSprite)
   {
     createSprite(sWidth, gFont.yAdvance);
 
     if (textcolor != textbgcolor) fillSprite(textbgcolor);
 
     drawGlyph(gUnicode[index]);
 
     pushSprite(x + gdX[index], y, textbgcolor);
     deleteSprite();
   }
 
   else drawGlyph(gUnicode[index]);
 
   return gxAdvance[index];
 }
 #endif

© 2023 acidvegas, inc • generated with stagit