Spiegazione aritmetica del passaggio temporale

L'ho portato da link qualche tempo fa.

Tuttavia ora sto volendo modificarlo allo scopo di cambiarlo da una virgola mobile a una matematica a virgola fissa per una maggiore efficienza (per coloro che parleranno di ottimizzazione prematura e cosa no, voglio avere il mio intero motore in punto fisso sia come processo di apprendimento per me e così posso portare il codice più facilmente ai sistemi in futuro che non hanno punti mobili nativi come arm cpus)

La conversione iniziale a punti fissi ha provocato il ciclaggio bloccato sul primo o sull'ultimo fotogramma del ciclismo.

Inoltre sarebbe bello capire meglio come funziona in modo da poter aggiungere più opzioni e così via in futuro, la mia matematica comunque fa schifo e i commenti sono limitati quindi non so davvero come funziona la matematica per determinare il inquadralo usando (cycleAmount)

Ero anche un principiante quando l'ho portato come non avevo idea tra punti mobili e interi e cosa no.

Quindi in sintesi la mia domanda è, qualcuno può dare un'esplosione dell'aritmetica usata per determinare il cicloAmount (che determina il "fotogramma" del ciclo)

Questa è la versione matematica in virgola mobile del codice:

public final void cycle(Colour[] sourceColours, double timeNow, double speedAdjust) {
  // Cycle all animated colour ranges in palette based on timestamp.
  sourceColours = sourceColours.clone();

  int cycleSize;
  double cycleRate;
  double cycleAmount;

  Cycle cycle;
  for (int i = 0, len = cycles.length; i < len; ++i) {
    cycle = cycles[i];

    cycleSize = (cycle.HIGH - cycle.LOW) + 1;
    cycleRate = cycle.RATE / (int) (CYCLE_SPEED / speedAdjust);
    cycleAmount = 0;

    if (cycle.REVERSE < 3) {
      // Standard Cycle
      cycleAmount = DFLOAT_MOD((timeNow / (1000 / cycleRate)), cycleSize);
      if (cycle.REVERSE < 1) {
        cycleAmount = cycleSize - cycleAmount; // If below 1 make sure its not reversed.
      }
    } else if (cycle.REVERSE == 3) {
      // Ping-Pong
      cycleAmount = DFLOAT_MOD((timeNow / (1000 / cycleRate)), cycleSize << 1);
      if (cycleAmount >= cycleSize) {
        cycleAmount = (cycleSize * 2) - cycleAmount;
      }
    } else if (cycle.REVERSE < 6) {
      // Sine Wave
      cycleAmount = DFLOAT_MOD((timeNow / (1000 / cycleRate)), cycleSize);
      cycleAmount = Math.sin((cycleAmount * 3.1415926 * 2) / cycleSize) + 1;
      if (cycle.REVERSE == 4) {
        cycleAmount *= (cycleSize / 4);
      } else if (cycle.REVERSE == 5) {
        cycleAmount *= (cycleSize >> 1);
      }
    }

    if (cycle.REVERSE == 2) {
      reverseColours(sourceColours, cycle);
    }

    if (USE_BLEND_SHIFT) {
      blendShiftColours(sourceColours, cycle, cycleAmount);
    } else {
      shiftColours(sourceColours, cycle, cycleAmount);
    }

    if (cycle.REVERSE == 2) {
      reverseColours(sourceColours, cycle);
    }
  }
colours = sourceColours;
}

// This utility function allows for variable precision floating point modulus.
private double DFLOAT_MOD(final double d, final double b) {
  return (Math.floor(d * PRECISION) % Math.floor(b * PRECISION)) / PRECISION;
}