ls_touchanim.ino

/************************* ls_touchanim: Displays animations for touches **************************
This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License.
To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/
or send a letter to Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
***************************************************************************************************
This displays evolved animations for each touch based on the global settings.
**************************************************************************************************/

int32_t colsInRowsAnimated[MAXROWS];
unsigned long touchAnimationLastMoment[MAXCOLS][MAXROWS];
unsigned long touchAnimationSpeed[MAXCOLS][MAXROWS];
signed char touchAnimationLastState[MAXCOLS][MAXROWS];
byte lastTouchAnimCol[2];
byte lastTouchAnimRow[2];

void initializeTouchAnimation() {
  initializeLedsLayer(LED_LAYER_PLAYED);

  prevTouchAnimTimerCount = millis();

  for (byte i = 0; i < 2; ++i) {
    lastTouchAnimCol[i] = 0;
    lastTouchAnimRow[i] = 0;
  }

  for (byte r = 0; r < MAXROWS; ++r) {
      colsInRowsAnimated[r]= 0;
  }

  for (byte c = 0; c < MAXCOLS; ++c) {
    for (byte r = 0; r < MAXROWS; ++r) {
      touchAnimationLastMoment[c][r] = 0;
      touchAnimationLastState[c][r] = -1;
      touchAnimationSpeed[c][r] = 0;
    }
  }
}

unsigned long calcTouchAnimationSpeed(byte mode, byte value7Bit) {
  unsigned long speed = 196 - value7Bit;
  switch (mode) {
    case playedBlinds:
    case playedCurtains:
    case playedTargets:
    case playedUp:
    case playedDown:
    case playedLeft:
    case playedRight:
    case playedOrbits:
      speed = speed / 2;
      break;
  }
  return speed;
}

void startTouchAnimation(byte col, byte row, unsigned long speed) {
  if (touchAnimationLastState[col][row] != -1) {
      drawTouchedAnimation(col, row, cellOff, touchAnimationLastState[col][row]);
      touchAnimationLastState[col][row] = -1;

      if (lastTouchAnimCol[1] == col && lastTouchAnimRow[1] == row) {
        lastTouchAnimCol[1] = lastTouchAnimCol[0];
        lastTouchAnimRow[1] = lastTouchAnimRow[0];
        lastTouchAnimCol[0] = col;
        lastTouchAnimRow[0] = row;
      }
  }
  else {
    // for expanding touch animations, we only allow two to be active at any given time
    // in order to prevent the whole surface to be lit up with animated cells
    switch (Split[getSplitOf(col)].playedTouchMode) {
      case playedCrosses:
      case playedCircles:
      case playedSquares:
      case playedDiamonds:
      case playedStars:
      case playedSparkles:
      case playedCurtains:
      case playedBlinds:
      case playedTargets: {
        byte clear_col;
        byte clear_row;
        // determine which of the last two animations is outdated and should be replaced
        // with the new one
        if (cell(lastTouchAnimCol[0], lastTouchAnimRow[0]).touched != touchedCell &&
            cell(lastTouchAnimCol[1], lastTouchAnimRow[1]).touched == touchedCell) {
          clear_col = lastTouchAnimCol[0];
          clear_row = lastTouchAnimRow[0];
        }
        else {
          clear_col = lastTouchAnimCol[1];
          clear_row = lastTouchAnimRow[1];
          lastTouchAnimCol[1] = lastTouchAnimCol[0];
          lastTouchAnimRow[1] = lastTouchAnimRow[0];
        }

        // stop a previously active animation
        if (clear_col != 0 && clear_row != 0) {
          drawTouchedAnimation(clear_col, clear_row, cellOff, touchAnimationLastState[clear_col][clear_row]);
          touchAnimationLastState[clear_col][clear_row] = -1;
          colsInRowsAnimated[clear_row] &= ~(int32_t)(1 << clear_col);
        }

        lastTouchAnimCol[0] = col;
        lastTouchAnimRow[0] = row;
        break;
      }
    }
  }

  // store the touch animation info and draw the first frame
  colsInRowsAnimated[row] |= (int32_t)(1 << col);
  touchAnimationLastMoment[col][row] = millis();
  touchAnimationSpeed[col][row] = speed;
  drawTouchedAnimation(col, row, cellOn, 0);
}

