Chuyển động tròn trên phần cứng công suất thấp

Tôi đã suy nghĩ về các nền tảng và kẻ thù di chuyển trong vòng tròn trong các trò chơi 2D cũ và tôi đã tự hỏi làm thế nào nó được thực hiện. Tôi hiểu các phương trình tham số, và việc sử dụng sin và cos để thực hiện nó là chuyện nhỏ, nhưng liệu NES hoặc SNES có thể thực hiện các cuộc gọi trig thời gian thực không? Tôi thừa nhận sự thiếu hiểu biết nặng nề, nhưng tôi nghĩ đó là những hoạt động đắt tiền. Có một số cách thông minh để tính toán chuyển động đó rẻ hơn?

Tôi đã làm việc để tạo ra một thuật toán từ các danh tính trig sum sẽ chỉ sử dụng trig tính toán trước, nhưng điều đó có vẻ khó hiểu.

Trên phần cứng như bạn đang mô tả, một giải pháp phổ biến cho trường hợp chung là chỉ cần tạo một bảng tra cứu cho các hàm lượng giác mà người ta quan tâm, đôi khi kết hợp với biểu diễn điểm cố định cho các giá trị.

Vấn đề tiềm ẩn với kỹ thuật này là nó tiêu tốn dung lượng bộ nhớ, mặc dù bạn có thể hạ thấp điều này bằng cách giải quyết độ phân giải dữ liệu thấp hơn trong bảng của bạn hoặc bằng cách tận dụng tính chất định kỳ của một số chức năng để lưu trữ ít dữ liệu hơn và phản chiếu nó khi chạy.

Tuy nhiên, đối với các vòng tròn đi qua cụ thể - để raster chúng hoặc di chuyển thứ gì đó dọc theo một vòng, có thể sử dụng một biến thể của thuật toán dòng của Bresenham . Tất nhiên, thuật toán thực tế của Bresenham cũng hữu ích cho việc đi qua các đường không nằm trong tám hướng "chính" khá rẻ.

Có một biến thể thuật toán của Bresenham bởi James Frith , nó thậm chí còn nhanh hơn vì nó loại bỏ hoàn toàn phép nhân. Nó không cần bất kỳ bảng tra cứu nào để đạt được điều này, mặc dù người ta có thể lưu trữ kết quả trong một bảng nếu bán kính không đổi. Do thuật toán của cả Bresenham và Frith đều sử dụng đối xứng 8 lần, nên bảng tra cứu này sẽ tương đối ngắn.

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

Bạn cũng có thể sử dụng phiên bản xấp xỉ của các hàm lượng giác bằng cách sử dụng Taylor Expansions http://en.wikipedia.org/wiki/Taylor_series

Ví dụ: bạn có thể có một xấp xỉ hợp lý của sin bằng cách sử dụng bốn thuật ngữ chuỗi taylor đầu tiên

Một thuật toán tuyệt vời để di chuyển đồng đều trên một vòng tròn là thuật toán Goertzel . Nó chỉ yêu cầu 2 phép nhân và 2 phép cộng mỗi bước, không có bảng tra cứu và trạng thái rất tối thiểu (4 số).

Trước tiên, xác định một số hằng số, có thể được mã hóa cứng, dựa trên kích thước bước cần thiết (trong trường hợp này là 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;

Thuật toán sử dụng 4 số làm trạng thái của nó, được khởi tạo như thế này:

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

Và cuối cùng là vòng lặp chính:

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

Nó có thể đi mãi mãi. Dưới đây là 50 điểm đầu tiên:

Thuật toán tất nhiên có thể làm việc trên phần cứng điểm cố định. Chiến thắng rõ ràng trước Bresenham là tốc độ không đổi trên vòng tròn.