Sprite_t_k_cst.cpp

/**************************************************************************************
// 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.
***************************************************************************************/
#include "Sprite_t_k_cst.h"
/***************************************************************************************
** Function name:           TFT_eSprite_CST
** Description:             Class constructor
*************************************************************************************x*/

//2018/10/5 ~ T.K CUSTOM//
TFT_eSprite_CST::TFT_eSprite_CST(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;
  _iswapBytes = false;   // Do not swap pushImage colour bytes by default

  _created = false;

  _xs = 0;  // window bounds for pushColor
  _ys = 0;
  _xe = 0;
  _ye = 0;

  _xptr = 0; // pushColor coordinate
  _yptr = 0;

  this->cursor_y = this->cursor_x = 0; // Text cursor position
}

/***************************************************************************************
** Function name:           createSprite
** Description:             Create a sprite (bitmap) of defined width and height
*************************************************************************************x*/
// cast returned value to (uint8_t*) for 8 bit or (uint16_t*) for 16 bit colours
void* TFT_eSprite_CST::createSprite(int16_t w, int16_t h, uint8_t frames)
{
  if ( _created ) return _img8_1;

  if ( w < 1 || h < 1 ) return NULL;

  _iwidth  = _dwidth  = _bitwidth = w;
  _iheight = _dheight = h;

  this->cursor_x = 0;
  this->cursor_y = 0;

  // Default scroll rectangle and gap fill colour
  _sx = 0;
  _sy = 0;
  _sw = w;
  _sh = h;
  _scolor = TFT_BLACK;

  // 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.
  if (_bpp == 16)
  {
    _img8_1 = ( uint8_t*) calloc(w * h + 1, sizeof(uint16_t));
    _img8_2 = _img8_1;
    _img    = (uint16_t*) _img8_1;

    if (_img)
    {
      _created = true;
      return _img;
    }
  }

  else if (_bpp == 8)
  {
    _img8_1 = ( uint8_t*) calloc(w * h + 1, sizeof(uint8_t));
    if (_img8_1)
    {
      _img8   = _img8_1;
      _img8_2 = _img8_1;
      _created = true;
      return _img8;
    }
  }
  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;

    if (frames > 2) frames = 2; // Currently restricted to 2 frame buffers
    if (frames < 1) frames = 1;
    _img8 = ( uint8_t*) calloc(frames * (w>>3) * h + frames, sizeof(uint8_t)); // extra pixel added

    if (_img8)
    {
      _created = true;
      _img8_1 = _img8;
      _img8_2 = _img8 + ( (w>>3) * h + 1 );
      return _img8_1;
    }
  }
  return NULL;
}

/***************************************************************************************
** Function name:           frameBuffer
** Description:             For 1 bpp Sprites, select the frame used for graphics
*************************************************************************************x*/
// Frames are numbered 1 and 2
void* TFT_eSprite_CST::frameBuffer(int8_t f)
{
  if (!_created) return NULL;

  if (_bpp == 16) return _img;

  if (_bpp == 8) return _img8;

  if ( f == 2 ) _img8 = _img8_2;
  else          _img8 = _img8_1;

  return _img8;
}

/***************************************************************************************
** Function name:           setDepth
** Description:             Set bits per pixel for colour (8 or 16)
*************************************************************************************x*/

void* TFT_eSprite_CST::setColorDepth(int8_t b)
{
  // Can't change an existing sprite's colour depth so delete it
  if (_created) free(_img8_1);

  // Now define the new colour depth
  if ( b > 8 ) _bpp = 16;  // Bytes per pixel
  else if ( b > 1 ) _bpp = 8;
  else _bpp = 1;

  // If it existed, re-create the sprite with the new colour depth
  if (_created)
  {
    _created = false;
    return createSprite(_iwidth, _iheight);
  }
  return NULL;
}

/***************************************************************************************
** Function name:           setBitmapColor
** Description:             Set the foreground foreground and background colour
***************************************************************************************/
void TFT_eSprite_CST::setBitmapColor(uint16_t c, uint16_t b)
{
  if (c == b) b = ~c;
  _tft->bitmap_fg = c;
  _tft->bitmap_bg = b;
}


/***************************************************************************************
** Function name:           deleteSprite
** Description:             Delete the sprite to free up memory (RAM)
*************************************************************************************x*/
void TFT_eSprite_CST::deleteSprite(void)
{
  if (!_created ) return;

  free(_img8_1);

  _created = false;
}


/***************************************************************************************
** Function name:           pushSprite
** Description:             Push the sprite to the TFT at x, y
*************************************************************************************x*/
void TFT_eSprite_CST::pushSprite(int32_t x, int32_t y)
{
  if (!_created) return;

  if (_bpp == 16) _tft->pushImage(x, y, _iwidth, _iheight, _img );

  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
*************************************************************************************x*/
void TFT_eSprite_CST::pushSprite(int32_t x, int32_t y, uint16_t transp)
{
  if (!_created) return;

  if (_bpp == 16) _tft->pushImage(x, y, _iwidth, _iheight, _img, transp );
  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 _tft->pushImage(x, y, _dwidth, _dheight, _img8, 0, (bool)false);
}


/***************************************************************************************
** Function name:           readPixel
** Description:             Read 565 colour of a pixel at defined coordinates
*************************************************************************************x*/
uint16_t TFT_eSprite_CST::readPixel(int32_t x, int32_t y)
{
  if ((x < 0) || (x >= _iwidth) || (y < 0) || (y >= _iheight) || !_created) return 0;

  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 (_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;
  }

  uint16_t color = (_img8[(x + y * _bitwidth)>>3] << (x & 0x7)) & 0x80;

  return color >> 7;
}


/***************************************************************************************
** Function name:           pushImage
** Description:             push 565 colour image into a defined area of a sprite 
*************************************************************************************x*/
// TODO Need to add more area boundary checks
void  TFT_eSprite_CST::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, uint16_t *data)
{
  if ((x >= _iwidth) || (y >= _iheight) || (w == 0) || (h == 0) || !_created) return;

  if (_bpp == 16)
  {
    for (uint32_t yp = y; yp < y + h; yp++)
    {
      for (uint32_t xp = x; xp < x + w; xp++)
      {
        uint16_t color =  *data++;
        if(!_iswapBytes) color = color<<8 | color>>8;
        _img[xp + yp * _iwidth] = color;
      }
    }
  }
  else if (_bpp == 8)
  {
    for (uint32_t yp = y; yp < y + h; yp++)
    {
      for (uint32_t xp = x; xp < x + w; xp++)
      {
        uint16_t color = *data++;
        if(_iswapBytes) color = color<<8 | color>>8;
        _img8[xp + yp * _iwidth] = (uint8_t)((color & 0xE000)>>8 | (color & 0x0700)>>6 | (color & 0x0018)>>3);
      }
    }
  }

  else // 1bpp
  {
    // Move coordinate rotation to support fn
    if (_rotation == 1)
    {
      int32_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)
    {
      int32_t tx = x;
      x = y;
      y = _dheight - tx - 1;
    }

    uint8_t* pdata = (uint8_t*) data;
    uint32_t ww =  (w+7) & 0xFFF8;
    for (int32_t yp = 0; yp<h; yp++)
    {
      for (int32_t xp = 0; xp<ww; xp+=8)
      {
        uint8_t pbyte = *pdata++;
        for (uint8_t xc = 0; xc < 8; xc++)
        {
          if (xp+xc<w) drawPixel(x+xp+xc, y+yp, (pbyte<<xc) & 0x80);
        }
      }
    }
  }
}


