Movimento circolare su hardware a bassa potenza

Stavo pensando a piattaforme e nemici che si muovevano in cerchio nei vecchi giochi 2D, e mi chiedevo come fosse fatto. Capisco le equazioni parametriche ed è banale usare sin e cos per farlo, ma un NES o SNES può effettuare chiamate trig in tempo reale? Ammetto una forte ignoranza, ma pensavo che fossero operazioni costose. C'è un modo intelligente per calcolare quel movimento in modo più economico?

Ho lavorato per derivare un algoritmo da identità di trig sum che avrebbe utilizzato solo trig precalcolato, ma che sembra contorto.

Su hardware come quello che stai descrivendo, una soluzione comune al caso generale è semplicemente quella di produrre una tabella di consultazione per le funzioni di trigonometria a cui era interessato, a volte in combinazione con rappresentazioni in virgola fissa per valori.

Il potenziale problema con questa tecnica è che consuma spazio di memoria, sebbene sia possibile minimizzare questo accontentandosi di una risoluzione inferiore dei dati nella tabella o sfruttando la natura periodica di alcune funzioni per archiviare meno dati e rispecchiarli in fase di esecuzione.

Tuttavia, per attraversare in modo specifico i cerchi - o per rasterizzarli o per spostare qualcosa lungo uno, è possibile utilizzare una variante dell'algoritmo di linea di Bresenham . L'attuale algoritmo di Bresenham , ovviamente, è utile anche per attraversare linee che non sono abbastanza economiche nelle otto direzioni "primarie".

C'è una variante di algoritmo di Bresenham da James Frith , che dovrebbe essere ancora più veloce in quanto elimina completamente la moltiplicazione. Non è necessaria alcuna tabella di ricerca per raggiungere questo obiettivo, anche se è possibile memorizzare i risultati in una tabella se il raggio rimane costante. Poiché sia ​​l'algoritmo di Bresenham che quello di Frith usano una simmetria 8 volte, questa tabella di ricerca sarebbe relativamente breve.

// FCircle.c - Draws a circle using Frith's algorithm.
// Copyright (c) 1996  James E. Frith - All Rights Reserved.
// Email:  jfrith@compumedia.com

typedef unsigned char   uchar;
typedef unsigned int    uint;

extern void SetPixel(uint x, uint y, uchar color);

// FCircle --------------------------------------------
// Draws a circle using Frith's Algorithm.

void FCircle(int x, int y, int radius, uchar color)
{
  int balance, xoff, yoff;

  xoff = 0;
  yoff = radius;
  balance = -radius;

  do {
    SetPixel(x+xoff, y+yoff, color);
    SetPixel(x-xoff, y+yoff, color);
    SetPixel(x-xoff, y-yoff, color);
    SetPixel(x+xoff, y-yoff, color);
    SetPixel(x+yoff, y+xoff, color);
    SetPixel(x-yoff, y+xoff, color);
    SetPixel(x-yoff, y-xoff, color);
    SetPixel(x+yoff, y-xoff, color);

    balance += xoff++;
    if ((balance += xoff) >= 0)
        balance -= --yoff * 2;

  } while (xoff <= yoff);
} // FCircle //

È inoltre possibile utilizzare una versione approssimata delle funzioni di trigitto utilizzando Taylor Expansions http://en.wikipedia.org/wiki/Taylor_series

Ad esempio, puoi avere una ragionevole approssimazione del seno usando i suoi primi quattro termini della serie taylor

Un algoritmo fantastico per viaggiare uniformemente su un cerchio è l' algoritmo Goertzel . Richiede solo 2 moltiplicazioni e 2 aggiunte per passaggio, nessuna tabella di ricerca e uno stato molto minimo (4 numeri).

Definire innanzitutto alcune costanti, possibilmente codificate, in base alla dimensione del passo richiesta (in questo caso, 2π / 64):

float const step = 2.f * M_PI / 64;
float const s = sin(step);
float const c = cos(step);
float const m = 2.f * c;

L'algoritmo utilizza 4 numeri come stato, inizializzato in questo modo:

float t[4] = { s, c, 2.f * s * c, 1.f - 2.f * s * s };

E infine il ciclo principale:

for (int i = 0; ; i++)
{
    float x = m * t[2] - t[0];
    float y = m * t[3] - t[1];
    t[0] = t[2]; t[1] = t[3]; t[2] = x; t[3] = y;
    printf("%f %f\n", x, y);
}

Può quindi andare per sempre. Ecco i primi 50 punti:

Naturalmente l'algoritmo può funzionare su hardware a virgola fissa. La chiara vittoria contro Bresenham è la velocità costante sul cerchio.