JJ Bliss
423 lines
13 KiB
Hare
423 lines
13 KiB
Hare
use sdl3;
|
|
use sdl3::image;
|
|
use sdl3::ttf;
|
|
use types::c;
|
|
use os;
|
|
use io;
|
|
use bufio;
|
|
use fmt;
|
|
use unix;
|
|
use unix::poll;
|
|
use strings;
|
|
use uxn;
|
|
|
|
def WIDTH = 640;
|
|
def HEIGHT = 480;
|
|
def DEFAULT_SCALE = 3;
|
|
def MAX_CONSOLE_INPUT = 0x1000;
|
|
|
|
export fn main() void = {
|
|
sdl3::Init(sdl3::InitFlags::VIDEO | sdl3::InitFlags::EVENTS | sdl3::InitFlags::GAMEPAD)!;
|
|
defer sdl3::Quit();
|
|
|
|
let scale = DEFAULT_SCALE;
|
|
const win = sdl3::CreateWindow(
|
|
c::nulstr("Meadow\0"),
|
|
WIDTH*scale, HEIGHT*scale, sdl3::WindowFlags::RESIZABLE |
|
|
sdl3::WindowFlags::MOUSE_CAPTURE |
|
|
sdl3::WindowFlags::INPUT_FOCUS |
|
|
sdl3::WindowFlags::MOUSE_FOCUS
|
|
)!;
|
|
defer sdl3::DestroyWindow(win);
|
|
|
|
sdl3::SetWindowMinimumSize(win,0,0)!;
|
|
|
|
const render = sdl3::CreateRenderer(win, null)!;
|
|
defer sdl3::DestroyRenderer(render);
|
|
sdl3::SetRenderDrawColor(render, 0, 0, 128, 255)!;
|
|
sdl3::SetRenderVSync(render,1)!;
|
|
|
|
|
|
const screen_w = WIDTH;
|
|
const screen_h = HEIGHT;
|
|
//Create blank texture for screen
|
|
const meadow_texture = sdl3::CreateTexture(render,
|
|
sdl3::PixelFormat::XRGB4444,
|
|
sdl3::TextureAccess::STATIC,
|
|
screen_w,
|
|
screen_h)!;
|
|
defer sdl3::DestroyTexture(meadow_texture);
|
|
sdl3::SetTextureScaleMode(meadow_texture, sdl3::ScaleMode::NEAREST)!;
|
|
// const pixeldata: [WIDTH * HEIGHT]u32 = [0...];
|
|
let pixeldata: *[uxn::MAXWIDTH * uxn::MAXHEIGHT]u16 = alloc([0...])!; //TODO figure out actual size
|
|
defer free (pixeldata);
|
|
|
|
let run = true;
|
|
let ev = sdl3::Event { ... };
|
|
if(len(os::args) < 2){
|
|
fmt::printf("usage: %s file.rom [args..]\n")!;
|
|
return;
|
|
};
|
|
let path = os::args[1];
|
|
|
|
//Setting up pollfds for uni::poll
|
|
const consolefd: []unix::poll::pollfd = [unix::poll::pollfd {
|
|
fd = os::stdin_file,
|
|
events = unix::poll::event::POLLIN,
|
|
revents = 0,
|
|
} ];
|
|
let state: *uxn::uxn = uxn::uxn_init(path)!;
|
|
uxn::uxn_reset(state);
|
|
let next_refresh: u64 = 0;
|
|
const perf_freq: u64 = sdl3::GetPerformanceFrequency();
|
|
const frame_interval = perf_freq / 60;
|
|
const ms_interval = perf_freq / 1000;
|
|
for (run) {
|
|
const now: u64 = sdl3::GetPerformanceCounter();
|
|
if(state.running){
|
|
// fmt::printf("Next Step!\n")!;
|
|
// uxn::uxn_step(state)!;
|
|
yield;
|
|
}else{
|
|
if(state.console_vector != 0){
|
|
// fmt::printf("Console!\n")!;
|
|
let args = os::args[2..];
|
|
let i: u8 = 0;
|
|
let argcount = len(args): u8;
|
|
for (let arg .. args){
|
|
// fmt::println("Console input args")!;
|
|
for(let char: u8 .. strings::toutf8(arg)){
|
|
// fmt::printfln("Console input arg char: {:x}", char)!;
|
|
match (uxn::console_input(char,2,state)) {
|
|
case done =>
|
|
yield done;
|
|
case let val: u8 =>
|
|
fmt::fatalf("Unhandled Opcode: {:x}", val);
|
|
};
|
|
};
|
|
let ctype: u8 = if(i == (argcount - 1)){
|
|
yield 4;
|
|
} else {
|
|
yield 3;
|
|
};
|
|
match (uxn::console_input('\n',ctype,state)) {
|
|
case done =>
|
|
yield done;
|
|
case let val: u8 =>
|
|
fmt::fatalf("Unhandled Opcode: {:x}", val);
|
|
};
|
|
i+=1; //TODO using i here seems inelegant
|
|
};
|
|
const pollr = unix::poll::poll(consolefd, unix::poll::NONBLOCK);
|
|
if(pollr > 0){
|
|
// fmt::println("Input!")!;
|
|
let buf: [MAX_CONSOLE_INPUT]u8 = [0...];
|
|
io::read(os::stdin_file, buf)!;
|
|
for( let b .. buf ){
|
|
// fmt::printfln("Input: {}",buf[0])!;
|
|
match (uxn::console_input(b,1,state)) {
|
|
case done =>
|
|
yield done;
|
|
case let val: u8 =>
|
|
fmt::fatalf("Unhandled Opcode: {:x}", val);
|
|
};
|
|
// uxn::console_input(b,1,state);
|
|
};
|
|
};
|
|
|
|
};
|
|
};
|
|
|
|
if(now >= next_refresh){
|
|
next_refresh = now + frame_interval;
|
|
|
|
if(state.screen_vector != 0){
|
|
// fmt::println("Executing screen vector")!;
|
|
match (uxn::uxn_eval(state.screen_vector, state)) {
|
|
case done =>
|
|
yield;
|
|
case uxn::quit =>
|
|
run = false;
|
|
case let err: uxn::error =>
|
|
fmt::fatalf("Error evaluating: {}", uxn::strerror(err));
|
|
};
|
|
};
|
|
};
|
|
if(state.screen_size_changed){
|
|
let dims = uxn::get_window_size(state);
|
|
// fmt::printfln("Setting window to width: {:x} height: {:x}", dims.width, dims.height)!;
|
|
if((dims.width != 0) && (dims.height !=0)){
|
|
sdl3::DestroyTexture(meadow_texture);
|
|
free(pixeldata);
|
|
pixeldata = alloc([0...])!; //TODO figure out actual size
|
|
|
|
let w: int = dims.width: int;
|
|
let h: int = dims.height: int;
|
|
|
|
fmt::printfln("Setting window to width: {} height: {}", w, h)!;
|
|
sdl3::SetWindowSize(win,w*scale,h*scale)!;
|
|
|
|
meadow_texture = sdl3::CreateTexture(render,
|
|
sdl3::PixelFormat::XRGB4444,
|
|
sdl3::TextureAccess::STATIC,
|
|
w,
|
|
h)!;
|
|
sdl3::SetTextureScaleMode(meadow_texture, sdl3::ScaleMode::NEAREST)!;
|
|
|
|
state.screen_update = true;
|
|
};
|
|
|
|
|
|
state.screen_size_changed = false;
|
|
};
|
|
|
|
if(state.screen_update){
|
|
const dims = uxn::get_window_size(state);
|
|
for(let y: u16 = 0; y <= dims.height: u16; y+=1 ){
|
|
for(let x: u16 = 0; x <= dims.width: u16; x+=1 ){
|
|
let colshort: u16 = uxn::get_color(x,y,state);
|
|
// fmt::printfln("Pixel x: {} y: {} color: {:x} pcount: {:x}", x, y, colshort, pcount)!;
|
|
const index: u32 = y: u32 * dims.width: u32 + x: u32;
|
|
// if(index < 10) fmt::printfln("pcount: {} index: {} x: {} y: {}", pcount, index, x, y)!;
|
|
pixeldata[index] = colshort;
|
|
};
|
|
};
|
|
const pitch: int = dims.width: int * 2;
|
|
// fmt::printfln("Pitch is {}", pitch)!;
|
|
if(pitch > 0) sdl3::UpdateTexture(meadow_texture, null, pixeldata, pitch)!;
|
|
sdl3::RenderClear(render)!;
|
|
sdl3::RenderTexture(render, meadow_texture, null, null)!;
|
|
|
|
sdl3::RenderPresent(render)!;
|
|
state.screen_update = false;
|
|
};
|
|
|
|
|
|
//Render stuff
|
|
for (sdl3::PollEvent(&ev)) {
|
|
// fmt::println("Handling event")!;
|
|
switch (ev.event_type) {
|
|
case sdl3::EventType::QUIT =>
|
|
run = false;
|
|
case sdl3::EventType::WINDOW_RESIZED =>
|
|
let dims = uxn::get_window_size(state);
|
|
let w = ev.window.data1 / scale: i32;
|
|
let h = ev.window.data2 / scale: i32;
|
|
const wmod = w % scale: i32;
|
|
const hmod = h % scale: i32;
|
|
if((wmod !=0) || (hmod !=0)){
|
|
w = w-wmod;
|
|
h = h-hmod;
|
|
sdl3::SetWindowSize(win,w,h)!;
|
|
};
|
|
|
|
if((dims.width != w: u16 / scale: u16) || (dims.height != h: u16 / scale: u16)){
|
|
// fmt::println("Dimensions not allowed!")!;
|
|
//TODO handle this maybe
|
|
uxn::set_window_size(w: u16,h: u16,state);
|
|
sdl3::DestroyTexture(meadow_texture);
|
|
free(pixeldata);
|
|
pixeldata = alloc([0...])!; //TODO figure out actual size
|
|
let old_w: int = dims.width: int;
|
|
let old_h: int = dims.height: int;
|
|
|
|
// fmt::printfln("User setting window to width: {} height: {}", w, h)!;
|
|
sdl3::SetWindowSize(win,w*scale: i32,h*scale: i32)!;
|
|
|
|
meadow_texture = sdl3::CreateTexture(render,
|
|
sdl3::PixelFormat::XRGB4444,
|
|
sdl3::TextureAccess::STATIC,
|
|
w,
|
|
h)!;
|
|
sdl3::SetTextureScaleMode(meadow_texture, sdl3::ScaleMode::NEAREST)!;
|
|
|
|
state.screen_update = true;
|
|
};
|
|
|
|
case sdl3::EventType::MOUSE_MOTION =>
|
|
// fmt::printfln("Mouse Event x: {} y: {}", ev.motion.x, ev.motion.y)!;
|
|
const x = ev.motion.x / scale: f32;
|
|
const y = ev.motion.y / scale: f32;
|
|
uxn::set_mouse_motion(x: u16,y: u16,state);
|
|
if(state.mouse_vector != 0 ){
|
|
match (uxn::uxn_eval(state.mouse_vector, state)) {
|
|
case done =>
|
|
yield;
|
|
case uxn::quit =>
|
|
run = false;
|
|
case let err: uxn::error =>
|
|
fmt::fatalf("Error evaluating: {}", uxn::strerror(err));
|
|
};
|
|
};
|
|
case sdl3::EventType::MOUSE_BUTTON_DOWN =>
|
|
// fmt::printfln("Mouse Down: 0x{:x}", ev.button.button: u8 )!;
|
|
const b = 1 << (ev.button.button: u8 - 1);
|
|
uxn::set_mouse_down(b,state);
|
|
if(state.mouse_vector != 0 ){
|
|
match (uxn::uxn_eval(state.mouse_vector, state)) {
|
|
case done =>
|
|
yield;
|
|
case uxn::quit =>
|
|
run = false;
|
|
case let err: uxn::error =>
|
|
fmt::fatalf("Error evaluating: {}", uxn::strerror(err));
|
|
};
|
|
};
|
|
case sdl3::EventType::MOUSE_BUTTON_UP =>
|
|
// fmt::printfln("Mouse Up: 0x{:x}", ev.button.button: u8 )!;
|
|
const b = 1 << (ev.button.button: u8 - 1);
|
|
uxn::set_mouse_up(b,state);
|
|
if(state.mouse_vector != 0 ){
|
|
match (uxn::uxn_eval(state.mouse_vector, state)) {
|
|
case done =>
|
|
yield;
|
|
case uxn::quit =>
|
|
run = false;
|
|
case let err: uxn::error =>
|
|
fmt::fatalf("Error evaluating: {}", uxn::strerror(err));
|
|
};
|
|
};
|
|
case sdl3::EventType::MOUSE_WHEEL =>
|
|
fmt::printfln("Mouse Wheel!")!;
|
|
case sdl3::EventType::KEY_DOWN =>
|
|
const key = ev.key.key;
|
|
const scancode = ev.key.scancode;
|
|
const mods = ev.key.mod;
|
|
const sym = sdl3::GetKeyFromScancode(scancode,mods,false);
|
|
uxn::set_key_down(sym: u8,state);
|
|
// Handle Debug
|
|
if(key == sdl3::K_F2){
|
|
fmt::println("Debug Print:")!;
|
|
uxn::print_stack_debug(state);
|
|
};
|
|
//Handle keyboard controller keys
|
|
// Ctrl -> A 0x01
|
|
if(key == sdl3::K_LCTRL || key == sdl3::K_RCTRL){
|
|
uxn::set_controller_down(0x01,state);
|
|
};
|
|
// Alt -> B 0x02
|
|
if(key == sdl3::K_LALT || key == sdl3::K_RALT){
|
|
uxn::set_controller_down(0x02,state);
|
|
};
|
|
// Shift -> Select 0x04
|
|
if(key == sdl3::K_LSHIFT || key == sdl3::K_RSHIFT){
|
|
uxn::set_controller_down(0x04,state);
|
|
};
|
|
// Home -> Start 0x08
|
|
if(key == sdl3::K_HOME){
|
|
uxn::set_controller_down(0x08,state);
|
|
};
|
|
// Up -> Up 0x10
|
|
if(key == sdl3::K_UP){
|
|
uxn::set_controller_down(0x10,state);
|
|
};
|
|
// Down -> Down 0x20
|
|
if(key == sdl3::K_DOWN){
|
|
uxn::set_controller_down(0x20,state);
|
|
};
|
|
// Left -> Left 0x40
|
|
if(key == sdl3::K_LEFT){
|
|
uxn::set_controller_down(0x40,state);
|
|
};
|
|
// Right -> Right 0x80
|
|
if(key == sdl3::K_RIGHT){
|
|
uxn::set_controller_down(0x80,state);
|
|
};
|
|
match (uxn::uxn_eval(state.controller_vector, state)) {
|
|
case done =>
|
|
yield;
|
|
case uxn::quit =>
|
|
run = false;
|
|
case let err: uxn::error =>
|
|
fmt::fatalf("Error evaluating: {}", uxn::strerror(err));
|
|
};
|
|
uxn::clear_key_down(state);
|
|
|
|
case sdl3::EventType::KEY_UP =>
|
|
const key = ev.key.key;
|
|
// Ctrl -> A 0x01
|
|
if(key == sdl3::K_LCTRL || key == sdl3::K_RCTRL){
|
|
uxn::set_controller_up(0x01,state);
|
|
};
|
|
// Alt -> B 0x02
|
|
if(key == sdl3::K_LALT || key == sdl3::K_RALT){
|
|
uxn::set_controller_up(0x02,state);
|
|
};
|
|
// Shift -> Select 0x04
|
|
if(key == sdl3::K_LSHIFT || key == sdl3::K_RSHIFT){
|
|
uxn::set_controller_up(0x04,state);
|
|
};
|
|
// Home -> Start 0x08
|
|
if(key == sdl3::K_HOME){
|
|
uxn::set_controller_up(0x08,state);
|
|
};
|
|
// Up -> Up 0x10
|
|
if(key == sdl3::K_UP){
|
|
uxn::set_controller_up(0x10,state);
|
|
};
|
|
// Down -> Down 0x20
|
|
if(key == sdl3::K_DOWN){
|
|
uxn::set_controller_up(0x20,state);
|
|
};
|
|
// Left -> Left 0x40
|
|
if(key == sdl3::K_LEFT){
|
|
uxn::set_controller_up(0x40,state);
|
|
};
|
|
// Right -> Right 0x80
|
|
if(key == sdl3::K_RIGHT){
|
|
uxn::set_controller_up(0x80,state);
|
|
};
|
|
match (uxn::uxn_eval(state.controller_vector, state)) {
|
|
case done =>
|
|
yield;
|
|
case uxn::quit =>
|
|
run = false;
|
|
case let err: uxn::error =>
|
|
fmt::fatalf("Error evaluating: {}", uxn::strerror(err));
|
|
};
|
|
|
|
|
|
case sdl3::EventType::WINDOW_EXPOSED =>
|
|
sdl3::RenderClear(render)!;
|
|
sdl3::RenderTexture(render, meadow_texture, null, null)!;
|
|
sdl3::RenderPresent(render)!;
|
|
case sdl3::EventType::WINDOW_SHOWN =>
|
|
sdl3::RenderClear(render)!;
|
|
sdl3::RenderTexture(render, meadow_texture, null, null)!;
|
|
sdl3::RenderPresent(render)!;
|
|
case sdl3::EventType::WINDOW_PIXEL_SIZE_CHANGED =>
|
|
sdl3::RenderClear(render)!;
|
|
sdl3::RenderTexture(render, meadow_texture, null, null)!;
|
|
sdl3::RenderPresent(render)!;
|
|
case sdl3::EventType::WINDOW_MOUSE_ENTER =>
|
|
sdl3::RenderClear(render)!;
|
|
sdl3::RenderTexture(render, meadow_texture, null, null)!;
|
|
sdl3::HideCursor()!;
|
|
case sdl3::EventType::WINDOW_MOUSE_LEAVE =>
|
|
sdl3::RenderClear(render)!;
|
|
sdl3::RenderTexture(render, meadow_texture, null, null)!;
|
|
sdl3::ShowCursor()!;
|
|
case =>
|
|
// fmt::printfln("Unhandled SDL event: 0x{:x} , {}", ev.event_type, ev.event_type )!;
|
|
yield;
|
|
};
|
|
};
|
|
|
|
//TODO handle this in a better place
|
|
if(state.dev[0x0f] != 0) run = false;
|
|
// sdl3::RenderClear(render)!;
|
|
// sdl3::RenderTexture(render, meadow_texture, null, null)!;
|
|
|
|
// sdl3::RenderPresent(render)!;
|
|
// sdl3::Delay(1000 / 60);
|
|
|
|
|
|
match(sdl3::get_error()){
|
|
case void =>
|
|
yield;
|
|
case let err: sdl3::error =>
|
|
fmt::printfln("SDL Error: {}", sdl3::strerror(err))!;
|
|
};
|
|
};
|
|
};
|