/***************************************************************************************
** Function name:           pushImage
** Description:             push 565 colour FLASH (PROGMEM) image into a defined area
*************************************************************************************x*/
// TODO Need to add more area boundary checks
void  TFT_eSprite_CST::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, const uint16_t *data)
{
  if ((x >= _iwidth) || (y >= _iheight) || (w == 0) || (h == 0) || !_created) return;

  if (_bpp == 16)
  {
    for (uint32_t yp = y; yp < y + h; yp++)
    {
      for (uint32_t xp = x; xp < x + w; xp++)
      {
        uint16_t color = pgm_read_word(data++);
        if(!_iswapBytes) color = color<<8 | color>>8;
        _img[xp + yp * _iwidth] = color;
      }
    }
  }

  else if (_bpp == 8)
  {
    for (uint32_t yp = y; yp < y + h; yp++)
    {
      for (uint32_t xp = x; xp < x + w; xp++)
      {
        uint16_t color = pgm_read_word(data++);
        if(_iswapBytes) color = color<<8 | color>>8;
        _img8[xp + yp * _iwidth] = (uint8_t)((color & 0xE000)>>8 | (color & 0x0700)>>6 | (color & 0x0018)>>3);
      }
    }
  }

  else // 1bpp
  {
    // Move coordinate rotation to support fn
    if (_rotation == 1)
    {
      int32_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)
    {
      int32_t tx = x;
      x = y;
      y = _dheight - tx - 1;
    }

    const uint8_t* pdata = (const uint8_t* ) data;
    uint32_t ww =  (w+7) & 0xFFF8;
    for (int32_t yp = 0; yp<h; yp++)
    {
      for (int32_t xp = 0; xp<ww; xp+=8)
      {
        uint8_t pbyte = pgm_read_byte(pdata++);
        for (uint8_t xc = 0; xc < 8; xc++)
        {
          if (xp+xc<w) drawPixel(x+xp+xc, y+yp, (pbyte<<xc) & 0x80);
        }
      }
    }
  }
}