void touchAnimLed(byte col, byte row, byte color, CellDisplay disp) {
  if (col > 0) {
    setLed(col, row, color, disp, LED_LAYER_PLAYED);
  }
}

void drawTouchedAnimation(byte col, byte row, CellDisplay disp, signed char state) {
  byte state_max = 5;
  switch (Split[getSplitOf(col)].playedTouchMode) {
    case playedTargets:
      state_max = max(max(row, NUMROWS-row), max(col, NUMCOLS-col)) + 1;
      break;
    case playedBlinds:
    case playedUp:
    case playedDown:
      state_max = max(row, NUMROWS-row) + 1;
      break;
    case playedCurtains:
    case playedLeft:
    case playedRight:
      state_max = max(col, NUMCOLS-col) + 1;
      break;
    case playedOrbits:
      state_max = 8;
      break;
  }

  if (state >= state_max) {
    if (cell(col, row).touched == touchedCell) {
      state = state % state_max;
    }
    else {
      touchAnimationLastMoment[col][row] = 0;
      touchAnimationLastState[col][row] = -1;
      touchAnimationSpeed[col][row] = 0;
      colsInRowsAnimated[row] &= ~(int32_t)(1 << col);
    }
  }
  
  if (state >= 0 && state < state_max) {
    touchAnimationLastState[col][row] = state;

    byte color = Split[getSplitOf(col)].colorPlayed;
    switch (Split[getSplitOf(col)].playedTouchMode) {
      case playedSparkles:
        if (disp == cellOff) {
          for (int c = max(col - state, 0); c <= min(col + state, NUMCOLS); ++c) {
            touchAnimLed(c, row + state, color, disp);
            touchAnimLed(c, row - state, color, disp);
          }
          for (int r = max(row - state, 0); r <= min(row + state, NUMROWS); ++r) {
            touchAnimLed(col + state, r, color, disp);
            touchAnimLed(col - state, r, color, disp);
          }
        }
        else {
          int c1 = random(max(col - state, 0), min(col + state, NUMCOLS) + 1);
          touchAnimLed(c1, row + state, color, disp);
          int c2 = random(max(col - state, 0), min(col + state, NUMCOLS) + 1);
          touchAnimLed(c2, row - state, color, disp);
          int r1 = random(max(row - state, 0), min(row + state, NUMROWS) + 1);
          touchAnimLed(col + state, r1, color, disp);
          int r2 = random(max(row - state, 0), min(row + state, NUMROWS) + 1);
          touchAnimLed(col - state, r2, color, disp);
        }
        break;
      case playedSquares:
        for (int c = max(col - state, 0); c <= min(col + state, NUMCOLS); ++c) {
          touchAnimLed(c, row + state, color, disp);
          touchAnimLed(c, row - state, color, disp);
        }
        for (int r = max(row - state, 0); r <= min(row + state, NUMROWS); ++r) {
          touchAnimLed(col + state, r, color, disp);
          touchAnimLed(col - state, r, color, disp);
        }
        break;
      case playedDiamonds: {
        int c = col - state, r = row;
        for (; c <= col; ++c, ++r) {
          touchAnimLed(c, r, color, disp);
        }
        c = col; r = row + state;
        for (; r >= row; ++c, --r) {
          touchAnimLed(c, r, color, disp);
        }
        c = col + state; r = row;
        for (; c >= col; --c, --r) {
          touchAnimLed(c, r, color, disp);
        }
        c = col; r = row - state;
        for (; r <= row; --c, ++r) {
          touchAnimLed(c, r, color, disp);
        }
        break;
      }
      case playedBlinds:
        for (byte c = 0; c < NUMCOLS; ++c) {
          touchAnimLed(c, row + state, color, disp);
          touchAnimLed(c, row - state, color, disp);
        }
        break;
      case playedCurtains:
        for (byte r = 0; r < NUMROWS; ++r) {
          touchAnimLed(col + state, r, color, disp);
          touchAnimLed(col - state, r, color, disp);
        }
        break;
      case playedCircles:
        switch (state) {
          case 1:
            touchAnimLed(col, row + state, color, disp);
            touchAnimLed(col, row - state, color, disp);
            touchAnimLed(col - state, row, color, disp);
            touchAnimLed(col + state, row, color, disp);
            break;
          case 2:
            touchAnimLed(col - 1, row + state, color, disp);
            touchAnimLed(col + 0, row + state, color, disp);
            touchAnimLed(col + 1, row + state, color, disp);
            touchAnimLed(col - 1, row - state, color, disp);
            touchAnimLed(col + 0, row - state, color, disp);
            touchAnimLed(col + 1, row - state, color, disp);
            touchAnimLed(col - state, row - 1, color, disp);
            touchAnimLed(col - state, row + 0, color, disp);
            touchAnimLed(col - state, row + 1, color, disp);
            touchAnimLed(col + state, row - 1, color, disp);
            touchAnimLed(col + state, row + 0, color, disp);
            touchAnimLed(col + state, row + 1, color, disp);
            break;
          case 3:
            touchAnimLed(col - 2, row + state - 1, color, disp);
            touchAnimLed(col - 1, row + state, color, disp);
            touchAnimLed(col + 0, row + state, color, disp);
            touchAnimLed(col + 1, row + state, color, disp);
            touchAnimLed(col + 2, row + state - 1, color, disp);
            touchAnimLed(col - 2, row - state + 1, color, disp);
            touchAnimLed(col - 1, row - state, color, disp);
            touchAnimLed(col + 0, row - state, color, disp);
            touchAnimLed(col + 1, row - state, color, disp);
            touchAnimLed(col + 2, row - state + 1, color, disp);
            touchAnimLed(col - state, row - 1, color, disp);
            touchAnimLed(col - state, row + 0, color, disp);
            touchAnimLed(col - state, row + 1, color, disp);
            touchAnimLed(col + state, row - 1, color, disp);
            touchAnimLed(col + state, row + 0, color, disp);
            touchAnimLed(col + state, row + 1, color, disp);
            break;
          case 4:
            touchAnimLed(col - 3, row + state - 1, color, disp);
            touchAnimLed(col - 2, row + state - 1, color, disp);
            touchAnimLed(col - 1, row + state, color, disp);
            touchAnimLed(col + 0, row + state, color, disp);
            touchAnimLed(col + 1, row + state, color, disp);
            touchAnimLed(col + 2, row + state - 1, color, disp);
            touchAnimLed(col + 3, row + state - 1, color, disp);
            touchAnimLed(col - 3, row - state + 1, color, disp);
            touchAnimLed(col - 2, row - state + 1, color, disp);
            touchAnimLed(col - 1, row - state, color, disp);
            touchAnimLed(col + 0, row - state, color, disp);
            touchAnimLed(col + 1, row - state, color, disp);
            touchAnimLed(col + 2, row - state + 1, color, disp);
            touchAnimLed(col + 3, row - state + 1, color, disp);
            touchAnimLed(col - state + 1, row - 2, color, disp);
            touchAnimLed(col - state, row - 1, color, disp);
            touchAnimLed(col - state, row + 0, color, disp);
            touchAnimLed(col - state, row + 1, color, disp);
            touchAnimLed(col - state + 1, row + 2, color, disp);
            touchAnimLed(col + state - 1, row - 2, color, disp);
            touchAnimLed(col + state, row - 1, color, disp);
            touchAnimLed(col + state, row + 0, color, disp);
            touchAnimLed(col + state, row + 1, color, disp);
            touchAnimLed(col + state - 1, row + 2, color, disp);
            break;
        }
        break;
      case playedCrosses:
        touchAnimLed(col, row + state, color, disp);
        touchAnimLed(col, row - state, color, disp);
        touchAnimLed(col - state, row, color, disp);
        touchAnimLed(col + state, row, color, disp);
        break;
      case playedStars:
        if (state % 2 == 1) {
          touchAnimLed(col, row + state, color, disp);
          touchAnimLed(col, row - state, color, disp);
          touchAnimLed(col - state, row, color, disp);
          touchAnimLed(col + state, row, color, disp);
        }
        else {
          int half_state =  state / 2;
          touchAnimLed(col - half_state, row + half_state, color, disp);
          touchAnimLed(col + half_state, row - half_state, color, disp);
          touchAnimLed(col - half_state, row - half_state, color, disp);
          touchAnimLed(col + half_state, row + half_state, color, disp);
        }
        break;
      case playedTargets:
        for (int r = row + state; r < NUMROWS; ++r) {
          touchAnimLed(col, r, color, disp);
        }
        for (int r = row - state; r >= 0; --r) {
          touchAnimLed(col, r, color, disp);
        }
        for (int c = col - state; c >= 0; --c) {
          touchAnimLed(c, row, color, disp);
        }
        for (int c = col + state; c < NUMCOLS; ++c) {
          touchAnimLed(c, row, color, disp);
        }
        break;
      case playedUp:
        for (int r = row + state; r < NUMROWS; ++r) {
          touchAnimLed(col, r, color, disp);
        }
        break;
      case playedDown:
        for (int r = row - state; r >= 0; --r) {
          touchAnimLed(col, r, color, disp);
        }
        break;
      case playedLeft:
        for (int c = col - state; c >= 0; --c) {
          touchAnimLed(c, row, color, disp);
        }
        break;
      case playedRight:
        for (int c = col + state; c < NUMCOLS; ++c) {
          touchAnimLed(c, row, color, disp);
        }
        break;
      case playedOrbits:
        switch (state % 4) {
          case 0: touchAnimLed(col - 1, row + 1, color, disp); touchAnimLed(col + 1, row - 1, color, disp); break;
          case 1: touchAnimLed(col, row - 1, color, disp); touchAnimLed(col, row + 1, color, disp); break;
          case 2: touchAnimLed(col + 1, row + 1, color, disp); touchAnimLed(col - 1, row - 1, color, disp); break;
          case 3: touchAnimLed(col - 1, row, color, disp); touchAnimLed(col + 1, row, color, disp); break;
        }
        break;
    }
  }
}

