Movimiento circular en hardware de baja potencia.

Estaba pensando en plataformas y enemigos que se movían en círculos en viejos juegos 2D, y me preguntaba cómo se hacía eso. Entiendo ecuaciones paramétricas, y es trivial usar sin y cos para hacerlo, pero ¿podría un NES o SNES hacer llamadas trigonométricas en tiempo real? Admito una gran ignorancia, pero pensé que eran operaciones costosas. ¿Hay alguna forma inteligente de calcular ese movimiento de manera más barata?

He estado trabajando para derivar un algoritmo a partir de identidades de suma trigonométrica que solo usarían trigonométricas precalculadas, pero eso parece complicado.

En hardware como el que está describiendo, una solución común para el caso general es simplemente producir una tabla de búsqueda para las funciones de trigonometría que le interesaban, a veces junto con representaciones de valores de punto fijo.

El problema potencial con esta técnica es que consume espacio en la memoria, aunque puede minimizar esto al conformarse con una resolución más baja de los datos en su tabla o al aprovechar la naturaleza periódica de algunas funciones para almacenar menos datos y reflejarla en tiempo de ejecución.

Sin embargo, para atravesar círculos específicamente, ya sea para rasterizarlos o para mover algo a lo largo de uno, se puede emplear una variación del algoritmo de línea de Bresenham . El algoritmo real de Bresenham , por supuesto, también es útil para atravesar líneas que no están en las ocho direcciones "primarias" de manera bastante económica.

Hay una variación del algoritmo de Bresenham por James Frith , que debería ser aún más rápido ya que elimina por completo la multiplicación. No necesita ninguna tabla de búsqueda para lograr esto, aunque uno podría almacenar los resultados en una tabla si el radio se mantiene constante. Dado que tanto el algoritmo de Bresenham como el de Frith utilizan una simetría de 8 veces, esta tabla de búsqueda sería relativamente corta.

// FCircle.c - Draws a circle using Frith's algorithm.
// Copyright (c) 1996  James E. Frith - All Rights Reserved.
// Email:  [email protected]

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 //

También puede usar una versión aproximada de las funciones trigonométricas usando Taylor Expansions http://en.wikipedia.org/wiki/Taylor_series

Por ejemplo, puede tener una aproximación razonable del seno utilizando sus primeros cuatro términos de la serie taylor

Un algoritmo impresionante para viajar uniformemente sobre un círculo es el algoritmo de Goertzel . Requiere solo 2 multiplicaciones y 2 adiciones por paso, sin tabla de búsqueda y un estado muy mínimo (4 números).

Primero defina algunas constantes, posiblemente codificadas, basadas en el tamaño de paso requerido (en este 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;

El algoritmo usa 4 números como estado, inicializado así:

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

Y finalmente el bucle principal:

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);
}

Entonces puede ir para siempre. Aquí están los primeros 50 puntos:

El algoritmo, por supuesto, puede funcionar en hardware de punto fijo. La clara victoria contra Bresenham es la velocidad constante sobre el círculo.