/***************************************************************************************
** Function name:           pushImage 8bitDIRECT FAST
** Description:             push 565 colour image into a defined area of a sprite 
*************************************************************************************x*/
/*
// TODO Need to add more area boundary checks
void  TFT_eSprite_CST::pushImage_D8AD(int32_t x, int32_t y, uint32_t w, uint32_t h, uint8_t *data)
{
	pushImage_D8(x,y,w,h,data,0);
}
void  TFT_eSprite_CST::pushImage_D8AD(int32_t x, int32_t y, uint32_t w, uint32_t h, uint8_t *data,uint16_t m)
{
  if ((x >= _iwidth) || (y >= _iheight) || (w == 0) || (h == 0) || !_created ||_bpp != 8) return;
	int yp2;
	switch(m){
		case SPBB_NOR://NORMAL
		default:
			if(m&SPR_CLIP)//Clipping MODE
			for (int32_t yp = 0; yp < h; yp++)
			{
				//Cliping
				if(y+yp>=_iheight){break;}
				else
				if(y+yp<0){data+=w;continue;}
				yp2=(y+yp)*_iwidth;dx=x;dx2=x+w;
				if(dx<0){data+=dx*-1;dx=0;}
				if(dx2>=_iwidth){dt=dx2-_iwidth;dx2=_iwidth;}
				else
				dt=0;
				if(m&SPR_ZERO_T)//Transparent color(0) ON >Run
				for (int32_t xp = dx; xp < dx2; xp++){
					color = *data++;
			 		if(color)_img8[xp + yp2] = color;
			    }
				else
				for (int32_t xp = dx; xp < dx2; xp++){
			 		_img8[xp + yp2] = *data++;
			    }
				data+=dt;
			}
			else//NORMAL
			if(m&SPR_ZERO_T)//Transparent color(0) ON >Run
				for (uint32_t yp = y; yp < y + h; yp++)
				{
					yp2=yp * _iwidth;
				  for (uint32_t xp = x; xp < x + w; xp++)
				  {
					color = *data++;
			 		if(color)_img8[xp + yp2] = color;
				  }
				}
				else//NO EFFECT
				for (uint32_t yp = y; yp < y + h; yp++)
				{
					yp2=yp * _iwidth;
				  for (uint32_t xp = x; xp < x + w; xp++)
				  {
					_img8[xp + yp2]= *data++;
				  }
				}
		break;
		case SPBB_TRA://Fake_Translucent
			if(m&SPR_CLIP)//Clipping MODE
			for (int32_t yp = 0; yp < h; yp++)
			{
				//Cliping
				if(y+yp>=_iheight){break;}
				else
				if(y+yp<0){data+=w;continue;}
				yp2=(y+yp)*_iwidth;dx=x;dx2=x+w;
				if(dx<0){data+=dx*-1;dx=0;}
				if(dx2>=_iwidth){dt=dx2-_iwidth;dx2=_iwidth;}
				else
				dt=0;
				for (int32_t xp = dx; xp < dx2; xp++){
			 		_img8[xp + yp2]|= *data++;
			    }
				data+=dt;
			}
			else//NORMAL
				for (uint32_t yp = y; yp < y + h; yp++)
				{
					yp2=yp * _iwidth;
				  for (uint32_t xp = x; xp < x + w; xp++)
				  {
					_img8[xp + yp2]|= *data++;
				  }
				}
		break;
		case SPBB_RGC://R<>G REVERSE CONVERT(MSX)
			if(m&SPR_CLIP)//Clipping MODE
			for (int32_t yp = 0; yp < h; yp++)
			{
				//Cliping
				if(y+yp>=_iheight){break;}
				else
				if(y+yp<0){data+=w;continue;}
				yp2=(y+yp)*_iwidth;dx=x;dx2=x+w;
				if(dx<0){data+=dx*-1;dx=0;}
				if(dx2>=_iwidth){dt=dx2-_iwidth;dx2=_iwidth;}
				else
				dt=0;
				for (int32_t xp = dx; xp < dx2; xp++){
					 color= *data++;
					_img8[xp + yp2] = ((color>>3)&(0b00011100)) | ((color<<3)&(0b11100000)) | (color&3);
			    }
				data+=dt;
			}
			else//NORMAL
				for (uint32_t yp = y; yp < y + h; yp++)
				{
					yp2=yp * _iwidth;
				  for (uint32_t xp = x; xp < x + w; xp++)
				  {
					color= *data++;
					_img8[xp + yp2] = ((color>>3)&(0b00011100)) | ((color<<3)&(0b11100000)) | (color&3);
				  }
				}
		break;
	}
}
*/
/***************************************************************************************
** Function name:           pushImage 8bitDIRECT ADVANCE Clipping/Transparent 2018/10/5 T.K Add
*************************************************************************************x*/
// TODO Need to add more area boundary checks
void  TFT_eSprite_CST::pushImage_D8AD(int32_t x, int32_t y, uint32_t w, uint32_t h, const uint8_t *data ,uint16_t m ,uint16_t cl,uint16_t ang,uint16_t scl,uint16_t tra)
{
  if (!_created ||_bpp != 8 || (x >= _iwidth) || (y >= _iheight) || (w == 0) || (h == 0) ) return;
	int yp2,dx,dx2,dt;
  int lf,ri,tp,bt,ln;
	byte color;
	if(scl==0)return;
	switch((m&15)){
    case SPBB_MOD://NORMAL
      ln=(int)sqrt(((w*scl)/10000.0f)*((w*scl)/10000.0f)+((h*scl)/10000.0f)*((h*scl)/10000.0f))/2+2; 
      lf=(x-ln);ri=(x+ln);tp=(y-ln);bt=(y+ln);
      int rx,ry,rx2,ry2,lx,lx2,ly,ly2,ycc,ycs,xc,yc,dy;
      int s,c;
      int32_t pa,adr2;
      rx=(w>>1);rx2=(w>>1)*-1;ry=(h>>1);ry2=(h>>1)*-1;
      lx=ln*-1;lx2=ln;ly=ln*-1;ly2=ln;
      s=(int)(sin(((float)(36000-ang)*3.14159265358979323844)/18000)*4096);
      c=(int)(cos(((float)(36000-ang)*3.14159265358979323844)/18000)*4096);
      if(y+ly<0)ly=ly+(0-(y+ly));
      if(x+lx<0)lx=lx+(0-(x+lx));
      if(y+ly2>_iheight)ly2=ly2-(y+ly2-_iheight);
      if(x+lx2>_iwidth)lx2=lx2-(x+lx2-_iwidth);
      for (int32_t yp=ly;yp<ly2;yp++ ) {
        yc=(yp*10000)/scl;
        ycs=yc*s;
        ycc=yc*c;
        for (int32_t xp=lx;xp<lx2;xp++ ) {
          xc=(xp*10000)/scl;
          dx=(int)(xc*c-ycs)>>12;
          dy=(int)(xc*s+ycc)>>12;
          if(dy<ry&&dy>=ry2&&dx<rx&&dx>=rx2);
          else
            continue;
          //if(y+yp<0||y+yp>=_iheight||x+xp<0||x+xp>=_iwidth)continue;
          color =data[(((h>>1)+dy)*w)+((w>>1)+dx)];
          if(color)_img8[(y+yp)*_iwidth+x+xp] = color;
        }
    }
    break;
		case SPBB_NOR://NORMAL
		default:
			if(m&SPR_CLIP)//Clipping MODE
			for (int32_t yp = 0; yp < h; yp++)
			{
				//Cliping
				if(y+yp>=_iheight){break;}
				else
				if(y+yp<0){data+=w;continue;}
				yp2=(y+yp)*_iwidth;dx=x;dx2=x+w;
				if(dx<0){data+=dx*-1;dx=0;}
				if(dx2>=_iwidth){dt=dx2-_iwidth;dx2=_iwidth;}
				else
				dt=0;
				if(m&SPR_ZERO_T)//Transparent color(0) ON >Run
				{ 
					if(m&SPR_COLOR)
					for (int32_t xp = dx+ yp2; xp < dx2+ yp2; xp++){
						color = pgm_read_byte(data++);
			 			if(color)_img8[xp] = cl;
					}
					else
					for (int32_t xp = dx+ yp2; xp < dx2+ yp2; xp++){
						color = pgm_read_byte(data++);
			 			if(color)_img8[xp] = color;
					}
				}
				else
				for (int32_t xp = dx+ yp2; xp < dx2+ yp2; xp++){
			 		_img8[xp] = pgm_read_byte(data++);
			    }
				data+=dt;
			}
			else//NORMAL
			if(m&SPR_ZERO_T)//Transparent color(0) ON >Run
				for (uint32_t yp = y; yp < y + h; yp++)
				{
					yp2=yp * _iwidth;
				  for (uint32_t xp = x + yp2; xp < x + w + yp2; xp++)
				  {
					color = pgm_read_byte(data++);
			 		if(color)_img8[xp] = color;
				  }
				}
				else//NO EFFECT
				for (uint32_t yp = y; yp < y + h; yp++)
				{
					yp2=yp * _iwidth;
				  for (uint32_t xp = x + yp2; xp < x + w + yp2; xp++)
				  {
					_img8[xp]= pgm_read_byte(data++);
				  }
				}
		break;
		case SPBB_TRA://Fake_Translucent
			if(m&SPR_CLIP)//Clipping MODE
			for (int32_t yp = 0; yp < h; yp++)
			{
				//Cliping
				if(y+yp>=_iheight){break;}
				else
				if(y+yp<0){data+=w;continue;}
				yp2=(y+yp)*_iwidth;dx=x;dx2=x+w;
				if(dx<0){data+=dx*-1;dx=0;}
				if(dx2>=_iwidth){dt=dx2-_iwidth;dx2=_iwidth;}
				else
				dt=0;
				for (int32_t xp = dx + yp2; xp < dx2 + yp2; xp++){
			 		_img8[xp]|= pgm_read_byte(data++);
			    }
				data+=dt;
			}
			else//NORMAL
				for (uint32_t yp = y; yp < y + h; yp++)
				{
					yp2=yp * _iwidth;
				  for (uint32_t xp = x + yp2; xp < x + w + yp2; xp++)
				  {
					_img8[xp]|= pgm_read_byte(data++);
				  }
				}
		break;
		case SPBB_RGC://R<>G REVERSE CONVERT(MSX)
			if(m&SPR_CLIP)//Clipping MODE
			for (int32_t yp = 0; yp < h; yp++)
			{
				//Cliping
				if(y+yp>=_iheight){break;}
				else
				if(y+yp<0){data+=w;continue;}
				yp2=(y+yp)*_iwidth;dx=x;dx2=x+w;
				if(dx<0){data+=dx*-1;dx=0;}
				if(dx2>=_iwidth){dt=dx2-_iwidth;dx2=_iwidth;}
				else
				dt=0;
				for (int32_t xp = dx + yp2; xp < dx2 + yp2; xp++){
					 color= pgm_read_byte(data++);
					_img8[xp] = ((color>>3)&(0b00011100)) | ((color<<3)&(0b11100000)) | (color&3);
			    }
				data+=dt;
			}
			else//NORMAL
				for (uint32_t yp = y; yp < y + h; yp++)
				{
					yp2=yp * _iwidth;
				  for (uint32_t xp = x + yp2; xp < x + w + yp2; xp++)
				  {
					color= pgm_read_byte(data++);
					_img8[xp] = ((color>>3)&(0b00011100)) | ((color<<3)&(0b11100000)) | (color&3);
				  }
				}
		break;
	}
}


