การเคลื่อนที่แบบวงกลมบนฮาร์ดแวร์ที่ใช้พลังงานต่ำ

ฉันกำลังคิดเกี่ยวกับแพลตฟอร์มและศัตรูที่เคลื่อนที่เป็นวงกลมในเกม 2D เก่าและฉันก็สงสัยว่ามันทำอย่างไร ฉันเข้าใจสมการแบบพารามิเตอร์และเป็นเรื่องง่ายที่จะใช้บาปและ cos เพื่อทำสิ่งนั้น แต่ NES หรือ SNES สามารถโทรหาแบบเรียลไทม์ได้หรือไม่ ฉันยอมรับความโง่เขลาอย่างหนัก แต่ฉันคิดว่าสิ่งเหล่านั้นเป็นการปฏิบัติการที่มีราคาแพง มีวิธีที่ฉลาดกว่าในการคำนวณการเคลื่อนไหวนั้นถูกกว่าหรือไม่?

ฉันพยายามหาอัลกอริธึมจากอัตลักษณ์รวมของตรีโกณมิติที่จะใช้ตรีโกณมิติแบบ precalculated แต่ดูเหมือนว่าซับซ้อน

บนฮาร์ดแวร์เช่นที่คุณกำลังอธิบายวิธีแก้ปัญหาทั่วไปสำหรับกรณีทั่วไปคือเพียงแค่สร้างตารางการค้นหาสำหรับฟังก์ชันตรีโกณมิติที่เราสนใจบางครั้งร่วมกับการเป็นตัวแทนจุดคงที่สำหรับค่า

ปัญหาที่อาจเกิดขึ้นกับเทคนิคนี้คือมันใช้เนื้อที่หน่วยความจำถึงแม้ว่าคุณสามารถดาวน์ไลท์นี้ได้โดยการตั้งค่าความละเอียดของข้อมูลในตารางของคุณที่ต่ำกว่าหรือโดยการใช้ประโยชน์จากธรรมชาติของฟังก์ชั่นบางอย่างเพื่อเก็บข้อมูลน้อยลง

แต่สำหรับเฉพาะภายในวงกลม - ทั้งเพื่อ rasterize พวกเขาหรือจะย้ายสิ่งที่ตามหนึ่งการเปลี่ยนแปลงของอัลกอริทึมสาย Bresenham สามารถได้รับการว่าจ้าง แน่นอนว่าอัลกอริทึมที่แท้จริงของ Bresenhamนั้นมีประโยชน์สำหรับการสำรวจเส้นทางที่ไม่ได้อยู่ในทิศทางแปด "หลัก" ค่อนข้างถูก

มีการเปลี่ยนแปลงของอัลกอริทึมของ BresenhamโดยJames Frithซึ่งน่าจะเร็วกว่านี้เพราะมันจะกำจัดการคูณอย่างสมบูรณ์ ไม่จำเป็นต้องใช้ตารางการค้นหาใด ๆ เพื่อให้บรรลุถึงสิ่งนี้แม้ว่าจะสามารถเก็บผลลัพธ์ไว้ในตารางได้หากรัศมียังคงที่ เนื่องจากทั้งอัลกอรึทึมของ Bresenham และ Frith ใช้สมมาตร 8 เท่าตารางการค้นหานี้จึงค่อนข้างสั้น

// 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 http://en.wikipedia.org/wiki/Taylor_series

ตัวอย่างเช่นคุณสามารถมีการประมาณค่าไซน์ที่สมเหตุสมผลโดยใช้คำสี่ชุดเทย์เลอร์เป็นครั้งแรก

ขั้นตอนวิธีการหนึ่งที่น่ากลัวในการเดินทางเหมือนกันกว่าวงกลมเป็นอัลกอริทึม Goertzel มันต้องการเพียงแค่การคูณ 2 ครั้งและการเพิ่ม 2 ครั้งต่อขั้นตอนไม่มีตารางการค้นหาและสถานะที่น้อยมาก (4 ตัวเลข)

ขั้นแรกให้กำหนดค่าคงที่บางค่าซึ่งอาจเป็นฮาร์ดโค้ดโดยขึ้นอยู่กับขนาดขั้นตอนที่ต้องการ (ในกรณีนี้คือ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;

อัลกอริทึมใช้ตัวเลข 4 ตัวเป็นสถานะเริ่มต้นดังนี้:

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

และในที่สุดวงหลัก:

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

มันสามารถไปได้ตลอดไป นี่คือ 50 คะแนนแรก:

แน่นอนว่าอัลกอริทึมสามารถทำงานกับฮาร์ดแวร์จุดคงที่ได้ การชนะอย่างชัดเจนต่อ Bresenham คือความเร็วคงที่ตลอดทั้งวงกลม