prodriguez/choco-chip8
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

implemented draw function in interpreter

Browse Source
This commit is contained in:
Pablo Rodriguez
2024-11-28 19:38:11 -05:00
parent 5429c5fac1
commit ea4b961d53
5 changed files with 151 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
DisplaySDL.hpp
View File

@@ -7,7 +7,7 @@
class DisplaySDL : public chocochip8::Display {
public:
DisplaySDL(int w, int h, uint32_t fgCol, uint32_t bgCol);
DisplaySDL(int w, int h, uint32_t fgCol = 0xffffff, uint32_t bgCol = 0x000000);
~DisplaySDL() override;
void updateWindow() const;

129
Interpreter.cpp
View File

@@ -4,6 +4,44 @@
namespace chocochip8 {
constexpr uint16_t gcvLowResToHighResRowLookupTable[256] = {
0x0000, 0x0003, 0x000C, 0x000F, 0x0030, 0x0033, 0x003C, 0x003F, 0x00C0, 0x00C3, 0x00CC, 0x00CF, 0x00F0, 0x00F3, 0x00FC, 0x00FF,
0x0300, 0x0303, 0x030C, 0x030F, 0x0330, 0x0333, 0x033C, 0x033F, 0x03C0, 0x03C3, 0x03CC, 0x03CF, 0x03F0, 0x03F3, 0x03FC, 0x03FF,
0x0C00, 0x0C03, 0x0C0C, 0x0C0F, 0x0C30, 0x0C33, 0x0C3C, 0x0C3F, 0x0CC0, 0x0CC3, 0x0CCC, 0x0CCF, 0x0CF0, 0x0CF3, 0x0CFC, 0x0CFF,
0x0F00, 0x0F03, 0x0F0C, 0x0F0F, 0x0F30, 0x0F33, 0x0F3C, 0x0F3F, 0x0FC0, 0x0FC3, 0x0FCC, 0x0FCF, 0x0FF0, 0x0FF3, 0x0FFC, 0x0FFF,
0x3000, 0x3003, 0x300C, 0x300F, 0x3030, 0x3033, 0x303C, 0x303F, 0x30C0, 0x30C3, 0x30CC, 0x30CF, 0x30F0, 0x30F3, 0x30FC, 0x30FF,
0x3300, 0x3303, 0x330C, 0x330F, 0x3330, 0x3333, 0x333C, 0x333F, 0x33C0, 0x33C3, 0x33CC, 0x33CF, 0x33F0, 0x33F3, 0x33FC, 0x33FF,
0x3C00, 0x3C03, 0x3C0C, 0x3C0F, 0x3C30, 0x3C33, 0x3C3C, 0x3C3F, 0x3CC0, 0x3CC3, 0x3CCC, 0x3CCF, 0x3CF0, 0x3CF3, 0x3CFC, 0x3CFF,
0x3F00, 0x3F03, 0x3F0C, 0x3F0F, 0x3F30, 0x3F33, 0x3F3C, 0x3F3F, 0x3FC0, 0x3FC3, 0x3FCC, 0x3FCF, 0x3FF0, 0x3FF3, 0x3FFC, 0x3FFF,
0xC000, 0xC003, 0xC00C, 0xC00F, 0xC030, 0xC033, 0xC03C, 0xC03F, 0xC0C0, 0xC0C3, 0xC0CC, 0xC0CF, 0xC0F0, 0xC0F3, 0xC0FC, 0xC0FF,
0xC300, 0xC303, 0xC30C, 0xC30F, 0xC330, 0xC333, 0xC33C, 0xC33F, 0xC3C0, 0xC3C3, 0xC3CC, 0xC3CF, 0xC3F0, 0xC3F3, 0xC3FC, 0xC3FF,
0xCC00, 0xCC03, 0xCC0C, 0xCC0F, 0xCC30, 0xCC33, 0xCC3C, 0xCC3F, 0xCCC0, 0xCCC3, 0xCCCC, 0xCCCF, 0xCCF0, 0xCCF3, 0xCCFC, 0xCCFF,
0xCF00, 0xCF03, 0xCF0C, 0xCF0F, 0xCF30, 0xCF33, 0xCF3C, 0xCF3F, 0xCFC0, 0xCFC3, 0xCFCC, 0xCFCF, 0xCFF0, 0xCFF3, 0xCFFC, 0xCFFF,
0xF000, 0xF003, 0xF00C, 0xF00F, 0xF030, 0xF033, 0xF03C, 0xF03F, 0xF0C0, 0xF0C3, 0xF0CC, 0xF0CF, 0xF0F0, 0xF0F3, 0xF0FC, 0xF0FF,
0xF300, 0xF303, 0xF30C, 0xF30F, 0xF330, 0xF333, 0xF33C, 0xF33F, 0xF3C0, 0xF3C3, 0xF3CC, 0xF3CF, 0xF3F0, 0xF3F3, 0xF3FC, 0xF3FF,
0xFC00, 0xFC03, 0xFC0C, 0xFC0F, 0xFC30, 0xFC33, 0xFC3C, 0xFC3F, 0xFCC0, 0xFCC3, 0xFCCC, 0xFCCF, 0xFCF0, 0xFCF3, 0xFCFC, 0xFCFF,
0xFF00, 0xFF03, 0xFF0C, 0xFF0F, 0xFF30, 0xFF33, 0xFF3C, 0xFF3F, 0xFFC0, 0xFFC3, 0xFFCC, 0xFFCF, 0xFFF0, 0xFFF3, 0xFFFC, 0xFFFF
};
constexpr uint8_t gcvLowResFontData[80] = {
0xF0, 0x90, 0x90, 0x90, 0xF0,
0x20, 0x60, 0x20, 0x20, 0x70,
0xF0, 0x10, 0xF0, 0x80, 0xF0,
0xF0, 0x10, 0xF0, 0x10, 0xF0,
0x90, 0x90, 0xF0, 0x10, 0x10,
0xF0, 0x80, 0xF0, 0x10, 0xF0,
0xF0, 0x80, 0xF0, 0x90, 0xF0,
0xF0, 0x10, 0x20, 0x40, 0x40,
0xF0, 0x90, 0xF0, 0x90, 0xF0,
0xF0, 0x90, 0xF0, 0x10, 0xF0,
0xF0, 0x90, 0xF0, 0x90, 0x90,
0xE0, 0x90, 0xE0, 0x90, 0xE0,
0xF0, 0x80, 0x80, 0x80, 0xF0,
0xE0, 0x90, 0x90, 0x90, 0xE0,
0xF0, 0x80, 0xF0, 0x80, 0xF0,
0xF0, 0x80, 0xF0, 0x80, 0x80
};
Interpreter::Interpreter(unsigned ticksPerSecond, Display &display, Buzzer &buzzer, Keypad &keypad):
mvMemory(scMemorySize),
mCallStack{},
@@ -12,7 +50,13 @@ Interpreter::Interpreter(unsigned ticksPerSecond, Display &display, Buzzer &buzz
mrKeypad{keypad},
mcTicksPerSecond{ticksPerSecond},
mvSpecialReg{},
mvReg{} {}
mvReg{},
mIsHighResMode{false} {
// Font sprite data goes into the interpreter reserved memory area
memcpy(mvMemory.data() + scLowRestFontAddr, gcvLowResFontData, sizeof(gcvLowResFontData));
// Initialize any non-zero registers at startup
mvSpecialReg[SR_PC] = scResetVector;
}
void Interpreter::tick() {
// decodes all possible machine code arithmetic opcodes
@@ -28,9 +72,9 @@ void Interpreter::tick() {
unsigned inst = (mvMemory[pc] << 8) | mvMemory[pc + 1];
// extract fields
unsigned regDst = (inst & 0x0F00) >> 8; // destination register index
unsigned regSrc = (inst & 0x00F0) >> 4; // source register index
unsigned opcode = (inst & 0x000F); // arithmetic opcode
unsigned iRegDst = (inst & 0x0F00) >> 8; // destination register index
unsigned iRegSrc = (inst & 0x00F0) >> 4; // source register index
unsigned opcode = (inst & 0x000F); // arithmetic opcode or sprite index
unsigned imm8 = (inst & 0x00FF); // 8-bit immediate
unsigned imm12 = (inst & 0x0FFF); // 12-bit immediate
@@ -59,25 +103,25 @@ void Interpreter::tick() {
mvSpecialReg[SR_PC] = imm12;
break;
case 0x3000: // 3XNN - skip if equal immediate
executeArithmetic(Opcode::JEQ, regDst, imm8);
executeArithmetic(Opcode::JEQ, iRegDst, imm8);
break;
case 0x4000: // 4XNN - skip if nonequal immediate
executeArithmetic(Opcode::JNEQ, regDst, imm8);
executeArithmetic(Opcode::JNEQ, iRegDst, imm8);
break;
case 0x5000: // 5XY0 - skip if equal
executeArithmetic(Opcode::JEQ, regDst, mvReg[regSrc]);
executeArithmetic(Opcode::JEQ, iRegDst, mvReg[iRegSrc]);
break;
case 0x6000: // 6XNN - load immediate
executeArithmetic(Opcode::SET, regDst, imm8);
executeArithmetic(Opcode::SET, iRegDst, imm8);
break;
case 0x7000: // 7XNN - increment
executeArithmetic(Opcode::ADD, regDst, imm8);
executeArithmetic(Opcode::ADD, iRegDst, imm8);
break;
case 0x8000: // 8XNN - general arithmetic
executeArithmetic(opcodeMap[opcode], regDst, mvReg[regSrc]);
executeArithmetic(opcodeMap[opcode], iRegDst, mvReg[iRegSrc]);
break;
case 0x9000: // 9XY0 - skip if nonequal
executeArithmetic(Opcode::JNEQ, regDst, mvReg[regSrc]);
executeArithmetic(Opcode::JNEQ, iRegDst, mvReg[iRegSrc]);
break;
case 0xA000: // ANNN - load I
mvSpecialReg[SR_I] = imm12;
@@ -86,9 +130,10 @@ void Interpreter::tick() {
mvSpecialReg[SR_I] = mvReg[R_V0] + imm12;
break;
case 0xC000: // CXNN - load random
executeArithmetic(Opcode::RAND, regDst, imm8);
executeArithmetic(Opcode::RAND, iRegDst, imm8);
break;
case 0xD000: // DXYN - draw
executeDraw(mvReg[iRegDst], mvReg[iRegSrc], opcode);
break;
case 0xE000: // EX9E, EXA1 - keypad access
break;
@@ -111,11 +156,11 @@ void Interpreter::tick() {
}
}
void Interpreter::loadProgram(size_t where, char const* data, size_t count) {
void Interpreter::loadProgram(char const* data, size_t count, size_t where) {
if(where + count > scMemorySize) {
throw std::out_of_range("program exceeds memory bounds or capacity");
}
memcpy(mvMemory.data(), data, count);
memcpy(mvMemory.data() + where, data, count);
}
void Interpreter::executeArithmetic(Opcode opcode, int iReg, reg_t operand) {
@@ -165,4 +210,60 @@ void Interpreter::executeArithmetic(Opcode opcode, int iReg, reg_t operand) {
}
}
void Interpreter::executeDraw(uint8_t x, uint8_t y, uint8_t n) {
size_t iMemAddr = mvSpecialReg[SR_I]; // address of the sprite data in memory
int collisionCount = 0; // number of scanlines in which any pixel changes from on to off
// coordinates are doubled in low resolution mode
if(!mIsHighResMode) {
x *= 2;
y *= 2;
}
x %= gcWidth;
y %= gcHeight;
// make x=0 be the right side of the screen instead of the left
x = gcWidth - x;
// draw each row of the sprite
for(int i = 0; i < (mIsHighResMode && n == 0 ? 16 : n); i++) {
uint16_t spriteRowBits;
if(mIsHighResMode) {
// draws an 8xN sprite
spriteRowBits = mvMemory[iMemAddr++] << 8;
if(n == 0) {
// draws an 16xN sprite, so fetch another byte from sprite data
spriteRowBits |= mvMemory[iMemAddr++];
}
} else {
// in low-res mode, each sprite pixel draws two on-screen pixels
spriteRowBits = gcvLowResToHighResRowLookupTable[mvMemory[iMemAddr++]];
}
// convert to bitset and shift into absolute horizontal position on the screen
Scanline spriteScanline(spriteRowBits);
if(x < 16) {
spriteScanline >>= (16 - x);
} else {
spriteScanline <<= (x - 16);
}
// we draw one scanline per sprite row in high-res mode, but twice in low-res mode
for(int j = 0; j < (mIsHighResMode ? 1 : 2); j++) {
Scanline &targetScanline = mrDisplay.mpFramebuffer->at(y + i * (mIsHighResMode ? 1 : 2) + j);
if((targetScanline & spriteScanline) != 0) {
collisionCount += 1;
}
// blit the sprite bitset into the screen
targetScanline ^= spriteScanline;
}
// update state flags
if(mIsHighResMode) {
mvReg[R_VF] = collisionCount;
} else {
mvReg[R_VF] = (collisionCount > 0 ? 1 : 0);
}
}
}
}; // namespace chochochip8

5
Interpreter.hpp
View File

@@ -14,6 +14,7 @@ private:
using sreg_t = unsigned;
public:
constexpr static sreg_t scLowRestFontAddr = 0x0000;
constexpr static sreg_t scResetVector = 0x0200;
constexpr static size_t scMemorySize = 4096;
@@ -35,10 +36,11 @@ public:
public:
Interpreter(unsigned ticksPerSecond, Display &display, Buzzer &buzzer, Keypad &keypad);
void tick();
void loadProgram(size_t where, char const* data, size_t count);
void loadProgram(char const* data, size_t count, size_t where = scResetVector);
private:
void executeArithmetic(Opcode opcode, int iReg, reg_t operand);
void executeDraw(uint8_t x, uint8_t y, uint8_t n);
private:
std::vector<uint8_t> mvMemory;
@@ -49,6 +51,7 @@ private:
const unsigned mcTicksPerSecond;
sreg_t mvSpecialReg[SR_COUNT];
reg_t mvReg[R_COUNT];
bool mIsHighResMode;
}; // class Interpreter
}; // namespace chocohip8

2
Peripherals.hpp
View File

@@ -37,7 +37,7 @@ namespace chocochip8 {
class Keypad {
public:
virtual ~Keypad() = default;
virtual void isKeyPressed(Key key) = 0;
virtual bool isKeyPressed(Key key) = 0;
};
}; // namespace chocochip8

39
main.cpp
View File

@@ -3,6 +3,7 @@
#include "BuzzerSDL.hpp"
#include "DisplaySDL.hpp"
#include "Interpreter.hpp"
#include "Peripherals.hpp"
int main(int argc, char* args[]) {
@@ -11,18 +12,38 @@ int main(int argc, char* args[]) {
return 1;
}
class DisplayTest : public DisplaySDL {
public:
DisplayTest() : DisplaySDL(1280, 640, 0xff0000, 0x00ff00) {
for(int i = 0; i < chocochip8::gcHeight; i+=2) {
mpFramebuffer->at(i).set();
}
}
class TestKeypad : public chocochip8::Keypad {
bool isKeyPressed(chocochip8::Key) override { return false; }
};
BuzzerSDL buzzer(440);
//buzzer.on();
DisplayTest display;
DisplaySDL display(1280, 640);
TestKeypad keypad;
chocochip8::Interpreter chip8(90, display, buzzer, keypad);
uint8_t prog[] = {
0xA0, 0x00, // LD I,0
0x60, 0x00, // LD $0,0
0x61, 0x00, // LD $1,0
0xD0, 0x15, // DRW $0, $1, 5
0xA0, 0x05, // LD I,5
0x60, 0x3C, // LD $0,60
0x61, 0x00, // LD $1,0
0xD0, 0x15, // DRW $0, $1, 5
0xA0, 0x0A, // LD I,10
0x60, 0x00, // LD $0,0
0x61, 0x1B, // LD $1,27
0xD0, 0x15, // DRW $0, $1, 5
0xA0, 0x0F, // LD I,15
0x60, 0x3C, // LD $0,60
0x61, 0x1B, // LD $1,27
0xD0, 0x15, // DRW $0, $1, 5
};
chip8.loadProgram((char*)prog, sizeof(prog));
for(int i = 0; i < sizeof(prog) / 2; i++) {
chip8.tick();
}
SDL_Event event;
while(SDL_WaitEvent(&event) && event.type != SDL_QUIT) {