/***************************************************************************************
** Function name:           pushPartImage 8bitDIRECT Source X,Y Size() ADD
** Description:             push 565 colour image into a defined area of a sprite 
*************************************************************************************x*/
// TODO Need to add more area boundary checks
/*
void  TFT_eSprite_CST::pushPartImage_D8(int32_t x, int32_t y, uint16_t sx, uint16_t sy, uint16_t w, uint16_t h, uint16_t sw, uint8_t *data,uint16_t m,uint16_t m=SPBB_NOR)
{
	if ((x >= _iwidth) || (y >= _iheight) || (w == 0) || (h == 0) || !_created ||_bpp != 8) return;
	int bp,sbp;
	byte color;
	switch(m){
		case SPBB_NOR://NORMAL
		default:
			if(m&SPR_ZERO_T)//Transparent color(0) ON >Run
			for (uint32_t yp = 0; yp < h; yp++)
			{
				bp=(y+yp) * _iwidth +x;sbp=(sy+yp) * _iwidth+sx;
			  for (uint32_t xp = 0; xp < w; xp++)
			  {
				 color=data[xp + sbp];
				 if(color!=0)_img8[xp + bp] =color; 
			  }
			}
			else//NOT T
			for (uint32_t yp = 0; yp < h; yp++)
			{
				bp=(y+yp) * _iwidth +x;sbp=(sy+yp) * _iwidth+sx;
			  for (uint32_t xp = 0; xp < w; xp++)
			  {
				_img8[xp + bp] = data[xp + sbp];
			  }
			}
		break;
		case SPBB_TRA://Fake_Translucent
			for (uint32_t yp = 0; yp < h; yp++)
			{
				bp=(y+yp) * _iwidth +x;sbp=(sy+yp) * _iwidth+sx;
			  for (uint32_t xp = 0; xp < w; xp++)
			  {
				_img8[xp + bp]|= data[xp + sbp];
			  }
			}
		break;
		case SPBB_RGC://R<>G REVERSE CONVERT(MSX)
			for (uint32_t yp = 0; yp < h; yp++)
			{
				bp=(y+yp) * _iwidth +x;sbp=(sy+yp) * _iwidth+sx;
			  for (uint32_t xp = 0; xp < w; xp++)
			  {
				color= data[xp + sbp];
				_img8[xp + bp] = ((color>>3)&(0b00011100)) | ((color<<3)&(0b11100000)) | (color&3);
			  }
			}
		break;
	}
}
*/
/***************************************************************************************
** Function name:           pushImage 8bitDIRECT 2018/10/5 T.K Add
** Description:             push 565 colour FLASH (PROGMEM) image into a defined area
*************************************************************************************x*/
// TODO Need to add more area boundary checks
//
void  TFT_eSprite_CST::pushPartImage_D8(int32_t x, int32_t y, uint16_t sx, uint16_t sy, uint16_t w, uint16_t h, uint16_t sw, const uint8_t *data,uint16_t m ,uint16_t cl,uint16_t ang,uint16_t scl,uint16_t tra)
{
  if (!_created ||_bpp != 8 || (x >= _iwidth) || (y >= _iheight) || (w == 0) || (h == 0) ) return;
	uint32_t bp,sbp;
	byte color;
	switch((m&15)){
		case SPBB_NOR://NORMAL
		default:
			if(m&SPR_CLIP)//Clipping MODE //Not supported
      {
        if(m&SPR_ZERO_T)//Transparent color(0) ON >Run
         for (uint32_t yp = 0; yp < h; yp++)
        {
          //Cliping AHO CODE
          if(y+yp>=_iheight){break;}
          else
          if(y+yp<0){continue;}
          bp=(y+yp) * _iwidth +x;sbp=(uint32_t)data+(sy+yp) * sw+sx;
         if(m&SPR_COLOR)
            for (uint32_t xp = 0; xp < w; xp++)
            {
             //Cliping AHO CODE
             if(x+xp>=_iwidth){break;}
             else
             if(x+xp<0){continue;}
             color=pgm_read_byte(xp + sbp);
             if(color!=0)_img8[xp + bp] =cl; 
            }
          else
            for (uint32_t xp = 0; xp < w; xp++)
            {
             //Cliping AHO CODE
             if(x+xp>=_iwidth){break;}
             else
             if(x+xp<0){continue;}
             color=pgm_read_byte(xp + sbp);
             if(color!=0)_img8[xp + bp] =color; 
            }
        }
        else//NOT T
        for (uint32_t yp = 0; yp < h; yp++)
        {
          //Cliping AHO CODE
          if(y+yp>=_iheight){break;}
          else
          if(y+yp<0){continue;}
          bp=(y+yp) * _iwidth +x;sbp=(sy+yp) * sw+sx;
          for (uint32_t xp = 0; xp < w; xp++)
          {
             //Cliping AHO CODE
             if(x+xp>=_iwidth){break;}
             else
             if(x+xp<0){continue;}
          _img8[xp + bp] = pgm_read_byte(xp + sbp);
          }
        }
  	  }
			else
			{
			  if(m&SPR_ZERO_T)//Transparent color(0) ON >Run
    			for (uint32_t yp = 0; yp < h; yp++)
    			{
    				bp=(y+yp) * _iwidth +x;sbp=(uint32_t)data+(sy+yp) * sw+sx;
    				if(m&SPR_COLOR)
    				  for (uint32_t xp = 0; xp < w; xp++)
    				  {
    					 color=pgm_read_byte(xp + sbp);
    					 if(color!=0)_img8[xp + bp] =cl; 
    				  }
    				else
    				  for (uint32_t xp = 0; xp < w; xp++)
    				  {
    					 color=pgm_read_byte(xp + sbp);
    					 if(color!=0)_img8[xp + bp] =color; 
    				  }
    			}
    			else//NOT T
    			for (uint32_t yp = 0; yp < h; yp++)
    			{
    				bp=(y+yp) * _iwidth +x;sbp=(sy+yp) * sw+sx;
    			  for (uint32_t xp = 0; xp < w; xp++)
    			  {
    				_img8[xp + bp] = pgm_read_byte(xp + sbp);
    			  }
    			}
			}
		break;
		case SPBB_TRA://Fake_Translucent
			if(m&SPR_CLIP);//Clipping MODE //Not supported
			else
			for (uint32_t yp = 0; yp < h; yp++)
			{
				bp=(y+yp) * _iwidth +x;(uint32_t)data+(sy+yp) * sw+sx;
			  for (uint32_t xp = 0; xp < w; xp++)
			  {
				_img8[xp + bp]|= pgm_read_byte(xp + sbp);
			  }
			}
		break;
		case SPBB_RGC://R<>G REVERSE CONVERT(MSX)
			if(m&SPR_CLIP);//Clipping MODE //Not supported
			else
			for (uint32_t yp = 0; yp < h; yp++)
			{
				bp=(y+yp) * _iwidth +x;sbp=(uint32_t)data+(sy+yp) * sw+sx;
			  for (uint32_t xp = 0; xp < w; xp++)
			  {
				color= pgm_read_byte(xp + sbp);
				_img8[xp + bp] = ((color>>3)&(0b00011100)) | ((color<<3)&(0b11100000)) | (color&3);
			  }
			}
		break;
	}
}

