Better write times for a large sprite?

[104TMR]

Many thanks for your work creating the TFT_eSPI library.
I am running an ESP32-S3 N16R8 (board pic attached) with a 4.0" TFT, 480x320, ILI9488 driver, and want to run a full screen graph that updates with new data approximately twice per second, without flicker.
Creating a sprite would seem the natural device to use, and I decided to take the Graph_2 demo and modfiy it to run within a sprite, and see what screen rewrite speeds could be achieved.
The code for this follows, but I have been surprised at the apparent long screen write times (~820ms) for each trace on the graph when written as a sprite (especially compared to the very rapid write times achieved directly (ie. no sprite) to the TFT screen).
I have turned PSRAM on and off (QSPI only - the IDE doesn't seem to allow/recognise OPI), and it doesn't seem to make a difference.

Run output as follows with PSRAM turned on:

ESP-ROM:esp32s3-20210327
Build:Mar 27 2021
rst:0x1 (POWERON),boot:0x2b (SPI_FAST_FLASH_BOOT)
SPIWP:0xee
mode:DIO, clock div:1
load:0x3fce3808,len:0x44c
load:0x403c9700,len:0xbe4
load:0x403cc700,len:0x2a68
entry 0x403c98d4
Total PSRAM: %d8386279
Free PSRAM: %d8386019
YES! Sprite created.
Creating graph
Sprite 1 time=819
Sprite 2 time=819
Sprite 3 time=818'

And with PSRAM turned off:

ESP-ROM:esp32s3-20210327
Build:Mar 27 2021
rst:0x1 (POWERON),boot:0x2b (SPI_FAST_FLASH_BOOT)
SPIWP:0xee
mode:DIO, clock div:1
load:0x3fce3808,len:0x44c
load:0x403c9700,len:0xbe4
load:0x403cc700,len:0x2a68
entry 0x403c98d4
Total heap: %d397396
Free heap: %d367088
Total PSRAM: %d0
Free PSRAM: %d0
YES! Sprite created.
Creating graph
Sprite 1 time=817
Sprite 2 time=816
Sprite 3 time=817

Are such sprite-screen-write-times realistic, or is there something I should be doing differently?
And advice/help appreciated.

Code:

#include <TFT_eSPI.h> // Hardware-specific library
#include <SPI.h>
//#include <SD.h>

TFT_eSPI tft = TFT_eSPI();                   // Invoke custom library with default width and height
TFT_eSprite sprGr = TFT_eSprite(&tft);  //Create a sprite to contain the graph.  Wherever 'tft.' would be used, now use 'sprGr.'


#define LTBLUE    0xB6DF
#define LTTEAL    0xBF5F
#define LTGREEN   0xBFF7
#define LTCYAN    0xC7FF
#define LTRED     0xFD34
#define LTMAGENTA 0xFD5F
#define LTYELLOW  0xFFF8
#define LTORANGE  0xFE73
#define LTPINK    0xFDDF
#define LTPURPLE  0xCCFF
#define LTGREY    0xE71C

#define BLUE      0x001F
#define TEAL      0x0438
#define GREEN     0x07E0
#define CYAN      0x07FF
#define RED       0xF800
#define MAGENTA   0xF81F
#define YELLOW    0xFFE0
#define ORANGE    0xFC00
#define PINK      0xF81F
#define PURPLE    0x8010
#define GREY      0xC618
#define WHITE     0xFFFF
#define BLACK     0x0000

#define DKBLUE    0x000D
#define DKTEAL    0x020C
#define DKGREEN   0x03E0
#define DKCYAN    0x03EF
#define DKRED     0x6000
#define DKMAGENTA 0x8008
#define DKYELLOW  0x8400
#define DKORANGE  0x8200
#define DKPINK    0x9009
#define DKPURPLE  0x4010
#define DKGREY    0x4A49

#define GraphWindowVertOffset 0
#define GraphWindowHorizOffset 0

bool display1 = true;
bool update1 = true;

double ox = -999, oy = -999; // Force them to be off screen
int sprGrWidth, sprGrHeight;
int XOrg, YOrg, GrWidth, GrHeight;
byte ColorDepth=8;
unsigned long StartTime;

void setup() {
  Serial.begin(115200);

  Serial.print("Total heap: %d");
  Serial.println(ESP.getHeapSize()); 
  Serial.print("Free heap: %d");
  Serial.println(ESP.getFreeHeap()); 
  Serial.print("Total PSRAM: %d"); 
  Serial.println( ESP.getPsramSize());
  Serial.print("Free PSRAM: %d"); 
  Serial.println(ESP.getFreePsram());

  double x, y;
  int RotationFlag=1; //0: portrait; 1: landscape
  if (RotationFlag) {
    XOrg=30; YOrg=270; GrWidth=420;GrHeight=240;
    sprGrWidth=480; sprGrHeight=320;
  }
  else {
    XOrg=30; YOrg=430; GrWidth=260;GrHeight=400;
    sprGrWidth=320; sprGrHeight=480;
  }
  
  tft.begin();
  tft.fillScreen(BLACK);
  tft.setRotation(RotationFlag);

  sprGr.setColorDepth(ColorDepth); 
  if (sprGr.createSprite(sprGrWidth, sprGrHeight) == nullptr) Serial.println("Sprite NOT created, insufficient RAM!");
  else Serial.println("YES! Sprite created.");
  //sprGr.createSprite(sprGrWidth, sprGrHeight);

  //Graph(tft, x, y, 1, XOrg, YOrg, GrWidth, GrHeight, 0, 6.5, 1, -1, 1, .25, "", "", "", display1, YELLOW);
  Serial.println("Creating graph");
  // sprGr.fillSprite(TFT_NAVY); 
  // sprGr.drawRect(0, 0, sprGrWidth, sprGrHeight, TFT_YELLOW);
  // sprGr.pushSprite(0,GraphWindowVertOffset);
  Graph(x, y, 1, XOrg, YOrg, GrWidth, GrHeight, 0, 6.5, 1, -1, 1, .25, "", "", "", display1, YELLOW);
  sprGr.pushSprite(GraphWindowHorizOffset,GraphWindowVertOffset);
  
  update1 = true;
  for (x = 0; x <= 6.3; x += .1) {
    y = sin(x);
    Trace(x, y, 1, XOrg, YOrg, GrWidth, GrHeight, 0, 6.5, 1, -1, 1, .25, "Sin(x)", "x", "fn(x)", update1, YELLOW);
  }
  StartTime=millis();
  sprGr.pushSprite(0,GraphWindowVertOffset);
  Serial.println("Sprite 1 time="+String(millis()-StartTime));
  delay(2000);

  update1 = true;
  for (x = 0; x <= 6.3; x += .1) {
    y = cos(x);
    Trace(x, y, 1, XOrg, YOrg, GrWidth, GrHeight, 0, 6.5, 1, -1, 1, .25, "Sin(x) + Cos(x)", " x", "fn(x)", update1, TFT_PINK);
  }
  StartTime=millis();
  sprGr.pushSprite(0,GraphWindowVertOffset);
  Serial.println("Sprite 2 time="+String(millis()-StartTime));
  delay(2000);
  
  update1 = true;
  for (x = 0; x <= 6.3; x += .02) {
    y = tan(x);
    Trace(x, y, 1, XOrg, YOrg, GrWidth, GrHeight, 0, 6.5, 1, -1, 1, .25, "Sin(x) + Cos(x) + Tan(x)", " x", "fn(x)", update1, CYAN);
  }
  StartTime=millis();
  sprGr.pushSprite(0,GraphWindowVertOffset);
  Serial.println("Sprite 3 time="+String(millis()-StartTime));
}


void loop(void) {
}

void Graph( double x, double y, byte dp,
            double gx, double gy, double w, double h,
            double xlo, double xhi, double xinc,
            double ylo, double yhi, double yinc,
            char *title, char *xlabel, char *ylabel,
            bool &redraw, unsigned int color) {

  double ydiv, xdiv;
  double i;
  double temp;
  int rot, newrot;

  // gcolor = graph grid colors
  // acolor = axes line colors
  // pcolor = color of your plotted data
  // tcolor = text color
  // bcolor = background color
  unsigned int gcolor = DKBLUE;
  unsigned int acolor = RED;
  unsigned int pcolor = color;
  unsigned int tcolor = WHITE;
  unsigned int bcolor = BLACK;

  if (redraw == true) {

    redraw = false;
    // initialize old x and old y in order to draw the first point of the graph
    // but save the transformed value
    // note my transform funcition is the same as the map function, except the map uses long and we need doubles
    //ox = (x - xlo) * ( w) / (xhi - xlo) + gx;
    //oy = (y - ylo) * (gy - h - gy) / (yhi - ylo) + gy;

    sprGr.setTextDatum(MR_DATUM);

    // draw y scale
    for ( i = ylo; i <= yhi; i += yinc) {
      // compute the transform
      temp =  (i - ylo) * (gy - h - gy) / (yhi - ylo) + gy;

      if (i == 0) {
        sprGr.drawLine(gx, temp, gx + w, temp, acolor);
        sprGr.setTextColor(acolor, bcolor);
        sprGr.drawString(xlabel, (int)(gx + w) , (int)temp, 2);
      }
      else {
        sprGr.drawLine(gx, temp, gx + w, temp, gcolor);
      }
      // draw the axis labels
      sprGr.setTextColor(tcolor, bcolor);
      // precision is default Arduino--this could really use some format control
      sprGr.drawFloat(i, dp, gx - 4, temp, 1);
    }

    // draw x scale
    for (i = xlo; i <= xhi; i += xinc) {

      // compute the transform
      temp =  (i - xlo) * ( w) / (xhi - xlo) + gx;
      if (i == 0) {
        sprGr.drawLine(temp, gy, temp, gy - h, acolor);
        sprGr.setTextColor(acolor, bcolor);
        sprGr.setTextDatum(BC_DATUM);
        sprGr.drawString(ylabel, (int)temp, (int)(gy - h - 8) , 2);
      }
      else {
        sprGr.drawLine(temp, gy, temp, gy - h, gcolor);
      }
      // draw the axis labels
      sprGr.setTextColor(tcolor, bcolor);
      sprGr.setTextDatum(TC_DATUM);
      // precision is default Arduino--this could really use some format control
      sprGr.drawFloat(i, dp, temp, gy + 7, 1);
    }

    //now draw the graph labels
    sprGr.setTextColor(tcolor, bcolor);
    sprGr.drawString(title, (int)(gx + w / 2) , (int)(gy - h - 30), 4);
  }

}

void Trace(double x,  double y,  byte dp,
           double gx, double gy,
           double w, double h,
           double xlo, double xhi, double xinc,
           double ylo, double yhi, double yinc,
           char *title, char *xlabel, char *ylabel,
           bool &update1, unsigned int color)
{
  double ydiv, xdiv;
  double i;
  double temp;
  int rot, newrot;

  //unsigned int gcolor = DKBLUE;   // gcolor = graph grid color
  unsigned int acolor = RED;        // acolor = main axes and label color
  unsigned int pcolor = color;      // pcolor = color of your plotted data
  unsigned int tcolor = WHITE;      // tcolor = text color
  unsigned int bcolor = BLACK;      // bcolor = background color

  // initialize old x and old y in order to draw the first point of the graph
  // but save the transformed value
  // note my transform funcition is the same as the map function, except the map uses long and we need doubles
  if (update1) {
    update1 = false;
    
    ox = (x - xlo) * ( w) / (xhi - xlo) + gx;
    oy = (y - ylo) * (gy - h - gy) / (yhi - ylo) + gy;

    if ((ox < gx) || (ox > gx+w)) {update1 = true; return;}
    if ((oy < gy-h) || (oy > gy)) {update1 = true; return;}
    

    sprGr.setTextDatum(MR_DATUM);

    // draw y scale
    for ( i = ylo; i <= yhi; i += yinc) {
      // compute the transform
      temp =  (i - ylo) * (gy - h - gy) / (yhi - ylo) + gy;

      if (i == 0) {
        sprGr.setTextColor(acolor, bcolor);
        sprGr.drawString(xlabel, (int)(gx + w) , (int)temp, 2);
      }
      // draw the axis labels
      sprGr.setTextColor(tcolor, bcolor);
      // precision is default Arduino--this could really use some format control
      sprGr.drawFloat(i, dp, gx - 4, temp, 1);
    }

    // draw x scale
    for (i = xlo; i <= xhi; i += xinc) {

      // compute the transform
      temp =  (i - xlo) * ( w) / (xhi - xlo) + gx;
      if (i == 0) {
        sprGr.setTextColor(acolor, bcolor);
        sprGr.setTextDatum(BC_DATUM);
        sprGr.drawString(ylabel, (int)temp, (int)(gy - h - 8) , 2);
      }

      // draw the axis labels
      sprGr.setTextColor(tcolor, bcolor);
      sprGr.setTextDatum(TC_DATUM);
      // precision is default Arduino--this could really use some format control
      sprGr.drawFloat(i, dp, temp, gy + 7, 1);
    }

    //now draw the graph labels
    sprGr.setTextColor(tcolor, bcolor);
    sprGr.drawString(title, (int)(gx + w / 2) , (int)(gy - h - 30), 4);
  }

  // the coordinates are now drawn, plot the data
  // the entire plotting code are these few lines...
  // recall that ox and oy are initialized above
  x =  (x - xlo) * ( w) / (xhi - xlo) + gx;
  y =  (y - ylo) * (gy - h - gy) / (yhi - ylo) + gy;

  if ((x < gx) || (x > gx+w)) {update1 = true; return;}
  if ((y < gy-h) || (y > gy)) {update1 = true; return;}
    
    
  sprGr.drawLine(ox, oy, x, y, pcolor);
  // it's up to you but drawing 2 more lines to give the graph some thickness
  //sprGr.drawLine(ox, oy + 1, x, y + 1, pcolor);
  //sprGr.drawLine(ox, oy - 1, x, y - 1, pcolor);
  ox = x;
  oy = y;
}

/*
  End of graphing function
*/