Movimento circular em hardware de baixa potência

Eu estava pensando em plataformas e inimigos se movendo em círculos nos antigos jogos 2D, e fiquei imaginando como isso foi feito. Entendo equações paramétricas, e é trivial usar sin e cos para fazer isso, mas um NES ou SNES poderia fazer chamadas em tempo real? Eu admito muita ignorância, mas achei que eram operações caras. Existe alguma maneira inteligente de calcular esse movimento mais barato?

Eu tenho trabalhado em derivar um algoritmo de identidades de soma trigonométrica que usariam somente trig pré-calculado, mas isso parece complicado.

Em hardware como o que você está descrevendo, uma solução comum para o caso geral é simplesmente produzir uma tabela de consulta para as funções trigonométricas em que estava interessado, às vezes em conjunto com representações de ponto fixo para valores.

O possível problema com essa técnica é que ela consome espaço na memória, embora você possa minimizá-la, definindo uma resolução mais baixa dos dados em sua tabela ou aproveitando a natureza periódica de algumas funções para armazenar menos dados e espelhá-los em tempo de execução.

No entanto, para atravessar círculos especificamente - seja para rasterizá-los ou para mover algo ao longo de um, uma variação do algoritmo de linha de Bresenham pode ser empregada . O algoritmo real de Bresenham , é claro, também é útil para atravessar linhas que não estão nas oito direções "primárias" com um preço bastante baixo.

Há uma variação de algoritmo Bresenham por James Frith , que deve ser ainda mais rápido, pois elimina completamente a multiplicação. Não é necessária nenhuma tabela de pesquisa para conseguir isso, embora seja possível armazenar os resultados em uma tabela se o raio permanecer constante. Como o algoritmo de Bresenham e Frith usa simetria 8 vezes, essa tabela de pesquisa seria relativamente curta.

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

Você também pode usar uma versão aproximada das funções trigonométricas usando o Taylor Expansions http://en.wikipedia.org/wiki/Taylor_series

Por exemplo, você pode ter uma aproximação razoável do seno usando seus primeiros quatro termos da série taylor

Um algoritmo impressionante para viajar uniformemente sobre um círculo é o algoritmo de Goertzel . Requer apenas 2 multiplicações e 2 adições por etapa, nenhuma tabela de pesquisa e um estado muito mínimo (4 números).

Primeiro, defina algumas constantes, possivelmente codificadas, com base no tamanho da etapa necessária (neste 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;

O algoritmo usa 4 números como seu estado, inicializado assim:

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

E finalmente o loop 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);
}

Pode então ir para sempre. Aqui estão os primeiros 50 pontos:

Obviamente, o algoritmo pode funcionar em hardware de ponto fixo. A vitória clara contra o Bresenham é a velocidade constante sobre o círculo.