void performAdvanceTouchAnimations(unsigned long nowMillis) {
  if ((Split[LEFT].playedTouchMode == playedCell || Split[LEFT].playedTouchMode == playedSame) &&
      (Split[RIGHT].playedTouchMode == playedCell || Split[RIGHT].playedTouchMode == playedSame)) return;

  bool buffer_started = false;

  for (byte row = 0; row < NUMROWS; ++row) {
    int32_t colsInRowAnimated = colsInRowsAnimated[row];
    while (colsInRowAnimated) {
      byte col = 31 - __builtin_clz(colsInRowAnimated);

      if (!buffer_started) {
        startBufferedLeds();
        buffer_started = true;
      }

      // clear the animation of the touch in its last state
      drawTouchedAnimation(col, row, cellOff, touchAnimationLastState[col][row]);

      colsInRowAnimated &= ~(1 << col);
    }
  }

  if (buffer_started) {
    for (byte row = 0; row < NUMROWS; ++row) {
      int32_t colsInRowAnimated = colsInRowsAnimated[row];
      while (colsInRowAnimated) {
        byte col = 31 - __builtin_clz(colsInRowAnimated);

        signed char state = touchAnimationLastState[col][row];
        unsigned long speed = touchAnimationSpeed[col][row];

        // if the cell is still touched without a pending release and at least 100ms have passed since
        // the initial touch, update the speed of the animation based on the current pressure, but apply
        // it with a slew rate
        TouchInfo* c = &cell(col, row);
        if (c->touched == touchedCell && c->pendingReleaseCount == 0 && calcTimeDelta(nowMillis, c->lastTouch) > 100) {
          speed -= speed/3;
          speed += calcTouchAnimationSpeed(Split[getSplitOf(col)].playedTouchMode, scale1016to127(c->pressureZ, true))/3;
          touchAnimationSpeed[col][row] = speed;
        }

        // if we exceed the time delay between each animation step, increase the state counter
        // and reset the delay
        if (calcTimeDelta(nowMillis, touchAnimationLastMoment[col][row]) >= speed) {
          state += 1;
          touchAnimationLastMoment[col][row] = nowMillis;
        }

        // draw the animation of the touch in its last state
        drawTouchedAnimation(col, row, cellOn, state);
      
        colsInRowAnimated &= ~(1 << col);
      }
    }

    finishBufferedLeds();
  }
}