/***************************************************************************************
** Function name:           setSwapBytes
** Description:             Used by 16 bit pushImage() to swap byte order in colours
***************************************************************************************/
void TFT_eSprite_CST::setSwapBytes(bool swap)
{
  _iswapBytes = swap;
}


/***************************************************************************************
** Function name:           getSwapBytes
** Description:             Return the swap byte order for colours
***************************************************************************************/
bool TFT_eSprite_CST::getSwapBytes(void)
{
  return _iswapBytes;
}


/***************************************************************************************
** Function name:           setWindow
** Description:             Set the bounds of a window for pushColor and writeColor
*************************************************************************************x*/
void TFT_eSprite_CST::setWindow(int32_t x0, int32_t y0, int32_t x1, int32_t y1)
{
  bool duff_coord = false;

  if (x0 > x1) swap_coord(x0, x1);
  if (y0 > y1) swap_coord(y0, y1);

  if (x0 < 0) x0 = 0;
  if (x0 >= _iwidth) duff_coord = true;
  if (x1 < 0) x1 = 0;
  if (x1 >= _iwidth) x1 = _iwidth - 1;

  if (y0 < 0) y0 = 0;
  if (y0 >= _iheight) duff_coord = true;
  if (y1 < 0) y1 = 0;
  if (y1 >= _iheight) y1 = _iheight - 1;

  if (duff_coord)
  { // Point to that extra "off screen" pixel
    _xs = 0;
    _ys = _iheight;
    _xe = 0;
    _ye = _iheight;
  }
  else
  {
    _xs = x0;
    _ys = y0;
    _xe = x1;
    _ye = y1;
  }

  _xptr = _xs;
  _yptr = _ys;
}


