Düşük güçlü donanımda dairesel hareket

Eski 2D oyunlarda çevrelerde hareket eden platformları ve düşmanları düşünüyordum ve bunun nasıl yapıldığını merak ediyordum. Parametrik denklemleri anlıyorum ve bunu yapmak için günah ve cos kullanmak önemsiz, ancak bir NES veya SNES gerçek zamanlı tetikleme çağrıları yapabilir mi? Ağır cehalet kabul ediyorum, ama bunların pahalı operasyonlar olduğunu düşündüm. Bu hareketi daha ucuza hesaplamanın akıllıca bir yolu var mı?

Sadece önceden hesaplanmış trig kullanan trig toplam kimliklerinden bir algoritma türetmek için çalışıyordum, ama bu kıvrık görünüyor.

Tanımladığınız gibi donanımda, genel durum için ortak bir çözüm, birinin ilgilendiği trigonometri fonksiyonları için, bazen değerler için sabit nokta gösterimleri ile birlikte, bir arama tablosu oluşturmaktır.

Bu teknikle ilgili potansiyel sorun, bellek alanını tüketmesidir, ancak tablonuzdaki verilerin daha düşük bir çözünürlüğüne karar vererek veya daha az veri depolamak ve çalışma zamanında yansıtmak için bazı işlevlerin periyodik doğasından yararlanarak bunu önemsiz gösterebilirsiniz.

Bununla birlikte, spesifik olarak çapraz çevreler için - ya rasterleştirmek ya da bir şeyi bir yere taşımak için , Bresenham'ın çizgi algoritmasının bir varyasyonu kullanılabilir . Bresenham'ın gerçek algoritması , elbette, sekiz "birincil" yönde olmayan çizgileri oldukça ucuza çevirmek için de yararlıdır.

Bir varyasyonu var Bresenham algoritması tarafından James Frith tamamen çarpma ortadan kaldırır çünkü daha hızlı olmalı. Yarıçap sabit kalırsa sonuçları bir tabloda saklayabilse de, bunu başarmak için herhangi bir arama tablosuna gerek yoktur. Hem Bresenham hem de Frith'in algoritması 8 kat simetri kullandığından, bu arama tablosu nispeten kısa olacaktır.

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

Taylor Expansions'ı kullanarak trig işlevlerinin yaklaşık bir sürümünü de kullanabilirsiniz http://en.wikipedia.org/wiki/Taylor_series

Örneğin, ilk dört taylor serisi terimini kullanarak sinüsün makul bir yaklaşımına sahip olabilirsiniz.

Bir daire üzerinde eşit olarak dolaşmak için harika bir algoritma Goertzel algoritmasıdır . Adım başına sadece 2 çarpma ve 2 ekleme, arama tablosu ve çok düşük bir durum (4 sayı) gerektirir.

İlk olarak, gerekli adım boyutuna göre (muhtemelen bu durumda 2π / 64) sabit kodlanmış bazı sabitleri tanımlayın:

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

Algoritmanın durumu olarak 4 sayı kullanılır ve şu şekilde başlatılır:

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

Ve son olarak ana döngü:

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

O zaman sonsuza dek gidebilir. İşte ilk 50 puan:

Algoritma elbette sabit nokta donanımı üzerinde çalışabilir. Bresenham'a karşı açık galibiyet daire üzerindeki sabit hızdır.