profan
/
chipd8
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
chipd8/source/app.d

1106 lines
23 KiB
D
Raw Blame History

import std.stdio;
import derelict.sdl2.sdl;
import derelict.imgui.imgui;
import glad.gl.all;
import window;
import imgui;
bool checkShaderError(GLuint shader, GLuint flag, bool is_program, in char[] shader_path) nothrow {
GLint result;
(is_program) ? glGetProgramiv(shader, flag, &result)
: glGetShaderiv(shader, flag, &result);
if (result == GL_FALSE) {
GLchar[256] log; //FIXME this is potentially fatal
(is_program) ? glGetProgramInfoLog(shader, log.sizeof, null, log.ptr)
: glGetShaderInfoLog(shader, log.sizeof, null, log.ptr);
printf("[OpenGL] Error in %s: %s\n", shader_path.ptr, log.ptr);
return false;
}
return true;
} // checkShaderError
struct PixelBuffer {
struct Shader {
private {
GLuint shader_prog;
}
@disable this(this);
void compile(const (GLchar*)* vs_source, const (GLchar*)* fs_source) {
import core.stdc.stdlib : exit;
GLuint new_vs_shader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(new_vs_shader, 1, vs_source, null);
glCompileShader(new_vs_shader);
if (!checkShaderError(new_vs_shader, GL_COMPILE_STATUS, false, "vertex_shader")) {
exit(-1);
}
GLuint new_fs_shader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(new_fs_shader, 1, fs_source, null);
glCompileShader(new_fs_shader);
if (!checkShaderError(new_fs_shader, GL_COMPILE_STATUS, false, "fragment_shader")) {
exit(-1);
}
GLuint new_shader = glCreateProgram();
glAttachShader(new_shader, new_vs_shader);
glAttachShader(new_shader, new_fs_shader);
// glBindAttribLocation(new_shader, 0, "screen_size");
glLinkProgram(new_shader);
if (!checkShaderError(new_shader, GL_LINK_STATUS, true, "shader_program")) {
exit(-1);
}
glValidateProgram(new_shader);
if (!checkShaderError(new_shader, GL_VALIDATE_STATUS, true, "shader_program")) {
exit(-1);
}
shader_prog = new_shader;
} // compile
void setUniforms(int w, int h) {
auto attr_loc = glGetUniformLocation(shader_prog, "screen_size");
glUniform2f(attr_loc, cast(float)w, cast(float)h);
} // setUniforms
void bind() {
glUseProgram(shader_prog);
} // bind
void unbind() {
glUseProgram(0);
} // unbind
} // Shader
struct Texture {
import derelict.sdl2.sdl;
import derelict.sdl2.image;
private {
GLuint texture_; //OpenGL handle for texture
GLenum input_format_, output_format_, data_type_;
int width_, height_;
}
@property @nogc nothrow {
int width() const { return width_; }
int height() const { return height_; }
GLuint handle() { return texture_; }
}
@disable this(this);
nothrow @nogc
this(int width, int height, GLenum input_format, GLenum output_format, GLenum unpack_alignment) {
width_ = width;
height_ = height;
input_format_ = input_format;
output_format_ = output_format;
data_type_ = GL_UNSIGNED_BYTE;
glGenTextures(1, &texture_);
glBindTexture(GL_TEXTURE_2D, texture_);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_alignment);
glTexImage2D(GL_TEXTURE_2D, 0, input_format_, width_, height_, 0, output_format_, GL_UNSIGNED_BYTE, cast(void*)0);
glBindTexture(GL_TEXTURE_2D, 0);
} //this
nothrow @nogc
void create(void* pixels, int width, int height, GLenum input_format = GL_RGB, GLenum output_format = GL_RGB, GLenum data_type = GL_UNSIGNED_BYTE) {
width_ = width;
height_ = height;
input_format_ = input_format;
output_format_ = output_format;
data_type_ = data_type;
//generate single texture, put handle in texture
glGenTextures(1, &texture_);
//normal 2d texture, bind to our texture handle
glBindTexture(GL_TEXTURE_2D, texture_);
//set texture parameters in currently bound texture, controls texture wrapping (or GL_CLAMP?)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
//linearly interpolate between pixels, MIN if texture is too small for drawing area, MAG if drawing area is smaller than texture
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
//texture type, level, format to store as, width, height, border, format loaded in
glTexImage2D(GL_TEXTURE_2D, 0, input_format_, width_, height_, 0, output_format_, data_type_, pixels);
//UNBIND
glBindTexture(GL_TEXTURE_2D, 0);
} // this
~this() nothrow @nogc {
if (texture_ != 0) {
glDeleteTextures(1, &texture_);
}
} // ~this
/**
* Binds the texture handle, takes an argument for which texture unit to use.
*/
nothrow @nogc
void bind(int unit) {
assert(unit >= 0 && unit <= 31);
glActiveTexture(GL_TEXTURE0 + unit); //since this is sequential, this works
glBindTexture(GL_TEXTURE_2D, texture_);
} // bind
nothrow @nogc
void unbind() {
glBindTexture(GL_TEXTURE_2D, 0);
} // unbind
/**
* Updates the texture in place given the new texture buffer.
* Takes an optional offset to update only a part of the texture.
**/
nothrow @nogc
void update(void[] pixels, size_t offset = 0) {
bind(0);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width_, height_, input_format_, data_type_, pixels.ptr);
unbind();
} // update
} // Texture
/**
* Generic VertexArray structure, used to upload data of any given vertex type to the GPU.
*/
struct VertexArray {
private {
GLuint vao_;
GLuint vbo_;
GLenum type_; // type of vertex data, GL_TRIANGLES etc
uint num_vertices_;
}
@disable this(this);
nothrow @nogc
void create(in float[2][] vertices, GLenum draw_type = GL_STATIC_DRAW, GLenum primitive = GL_TRIANGLES) {
this.num_vertices_ = cast(uint)vertices.length;
this.type_ = primitive;
glGenVertexArrays(1, &vao_);
glBindVertexArray(vao_);
glGenBuffers(1, &vbo_);
glBindBuffer(GL_ARRAY_BUFFER, vbo_);
glBufferData(GL_ARRAY_BUFFER, vertices.length * vertices[0].sizeof, vertices.ptr, draw_type);
// pos
glEnableVertexAttribArray(0);
glVertexAttribPointer(0,
2,
GL_FLOAT,
GL_FALSE,
float.sizeof * 2,
null
);
glBindVertexArray(0);
} // this
~this() nothrow @nogc {
if (vao_ != 0) {
glDeleteVertexArrays(1, &vao_);
}
} // ~this
void bind() nothrow @nogc {
glBindVertexArray(vao_);
} // bind
void draw() nothrow @nogc {
glDrawArrays(type_, 0, num_vertices_);
} // draw
void unbind() nothrow @nogc {
glBindVertexArray(0);
} // unbind
} // VertexArray
const char* vs_shader = q{
#version 330 core
uniform vec2 screen_size;
layout(location = 0) in vec2 pos;
out vec2 frag_uv;
void main() {
gl_Position = vec4(pos, 0.0, 1.0);
frag_uv = clamp(pos, vec2(0.0, 0.0), vec2(1.0, 1.0));
}
};
const char* fs_shader = q{
#version 330 core
uniform sampler2D tex;
in vec2 frag_uv;
out vec4 out_col;
void main() {
float v = texture(tex, frag_uv.st).r * 255;
out_col = vec4(v, v, v, 1.0);
}
};
Shader shader;
VertexArray vao;
Texture tex;
void create(void* pixels, int w, int h) {
float[2][6] rect = [
[-1.0f, -1.0f], // top left
[1.0f, -1.0f], // top right
[1.0f, 1.0f], // bottom right
[-1.0f, -1.0f], // top left
[-1.0f, 1.0f], // bottom left
[1.0f, 1.0f], // bottom right
];
vao.create(rect[]);
tex.create(pixels, w, h, GL_RED, GL_RED);
shader.compile(&vs_shader, &fs_shader);
} // create
void draw(int screen_w, int screen_h) {
vao.bind();
shader.bind();
shader.setUniforms(screen_w, screen_h);
tex.bind(0);
vao.draw();
} // draw
nothrow @nogc
void update(void[] pixels, size_t offset = 0) {
tex.update(pixels, offset);
} // update
} // PixelBuffer
struct Chip8Status {
//emu ptr
Emulator* run_;
Chip8* emu_;
// mem editor
// MemoryEditor mem_editor_;
// state
bool status_menu_ = true;
int stack_cur_ = -1;
void initialize(Emulator* run, Chip8* emu) {
this.run_ = run;
this.emu_ = emu;
} // initialize
alias Callback = float delegate(int idx, const char** out_text);
static extern(C) bool doCallback(void* ptr, int idx, const (char**) out_text) {
auto callback = *(cast(Callback*) ptr);
callback(idx, out_text);
return true;
} // doCallback;
void getStackFrame(int idx, const (char**) out_text) {
static char[32] frame_text;
import core.stdc.stdio : sprintf;
sprintf(frame_text.ptr, "0x%04X", emu_.stack[idx]);
auto p = frame_text.ptr;
auto op = cast(char**)out_text;
*op = p;
} // getStackFrame
void resetShortcut() {
emu_.reset();
} // resetShortcut
void loadShortcut() {
import std.file : read;
auto buf = read("programs/sqrt.ch8");
emu_.load(0x200, buf); // do ze load yes, will copy all the data in
} // loadShortcut
void saveShortcut() {
} // saveShortcut
void debugShortcut() {
status_menu_ = !status_menu_;
} // debugShortcut
void redrawShortcut() {
emu_.draw_flag = true;
} // redrawShortcut
void toggleRunShortcut() {
emu_.run_flag = !emu_.run_flag;
} // toggleRunShortcut
void stepShortcut() {
emu_.step();
} // stepShortcut
void quitShortcut() {
run_.quit();
} // quitShortcut
void draw() {
if (!status_menu_) return;
if (igBeginMainMenuBar()) {
if (igBeginMenu("Menu")) {
if (igMenuItem("Reset", "CTRL+R")) {
resetShortcut();
}
if (igMenuItem("Load", "CTRL+L")) {
loadShortcut();
}
if (igMenuItem("Debug", "CTRL+D")) {
debugShortcut();
}
if (igMenuItem("Quit", "CTRL+Q")) {
quitShortcut();
}
igEndMenu();
}
igEndMainMenuBar();
}
{
import std.range : chunks;
igBegin("Emulator Status");
igBeginChild("General");
igText("OpCode: 0x%04X", emu_.cpu.opcode);
igText("PC:");
igSameLine();
igText("pc: 0x%04X (%hu)", emu_.cpu.pc, emu_.cpu.pc);
// igDragInt("##pc", cast(int*)&emu_.cpu.pc, 0.5f, 0, emu_.ram.length);
igText("Registers (v0 - vF)");
igColumns(4, null, false);
auto n = 0;
foreach (ref chunk; emu_.cpu.v[].chunks(4)) {
igText("v%0X 0x%02X ", n, chunk[0]);
igText("v%0X 0x%02X ", n+1, chunk[1]);
igText("v%0X 0x%02X ", n+2, chunk[2]);
igText("v%0X 0x%02X ", n+3, chunk[3]);
igNextColumn();
n += 4;
}
igColumns(1, null, false);
igText("Index Register: 0x%04X", emu_.cpu.i);
igText("Delay Timer: 0x%04X", emu_.cpu.delay_timer);
igText("Sound Timer: 0x%04X", emu_.cpu.sound_timer);
if(igButton("Step")) {
emu_.step();
}
igSameLine();
if (igButton((emu_.run_flag) ? "Stop" : "Run")) {
emu_.run_flag = !emu_.run_flag;
}
igText("Stack");
auto d = &getStackFrame;
igPushItemWidth(-1);
igListBox2("", &stack_cur_, &doCallback, cast(void*)&d, emu_.stack.length, 16);
igPopItemWidth();
igEndChild();
igEnd();
}
// mem_editor_.draw("Emulator Memory", emu_.ram[]);
} // draw
void handleEvent(ref SDL_Event ev) {
switch (ev.type) with (SDL_EventType) {
case SDL_KEYDOWN:
if ((ev.key.keysym.mod & KMOD_CTRL) != 0) {
switch (ev.key.keysym.scancode) with (SDL_EventType) {
case SDL_SCANCODE_R: resetShortcut(); break;
case SDL_SCANCODE_L: loadShortcut(); break;
case SDL_SCANCODE_D: debugShortcut(); break;
case SDL_SCANCODE_G: redrawShortcut(); break;
case SDL_SCANCODE_T: toggleRunShortcut(); break;
case SDL_SCANCODE_S: stepShortcut(); break;
case SDL_SCANCODE_Q: quitShortcut(); break;
default: break;
}
} else {
if (ev.key.keysym.scancode == SDL_SCANCODE_ESCAPE) {
quitShortcut();
}
}
break;
default:
break;
}
} // handleEvent
} // Chip8Status
pure
@property {
ubyte x(ref ushort oc) {
return (oc & 0x0F00) >> 8;
}
ubyte y(ref ushort oc) {
return (oc & 0x00F0) >> 4;
}
ubyte n(ref ushort oc) {
return oc & 0x000F;
}
ubyte nn(ref ushort oc) {
return (oc & 0x00FF);
}
ushort nnn(ref ushort oc) {
return (oc & 0x0FFF);
}
}
struct Chip8 {
alias OpCode = ushort;
alias ProgramCounter = ushort;
alias Memory = ubyte[4096];
alias Stack = ushort[16];
alias Register = ubyte;
alias Registers = Register[16];
alias IndexRegister = ushort;
alias KeyPad = ubyte[16];
struct CPU {
OpCode opcode = 0; //current opcode
ProgramCounter pc = 0x200;
Registers v; //16 general purpose registers
IndexRegister i;
Register delay_timer;
Register sound_timer;
} // CPU
CPU cpu;
Memory ram;
Stack stack;
ubyte sp;
KeyPad kp;
ubyte[64*32] screen_buf;
ubyte[3][64*32] screen_data;
bool run_flag;
bool draw_flag;
void load(size_t offset, in void[] data) {
assert(offset + data.length < ram.length);
ram[offset .. offset + data.length] = cast(ubyte[])data[];
} // load
void reset() {
cpu = cpu.init;
stack = stack.init;
ram[0x200 .. $ - 1] = 0;
cpu.pc = 0x200;
sp = sp.init;
run_flag = run_flag.init;
draw_flag = draw_flag.init;
screen_buf = screen_buf.init;
screen_data = screen_data.init;
} // reset
void step() {
cpu.opcode = ram[cpu.pc] << 8 | ram[cpu.pc + 1];
ushort pc_target = cast(ProgramCounter)(cpu.pc + 2u);
// writefln("opcode: 0x%X, pc: 0x%X : %d", cpu.opcode, cpu.pc, cpu.pc);
switch (cpu.opcode & 0xF000) with (cpu) {
case 0x0000:
switch (cpu.opcode & 0x0FFF) {
case 0x00E0: // 0x00E0 Clears the screen.
screen_buf[0..$] = 0;
draw_flag = true;
break;
case 0x00EE: // 0x00EE Returns from a subroutine.
pc_target = stack[--sp];
break;
default: // 0x0NNN Calls RCA 1802 program at address NNN. Not necessary for most ROMs.
//assert(0, "0x0NNN RCA 1802 program opcode not implemented!");
break;
}
break;
case 0x1000: // 0x1NNN Jumps to address NNN.
pc_target = cpu.opcode.nnn;
break;
case 0x2000: // 0x2NNN Calls subroutine at NNN.
stack[sp++] = cpu.pc;
pc_target = cpu.opcode.nnn;
break;
case 0x3000: // 0x3XNN Skips the next instruction if VX equals NN.
if (cpu.v[cpu.opcode.x] == (cpu.opcode.nn)) {
pc_target += 2u;
}
break;
case 0x4000: // 0x4XNN Skips the next instruction if VX doesn't equal NN.
if (cpu.v[cpu.opcode.x] != (cpu.opcode.nn)) {
pc_target += 2u;
}
break;
case 0x5000: // 0x5XYO Skips the next instruction if VX equals VY.
if (cpu.v[cpu.opcode.x] == cpu.v[cpu.opcode.y]) {
pc_target += 2u;
}
break;
case 0x6000: // 0x6XNN Sets VX to NN.
cpu.v[cpu.opcode.x] = cpu.opcode.nn;
break;
case 0x7000: // 0x7XNN Adds NN to VX.
cpu.v[cpu.opcode.x] += cpu.opcode.nn;
break;
case 0x8000:
ubyte x = cpu.opcode.x;
ubyte y = cpu.opcode.y;
switch (cpu.opcode.n) {
case 0x0000: // 0x8XY0 Sets VX to the value of VY.
cpu.v[x] = cpu.v[y];
break;
case 0x0001: // 0x8XY1 Sets VX to VX or VY.
cpu.v[x] = cpu.v[x] | cpu.v[y];
break;
case 0x0002: // 0x8XY2 Sets VX to VX and VY.
cpu.v[x] = cpu.v[x] & cpu.v[y];
break;
case 0x0003: // 0x8XY3 Sets VX to VX xor VY.
cpu.v[x] = cpu.v[x] ^ cpu.v[y];
break;
case 0x0004: // 0x8XY4 Adds VY to VX. VF is set to 1 when there's a carry, and to 0 when there isn't.
ubyte vx = cpu.v[x];
ubyte vy = cpu.v[y];
if (cast(ushort)vx + cast(ushort)vy > 255) {
cpu.v[0xF] = 1;
} else {
cpu.v[0xF] = 0;
}
cpu.v[x] += cpu.v[y];
break;
case 0x0005: // 0x8XY5 VY is subtracted from VX. VF is set to 0 when there's a borrow, and 1 when there isn't.
ubyte vx = cpu.v[x];
ubyte vy = cpu.v[y];
if (vx > vy) {
cpu.v[0xF] = 1;
} else {
cpu.v[0xF] = 0;
}
cpu.v[x] -= cpu.v[y];
break;
case 0x0006: // 0x8XY6 Shifts VX right by one. VF is set to the value of the least significant bit of VX before the shift.
ubyte vx = cpu.v[x];
cpu.v[0xF] = vx & 0x1;
cpu.v[x] >>= 1;
break;
case 0x0007: // 0x8XY7 Sets VX to VY minus VX. VF is set to 0 when there's a borrow, and 1 when there isn't.
ubyte vx = cpu.v[x];
ubyte vy = cpu.v[y];
if (vy > vx) {
cpu.v[0xF] = 1;
} else {
cpu.v[0xF] = 0;
}
cpu.v[x] = cast(Register)(vy - vx);
break;
case 0x000E: // 0x8XYE Shifts VX left by one. VF is set to the value of the most significant bit of VX before the shift.
ubyte vx = cpu.v[x];
cpu.v[0xF] = vx >> 7;
cpu.v[x] <<= 1;
break;
default: // unhandled for some reason
writefln("unknown opcode: 0x%x", cpu.opcode);
break;
}
break;
case 0x9000: // 0x9XYO Skips the next instruction if VX doesn't equal VY.
if (cpu.v[cpu.opcode.x] != cpu.v[cpu.opcode.y]) {
pc_target += 2u; // do skip yes
}
break;
case 0xA000: // 0xANNN Sets I to the address NNN.
cpu.i = cpu.opcode.nnn;
break;
case 0xB000: // 0xBNNN Jumps to the address NNN plus V0.
pc_target = cast(ProgramCounter)(cpu.opcode.nnn + cpu.v[0x0]);
break;
case 0xC000: // 0xCXNN Sets VX to the result of a bitwise and operation on a random number and NN.
import std.random : uniform;
ubyte x = cpu.opcode.x;
cpu.v[x] = uniform(Register.min, Register.max) & (cpu.opcode & 0x00FF);
break;
// 0xDXYN
// Sprites stored in memory at location in index register (I), 8bits wide.
// Wraps around the screen. If when drawn, clears a pixel, register VF is set to 1 otherwise it is zero.
// All drawing is XOR drawing (i.e. it toggles the screen pixels).
// Sprites are drawn starting at position VX, VY. N is the number of 8bit rows that need to be drawn.
// If N is greater than 1, second line continues at position VX, VY+1, and so on.
case 0xD000:
ProgramCounter spr_addr = cpu.i;
ubyte x = cpu.opcode.x;
ubyte y = cpu.opcode.y;
ubyte n = cpu.opcode.n;
foreach(int row; 0 .. n) {
ushort pixel = ram[spr_addr + row];
foreach (int col; 0 .. 8) {
if ((pixel & (0x80 >> col)) != 0) {
ubyte x_off = cast(ubyte)((x + col) % 64);
ubyte y_off = cast(ubyte)((y + row) % 32);
ushort offset = x_off + (y_off * 64);
if (screen_buf[offset] == 1) {
cpu.v[0xF] = 1;
}
screen_buf[offset] ^= 1;
}
}
}
draw_flag = true;
break;
case 0xE000:
ubyte x = cpu.opcode.x;
ubyte key = cpu.v[x];
switch (cpu.opcode & 0x000F) {
case 0x000E: // 0xEX9E Skips the next instruction if the key stored in VX is pressed.
writefln("0xEXA1: skip instruction if VX not pressed: %x", key);
break;
case 0x0001: // 0xEXA1 Skips the next instruction if the key stored in VX isn't pressed.
writefln("0xEXA1: skip instruction if VX not pressed: %x", key);
break;
default: //unhandled for some reason
writefln("unknown opcode: 0x%x", cpu.opcode);
break;
}
break;
case 0xF000:
switch (cpu.opcode & 0x00FF) {
case 0x0007: // 0xFX07 Sets VX to the value of the delay timer.
cpu.v[cpu.opcode.x] = cpu.delay_timer;
break;
case 0x000A: // 0xFX0A A key press is awaited, and then stored in VX.
break;
case 0x0015: // 0xFX15 Sets the delay timer to VX.
cpu.delay_timer = cpu.v[cpu.opcode.x];
break;
case 0x0018: // 0xFX18 Sets the sound timer to VX.
cpu.sound_timer = cpu.v[cpu.opcode.x];
break;
case 0x001E: // 0xFX1E Adds VX to I.
if (cpu.i + cpu.v[cpu.opcode.x] > 0xFF) {
cpu.v[0xF] = 1;
} else {
cpu.v[0xF] = 0;
}
cpu.i += cpu.v[cpu.opcode.x];
break;
case 0x0029: // 0xFX29 Sets I to the location of the sprite for the character in VX.
ubyte vx = cpu.v[cpu.opcode.x];
// ushort char_addr = 0x200 + (vx * 40); // base of char sprites + value of vx * bits per character
ushort char_addr = vx * 0x5;
cpu.i = char_addr;
break;
// 0xFX33 Stores the Binary-coded decimal representation of VX,
// with the most significant of three digits at the address in I,
// the middle digit at I plus 1, and the least significant digit at I plus 2.
case 0x0033:
ubyte vx = cpu.v[cpu.opcode.x];
ram[cpu.i] = vx / 100;
ram[cpu.i + 1] = (vx / 10) % 10;
ram[cpu.i + 2] = (vx % 100) % 10;
break;
case 0x0055: // 0xFX55 Stores V0 to VX in memory starting at address I.
IndexRegister addr = cpu.i;
foreach (reg; cpu.v) {
ram[addr++] = reg;
}
break;
case 0x0065: // 0xFX65 Fills V0 to VX with values from memory starting at address I.
IndexRegister addr = cpu.i;
foreach (ref reg; cpu.v) {
reg = ram[addr++];
}
break;
default: // unhandled for some reason
writefln("unknown opcode: 0x%x", cpu.opcode);
break;
}
break;
default:
writefln("unknown opcode: 0x%x", cpu.opcode);
}
/* now update pc and timer registers. */
cpu.pc = pc_target;
if (cpu.delay_timer != 0u) {
--cpu.delay_timer;
}
if (cpu.sound_timer != 0u) {
if (cpu.sound_timer == 1u) {
writefln("beep!");
}
--cpu.sound_timer;
}
} // step
void handleEvent(ref SDL_Event ev) {
} // handleEvent
void tick() {
if (run_flag) {
step();
}
} // tick
} // Emulator
void loadLibs() {
DerelictSDL2.load();
DerelictImgui.load();
}
void initLibs() {
SDL_Init(SDL_INIT_VIDEO);
SDL_GL_LoadLibrary(null);
}
void setupImgui() {
}
void main() {
loadLibs();
initLibs();
Emulator emu;
emu.create();
emu.run();
}
struct Emulator {
bool running;
// debug
Chip8Status status;
Window window;
Imgui imgui;
Chip8 emu;
// drawing
PixelBuffer buf;
void create() {
// create window
window.createWindow(960, 768);
// setup imgui
imgui.initialize();
imgui.createDeviceObjects();
// setup debug ui
status.initialize(&this, &emu);
// debug data
emu.screen_buf[0] = 1;
emu.screen_buf[64 - 1] = 1;
emu.screen_buf[64*32 - 64] = 1;
emu.screen_buf[64*32 - 1] = 1;
// set up pixel buffer to poke at
buf.create(emu.screen_buf.ptr, 64, 32);
}
void handleEvents() {
SDL_Event event;
while (SDL_PollEvent(&event)) {
imgui.handleEvent(event);
status.handleEvent(event);
emu.handleEvent(event);
switch (event.type) with (SDL_EventType) {
case SDL_QUIT: {
running = false;
break;
}
default: {
break;
}
}
}
} // handleEvents
void run() {
running = true;
while (running) {
handleEvents();
tick();
draw();
}
}
void tick() {
emu.tick();
}
void draw() {
window.renderClear(0x428bca);
int w, h;
window.windowSize(w, h);
if (emu.draw_flag) {
buf.update(emu.screen_buf);
emu.draw_flag = false;
}
buf.draw(w, h);
imgui.newFrame(window);
status.draw();
imgui.endFrame();
window.renderPresent();
}
void quit() {
running = false;
}
}
Reference in New Issue View Git Blame Copy Permalink