Gerakan memutar pada perangkat keras bertenaga rendah

Saya sedang memikirkan platform dan musuh yang bergerak berputar-putar di game 2D lama, dan saya bertanya-tanya bagaimana itu dilakukan. Saya mengerti persamaan parametrik, dan itu sepele untuk menggunakan dosa dan cos untuk melakukannya, tetapi bisakah NES atau SNES membuat panggilan waktu nyata? Saya mengakui ketidaktahuan yang berat, tetapi saya pikir itu adalah operasi yang mahal. Apakah ada cara pintar untuk menghitung gerakan itu dengan lebih murah?

Saya telah bekerja untuk mendapatkan algoritme dari identitas jumlah trigonometri yang hanya akan menggunakan trigon prakiraan, tetapi tampaknya berbelit-belit.

Pada perangkat keras seperti yang Anda gambarkan, solusi umum untuk kasus umum adalah dengan hanya menghasilkan tabel pencarian untuk fungsi trigonometri yang diminati, kadang-kadang bersamaan dengan representasi titik tetap untuk nilai.

Masalah potensial dengan teknik ini adalah ia menghabiskan ruang memori, meskipun Anda bisa mengecilkan ini dengan menetapkan resolusi data yang lebih rendah di tabel Anda atau dengan mengambil keuntungan dari sifat periodik dari beberapa fungsi untuk menyimpan lebih sedikit data dan mencerminkannya saat runtime.

Namun, untuk secara khusus melintasi lingkaran - baik untuk meraster mereka atau untuk memindahkan sesuatu, variasi algoritma garis Bresenham dapat digunakan . Algoritma Bresenham yang sebenarnya , tentu saja, juga berguna untuk melintasi garis yang tidak berada di delapan arah "primer" dengan cukup murah.

Ada variasi dari algoritma Bresenham oleh James Frith , yang seharusnya lebih cepat karena sepenuhnya menghilangkan multiplikasi. Tidak perlu tabel pencarian untuk mencapai ini, meskipun orang bisa menyimpan hasilnya dalam tabel jika radius tetap konstan. Karena algoritma Bresenham dan Frith menggunakan simetri 8 kali lipat, tabel pencarian ini akan relatif pendek.

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

Anda juga dapat menggunakan versi perkiraan fungsi trigonometri menggunakan Taylor Expansions http://en.wikipedia.org/wiki/Taylor_series

Sebagai contoh, Anda dapat memiliki perkiraan yang wajar tentang sinus menggunakan empat istilah seri taylor pertama

Salah satu algoritma yang luar biasa untuk melakukan perjalanan secara seragam di atas lingkaran adalah algoritma Goertzel . Ini hanya membutuhkan 2 perkalian dan 2 penambahan per langkah, tidak ada tabel pencarian, dan status yang sangat minimal (4 angka).

Pertama, tentukan beberapa konstanta, mungkin hardcoded, berdasarkan ukuran langkah yang diperlukan (dalam hal ini, 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;

Algoritma menggunakan 4 angka sebagai statusnya, diinisialisasi seperti ini:

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

Dan akhirnya loop utama:

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

Kemudian bisa pergi selamanya. Inilah 50 poin pertama:

Algoritme tentu saja dapat bekerja pada perangkat keras titik tetap. Kemenangan yang jelas melawan Bresenham adalah kecepatan konstan di atas lingkaran.