/***************************************************************************************
** Function name:           pushColor
** Description:             Send a new pixel to the set window
*************************************************************************************x*/
void TFT_eSprite_CST::pushColor(uint32_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 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
*************************************************************************************x*/
void TFT_eSprite_CST::pushColor(uint32_t color, uint16_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 = color;

  while(len--) writeColor(pixelColor);
}


/***************************************************************************************
** Function name:           writeColor
** Description:             Write a pixel with pre-formatted colour to the set window
*************************************************************************************x*/
void TFT_eSprite_CST::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 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
*************************************************************************************x*/
void TFT_eSprite_CST::setScrollRect(int32_t x, int32_t y, uint32_t w, uint32_t h, uint16_t color)
{
  if ((x >= _iwidth) || (y >= _iheight) || !_created ) return;

  if (x < 0) x = 0;
  if (y < 0) 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
*************************************************************************************x*/
void TFT_eSprite_CST::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;       // 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 return; // TODO add scroll for 1 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
*************************************************************************************x*/
void TFT_eSprite_CST::fillSprite(uint32_t color)
{
  if (!_created ) return;

  // Use memset if possible as it is super fast
  if(( (uint8_t)color == (uint8_t)(color>>8) ) && _bpp == 16)
                    memset(_img,  (uint8_t)color, _iwidth * _iheight * 2);
  else if (_bpp == 8)
  {
    color = (color & 0xE000)>>8 | (color & 0x0700)>>6 | (color & 0x0018)>>3;
    memset(_img8, (uint8_t)color, _iwidth * _iheight);
  }
  else if (_bpp == 1)
  {
    if(color) memset(_img8, 0xFF, (_iwidth>>3) * _iheight + 1);
    else      memset(_img8, 0x00, (_iwidth>>3) * _iheight + 1);
  }

  else fillRect(0, 0, _iwidth, _iheight, color);
}


/***************************************************************************************
** Function name:           setCursor
** Description:             Set the sprite text cursor x,y position
*************************************************************************************x*/
// Not needed - using TFT_eSPI class function and this->cursor_x/y
//void TFT_eSprite_CST::setCursor(int16_t x, int16_t y)
//{
//  this->cursor_x = x;
//  this->cursor_y = y;
//}


/***************************************************************************************
** Function name:           width
** Description:             Return the width of sprite
*************************************************************************************x*/
// Return the size of the display
int16_t TFT_eSprite_CST::width(void)
{
  if (!_created ) return 0;

  if (_bpp > 1) return _iwidth;

  if (_rotation == 1 || _rotation == 3) return _dheight;

  return _bitwidth;
}


/***************************************************************************************
** Function name:           height
** Description:             Return the height of sprite
*************************************************************************************x*/
int16_t TFT_eSprite_CST::height(void)
{
  if (!_created ) return 0;

  if (_bpp > 1) return _iheight;

  if (_rotation == 1 || _rotation == 3) return _dwidth;

  return _dheight;
}


/***************************************************************************************
** Function name:           setRotation
** Description:             Rotate coordinate frame for 1bpp sprite
*************************************************************************************x*/
// Does nothing for 8 and 16 bpp sprites. TODO allow rotation of these sprites
void TFT_eSprite_CST::setRotation(uint8_t rotation)
{
  _rotation = rotation;
  if (rotation == 0 && _iwidth > _iheight) swap_coord(_iwidth, _iheight);
  if (rotation == 1 && _iwidth < _iheight) swap_coord(_iwidth, _iheight);
  if (rotation == 2 && _iwidth > _iheight) swap_coord(_iwidth, _iheight);
  if (rotation == 3 && _iwidth < _iheight) swap_coord(_iwidth, _iheight);
}


/***************************************************************************************
** Function name:           getRotation
** Description:             Get rotation for 1bpp sprite
*************************************************************************************x*/

uint8_t TFT_eSprite_CST::getRotation(void)
{
  return _rotation;
}


/***************************************************************************************
** Function name:           drawPixel
** Description:             push a single pixel at an arbitrary position
*************************************************************************************x*/
void TFT_eSprite_CST::drawPixel(uint32_t x, uint32_t y, uint32_t color)
{
  // x and y are unsigned so that -ve coordinates turn into large positive ones
  // this make bounds checking a bit faster
  if ((x >= _iwidth) || (y >= _iheight) || !_created) return;

  if (_bpp == 8)
  {
    _img8[x+y*_iwidth] = (uint8_t)((color & 0xE000)>>8 | (color & 0x0700)>>6 | (color & 0x0018)>>3);
  }
  else
  if (_bpp == 16)
  {
    color = (color >> 8) | (color << 8);
    _img[x+y*_iwidth] = (uint16_t) color;
  }
  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:           drawPixel_len //2018/10/3 T.K add
** Description:             push a multi pixel at an arbitrary position
*************************************************************************************x*/
void TFT_eSprite_CST::drawPixel_len(uint32_t x, uint32_t y, uint32_t * color_t, uint32_t len)
{
  // x and y are unsigned so that -ve coordinates turn into large positive ones
  // this make bounds checking a bit faster
	int i;
  if ((x >= _iwidth) || (y >= _iheight) || !_created) return;
	uint32_t color,yb;
	if (_bpp == 16)
	{
		yb=x+y*_iwidth;
		for(i=0;i<len;i++){
			if ((x+i >= _iwidth)) break;
			color = color_t[i];
			color = (color >> 8) | (color << 8);
			_img[yb] = (uint16_t) color;
			yb++;
		}
	}
	else if (_bpp == 8)
	{	yb=x+y*_iwidth;
		for(i=0;i<len;i++){
			if ((x+i >= _iwidth)) break;
			color = color_t[i];
			_img8[yb] = (uint8_t)((color & 0xE000)>>8 | (color & 0x0700)>>6 | (color & 0x0018)>>3);
			yb++;
		}
	}
	else // 1 bpp
	{
		for(i=0;i<len;i++){
			if ((x+i >= _iwidth)) break;
			color = color_t[i];
			if (_rotation == 1)
			{
				uint16_t tx = x + i;
				x = _dwidth - y - 1;
				y = tx;
			}
			else if (_rotation == 2)
			{
				x = _dwidth - x + i - 1;
				y = _dheight - y - 1;
			}
			else if (_rotation == 3)
			{
				uint16_t tx = x + i;
				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
*************************************************************************************x*/
void TFT_eSprite_CST::drawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t color)
{
  if (!_created ) return;

  boolean steep = abs(y1 - y0) > abs(x1 - x0);
  if (steep) {
    swap_coord(x0, y0);
    swap_coord(x1, y1);
  }

  if (x0 > x1) {
    swap_coord(x0, x1);
    swap_coord(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
*************************************************************************************x*/
void TFT_eSprite_CST::drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t color)
{

  if ((x < 0) || (x >= _iwidth) || (y >= _iheight) || !_created) return;

  if (y < 0) { h += y; y = 0; }

  if ((y + h) > _iheight) h = _iheight - y;

  if (h < 1) return;

  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 == 16)
  {
    color = (color >> 8) | (color << 8);
    int32_t yp = x + _iwidth * y;
    while (h--) {_img[yp] = (uint16_t) color; yp += _iwidth;}
  }
  else 
  {
    while (h--)
    {
      drawPixel(x, y, color);
      y++;
    }
  }
}


/***************************************************************************************
** Function name:           drawFastHLine
** Description:             draw a horizontal line
*************************************************************************************x*/
void TFT_eSprite_CST::drawFastHLine(int32_t x, int32_t y, int32_t w, uint32_t color)
{

  if ((y < 0) || (x >= _iwidth) || (y >= _iheight) || !_created) return;

  if (x < 0) { w += x; x = 0; }

  if ((x + w) > _iwidth)  w = _iwidth  - x;

  if (w < 1) return;

  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 == 16)
  {
    color = (color >> 8) | (color << 8);
    while (w--) _img[_iwidth * y + x++] = (uint16_t) color;
  }
  else
  {
    while (w--)
    {
      drawPixel(x, y, color);
      x++;
    }
  }
}


/***************************************************************************************
** Function name:           fillRect
** Description:             draw a filled rectangle
*************************************************************************************x*/
void TFT_eSprite_CST::fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color)
{
  if (!_created ) return;

  if (x < 0) { w += x; x = 0; }
  if (y < 0) { h += y; y = 0; }
  if ((x + w < 0) || (y + h < 0) || (x >= _iwidth) || (y >= _iheight)) return;
  if ((x + w) > _iwidth)  w = _iwidth  - x;
  if ((y + h) > _iheight) h = _iheight - y;
  if ((w < 1) || (h < 1)) return;

  int32_t yp = _iwidth * y + x;

  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 == 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 
  {
    while (h--)
    {
      int32_t ww = w;
      int32_t xx = x;
      while (ww--) drawPixel(xx++, y, color);
      y++;
    }
  }
}


/***************************************************************************************
** Function name:           write
** Description:             draw characters piped through serial stream
*************************************************************************************x*/
size_t TFT_eSprite_CST::write(uint8_t utf8)
{
  if (utf8 == '\r') return 1;

#ifdef SMOOTH_FONT
  if(this->fontLoaded)
  {
    uint16_t unicode = decodeUTF8(utf8);
    if (unicode < 32 && utf8 != '\n') return 0;

    //fontFile = SPIFFS.open( _gFontFilename, "r" );
    //fontFile = SPIFFS.open( this->_gFontFilename, "r" );

    //if(!fontFile)
    //{
    //  fontLoaded = false;
    //  return 0;
    //}
    //Serial.print("Decoded Unicode = 0x");Serial.println(unicode,HEX);

    drawGlyph(unicode);
    //fontFile.close();
    return 0;
  }
#endif

  if (!_created ) return 0;


  uint8_t uniCode = utf8;        // Work with a copy
  if (utf8 == '\n') uniCode+=22; // Make it a valid space character to stop errors
  else if (utf8 < 32) return 0;

  uint16_t width = 0;
  uint16_t height = 0;

//vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv DEBUG vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
  //Serial.print((uint8_t) uniCode); // Debug line sends all printed TFT text to serial port
  //Serial.println(uniCode, HEX); // Debug line sends all printed TFT text to serial port
  //delay(5);                     // Debug optional wait for serial port to flush through
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ DEBUG ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
#ifdef LOAD_GFXFF
  if(!gfxFont) {
#endif
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

#ifdef LOAD_FONT2
  if (textfont == 2)
  {
    if (utf8 > 127) return 0;
    // This is 20us faster than using the fontdata structure (0.443ms per character instead of 0.465ms)
    width = pgm_read_byte(widtbl_f16 + uniCode-32);
    height = chr_hgt_f16;
    // Font 2 is rendered in whole byte widths so we must allow for this
    width = (width + 6) / 8;  // Width in whole bytes for font 2, should be + 7 but must allow for font width change
    width = width * 8;        // Width converted back to pixles
  }
  #ifdef LOAD_RLE
  else
  #endif
#endif

#ifdef LOAD_RLE
  {
    if ((textfont>2) && (textfont<9))
    {
      if (utf8 > 127) return 0;
      // Uses the fontinfo struct array to avoid lots of 'if' or 'switch' statements
      // A tad slower than above but this is not significant and is more convenient for the RLE fonts
      width = pgm_read_byte( (uint8_t *)pgm_read_dword( &(fontdata[textfont].widthtbl ) ) + uniCode-32 );
      height= pgm_read_byte( &fontdata[textfont].height );
    }
  }
#endif

#ifdef LOAD_GLCD
  if (textfont==1)
  {
      width =  6;
      height = 8;
  }
#else
  if (textfont==1) return 0;
#endif

  height = height * textsize;

  if (utf8 == '\n') 
  {
    this->cursor_y += height;
    this->cursor_x  = 0;
  }
  else
  {
    if (textwrapX && (this->cursor_x + width * textsize > _iwidth))
    {
      this->cursor_y += height;
      this->cursor_x = 0;
    }
    if (textwrapY && (this->cursor_y >= _iheight)) this->cursor_y = 0;
    this->cursor_x += drawChar(uniCode, this->cursor_x, this->cursor_y, textfont);
  }

//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
#ifdef LOAD_GFXFF
  } // Custom GFX font
  else
  {

    if(utf8 == '\n') {
      this->cursor_x  = 0;
      this->cursor_y += (int16_t)textsize * (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
    } else {
      if (uniCode > (uint8_t)pgm_read_byte(&gfxFont->last )) return 0;
      if (uniCode < (uint8_t)pgm_read_byte(&gfxFont->first)) return 0;

      uint8_t   c2    = uniCode - pgm_read_byte(&gfxFont->first);
      GFXglyph *glyph = &(((GFXglyph *)pgm_read_dword(&gfxFont->glyph))[c2]);
      uint8_t   w     = pgm_read_byte(&glyph->width),
                h     = pgm_read_byte(&glyph->height);
      if((w > 0) && (h > 0)) { // Is there an associated bitmap?
        int16_t xo = (int8_t)pgm_read_byte(&glyph->xOffset);
        if(textwrapX && ((this->cursor_x + textsize * (xo + w)) > _iwidth)) {
          // Drawing character would go off right edge; wrap to new line
          this->cursor_x  = 0;
          this->cursor_y += (int16_t)textsize * (uint8_t)pgm_read_byte(&gfxFont->yAdvance);
        }
        if (textwrapY && (this->cursor_y >= _iheight)) this->cursor_y = 0;
        drawChar(this->cursor_x, this->cursor_y, uniCode, textcolor, textbgcolor, textsize);
      }
      this->cursor_x += pgm_read_byte(&glyph->xAdvance) * (int16_t)textsize;
    }
  }
#endif // LOAD_GFXFF
//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

  return 1;
}


/***************************************************************************************
** Function name:           drawChar
** Description:             draw a single character in the Adafruit GLCD or freefont
*************************************************************************************x*/
void TFT_eSprite_CST::drawChar(int32_t x, int32_t y, unsigned char c, uint32_t color, uint32_t bg, uint8_t size)
{
  if (!_created ) return;

  if ((x >= _iwidth)            || // Clip right
      (y >= _iheight)           || // Clip bottom
      ((x + 6 * size - 1) < 0) || // Clip left
      ((y + 8 * size - 1) < 0))   // Clip top
    return;

#ifdef LOAD_GLCD
//>>>>>>>>>>>>>>>>>>
#ifdef LOAD_GFXFF
  if(!gfxFont) { // 'Classic' built-in font
#endif
//>>>>>>>>>>>>>>>>>>

  boolean 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 >= (uint8_t)pgm_read_byte(&gfxFont->first)) && (c <= (uint8_t)pgm_read_byte(&gfxFont->last )))
    {
//>>>>>>>>>>>>>>>>>>>>>>>>>>>

      c -= pgm_read_byte(&gfxFont->first);
      GFXglyph *glyph  = &(((GFXglyph *)pgm_read_dword(&gfxFont->glyph))[c]);
      uint8_t  *bitmap = (uint8_t *)pgm_read_dword(&gfxFont->bitmap);

      uint16_t bo = pgm_read_word(&glyph->bitmapOffset);
      uint8_t  w  = pgm_read_byte(&glyph->width),
               h  = pgm_read_byte(&glyph->height),
               xa = pgm_read_byte(&glyph->xAdvance);
      int8_t   xo = pgm_read_byte(&glyph->xOffset),
               yo = pgm_read_byte(&glyph->yOffset);
      uint8_t  xx, yy, bits, bit=0;
      int16_t  xo16 = 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
#endif

}


/***************************************************************************************
** Function name:           drawChar
** Description:             draw a unicode onto the screen
*************************************************************************************x*/
int16_t TFT_eSprite_CST::drawChar(unsigned int uniCode, int x, int y)
{
  return drawChar(uniCode, x, y, textfont);
}

int16_t TFT_eSprite_CST::drawChar(unsigned int uniCode, int x, int y, int font)
{
  if (!_created ) 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_byte(&gfxFont->first)) && (uniCode <= pgm_read_byte(&gfxFont->last) ))
      {
        uint8_t   c2    = uniCode - pgm_read_byte(&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;

  int width  = 0;
  int height = 0;
  uint32_t flash_address = 0;
  uniCode -= 32;

#ifdef LOAD_FONT2
  if (font == 2)
  {
    // This is faster than using the fontdata structure
    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))
    {
      // This is slower than above but is more convenient for the RLE fonts
      flash_address = pgm_read_dword( 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

  int w = width;
  int pX      = 0;
  int pY      = y;
  uint8_t line = 0;

#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;
    if (x + width * textsize >= _iwidth) return width * textsize ;

    for (int i = 0; i < height; i++)
    {
      if (textcolor != textbgcolor) fillRect(x, pY, width * textsize, textsize, textbgcolor);

      for (int 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

    if (textcolor != textbgcolor) fillRect(x, pY, width * textsize, textsize * height, textbgcolor);
    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);
    int px = 0, py = pY; // To hold character block start and end column and row values
    int 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++; // 20 bytes smaller by incrementing here
      if (line & 0x80) {
        line &= 0x7F;
        line++;
        if (ts) {
          px = x + textsize * (pc % width); // Keep these px and py calculations outside the loop as they are slow
          py = y + textsize * (pc / width);
        }
        else {
          px = x + pc % width; // Keep these px and py calculations outside the loop as they are slow
          py = y + pc / width;
        }
        while (line--) {
          pc++;
          setWindow(px, py, px + ts, py + ts);
          if (ts) { tnp = np; while (tnp--) writeColor(color); }
          else    writeColor(color);

          px += textsize;

          if (px >= (x + width * textsize))
          {
            px = x;
            py += textsize;
          }
        }
      }
      else {
        line++;
        pc += line;
      }
    }
  }
  // End of RLE font rendering
#endif
  return width * textsize;    // x +
}

#ifdef SMOOTH_FONT
/***************************************************************************************
** Function name:           drawGlyph
** Description:             Write a character to the sprite cursor position
*************************************************************************************x*/
void TFT_eSprite_CST::drawGlyph(uint16_t code)
{
  if (code < 0x21)
  {
    if (code == 0x20) {
      if (_created) this->cursor_x += this->gFont.spaceWidth;
      else this->cursor_x += this->gFont.spaceWidth;
      return;
    }

    if (code == '\n') {
      if (_created)
      {
      this->cursor_x = 0;
      this->cursor_y += this->gFont.yAdvance;
      if (this->cursor_y >= _height) this->cursor_y = 0;
      return;
      }
      else
      {
        cursor_x = 0;
        cursor_y += gFont.yAdvance;
        if (cursor_y >= _height) cursor_y = 0;
        return;
      }
    }
  }

  uint16_t gNum = 0;
  bool found = this->getUnicodeIndex(code, &gNum);
  
  uint16_t fg = this->textcolor;
  uint16_t bg = this->textbgcolor;

  if (found)
  {
    
    bool newSprite = !_created;
  
    if (newSprite)
    {
      createSprite(this->gWidth[gNum], this->gFont.yAdvance);
      if(bg) fillSprite(bg);
      this->cursor_x = -this->gdX[gNum];
      this->cursor_y = 0;
    }

    this->fontFile.seek(this->gBitmap[gNum], fs::SeekSet); // This is slow for a significant position shift!

    uint8_t pbuffer[this->gWidth[gNum]];

    uint16_t xs = 0;
    uint16_t dl = 0;

    for (int y = 0; y < this->gHeight[gNum]; y++)
    {
      this->fontFile.read(pbuffer, this->gWidth[gNum]);
      for (int x = 0; x < this->gWidth[gNum]; x++)
      {
        uint8_t pixel = pbuffer[x];
        if (pixel)
        {
          if (pixel != 0xFF)
          {
            if (dl) { drawFastHLine( xs, y + this->cursor_y + this->gFont.maxAscent - this->gdY[gNum], dl, fg); dl = 0; }
            if (pixel>127) drawPixel(x + this->cursor_x + this->gdX[gNum], y + this->cursor_y + this->gFont.maxAscent - this->gdY[gNum], alphaBlend(pixel, fg, bg));
          }
          else
          {
            if (dl==0) xs = x + this->cursor_x + this->gdX[gNum];
            dl++;
          }
        }
        else
        {
          if (dl) { drawFastHLine( xs, y + this->cursor_y + this->gFont.maxAscent - this->gdY[gNum], dl, fg); dl = 0; }
        }
      }
      if (dl) { drawFastHLine( xs, y + this->cursor_y + this->gFont.maxAscent - this->gdY[gNum], dl, fg); dl = 0; }
    }

    if (newSprite)
    {
      pushSprite(this->cursor_x + this->gdX[gNum], this->cursor_y, bg);
      deleteSprite();
      this->cursor_x += this->gxAdvance[gNum];
    }
    else this->cursor_x += this->gxAdvance[gNum];
  }
  else
  {
    // Not a Unicode in font so draw a rectangle and move on cursor
    drawRect(this->cursor_x, this->cursor_y + this->gFont.maxAscent - this->gFont.ascent, this->gFont.spaceWidth, this->gFont.ascent, fg);
    this->cursor_x += this->gFont.spaceWidth + 1;
  }
}


/***************************************************************************************
** Function name:           printToSprite
** Description:             Write a string to the sprite cursor position
*************************************************************************************x*/
void TFT_eSprite_CST::printToSprite(String string)
{
  if(!this->fontLoaded) return;
  int16_t len = string.length();
  char cbuffer[len + 1];              // Add 1 for the null
  string.toCharArray(cbuffer, len + 1); // Add 1 for the null, otherwise characters get dropped
  printToSprite(cbuffer, len);
  //printToSprite((char*)string.c_str(), string.length());
}


/***************************************************************************************
** Function name:           printToSprite
** Description:             Write a string to the sprite cursor position
*************************************************************************************x*/
void TFT_eSprite_CST::printToSprite(char *cbuffer, int len) //String string)
{
  if(!this->fontLoaded) return;
  
  //fontFile = SPIFFS.open( this->_gFontFilename, "r" );

  if(!this->fontFile)
  {
    this->fontLoaded = false;
    return;
  }

  uint16_t n = 0;
  bool newSprite = !_created;
  
  if (newSprite)
  {
    int16_t sWidth = 0;
    uint16_t index = 0;

    while (n < len)
    {
      uint16_t unicode = decodeUTF8((uint8_t*)cbuffer, &n, len - n);
      if (this->getUnicodeIndex(unicode, &index))
      {
        if (n == 0) sWidth -= this->gdX[index];
        if (n == len-1) sWidth += ( this->gWidth[index] + this->gdX[index]);
        else sWidth += this->gxAdvance[index];
      }
      else sWidth += this->gFont.spaceWidth + 1;
    }

    createSprite(sWidth, this->gFont.yAdvance);
    uint16_t transparent = TFT_BLACK;

    if (this->textbgcolor != TFT_BLACK) fillSprite(this->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(_tft->cursor_x, _tft->cursor_y);
    deleteSprite();
  }
    
  //fontFile.close();
}


/***************************************************************************************
** Function name:           printToSprite
** Description:             Print character in a Sprite, create sprite if needed
*************************************************************************************x*/
int16_t TFT_eSprite_CST::printToSprite(int16_t x, int16_t y, uint16_t index)
{
  bool newSprite = !_created;
  int16_t sWidth = this->gWidth[index];

  if (newSprite)
  {
    createSprite(sWidth, this->gFont.yAdvance);
    uint16_t transparent = TFT_BLACK;
    if (this->textbgcolor != TFT_BLACK) fillSprite(this->textbgcolor);

    drawGlyph(this->gUnicode[index]);

    pushSprite(x + this->gdX[index], y, this->textbgcolor);
    deleteSprite();
  }

  else drawGlyph(this->gUnicode[index]);

  return this->gxAdvance[index];
}
#endif