2021-02-08 17:18:01 -05:00
|
|
|
#include <stdio.h>
|
2021-03-26 17:01:51 -04:00
|
|
|
#include <time.h>
|
2022-03-28 11:49:54 -04:00
|
|
|
#include <unistd.h>
|
2022-01-08 13:03:21 -05:00
|
|
|
|
2021-05-12 21:28:45 -04:00
|
|
|
#include "uxn.h"
|
2021-06-27 13:53:54 -04:00
|
|
|
|
|
|
|
#pragma GCC diagnostic push
|
2021-12-25 15:27:23 -05:00
|
|
|
#pragma clang diagnostic push
|
2021-06-27 13:53:54 -04:00
|
|
|
#pragma GCC diagnostic ignored "-Wpedantic"
|
2021-12-25 15:27:23 -05:00
|
|
|
#pragma clang diagnostic ignored "-Wtypedef-redefinition"
|
2021-06-27 13:53:54 -04:00
|
|
|
#include <SDL.h>
|
2022-01-05 08:28:22 -05:00
|
|
|
#include "devices/system.h"
|
2023-08-08 17:13:07 -04:00
|
|
|
#include "devices/console.h"
|
2021-12-28 16:37:26 -05:00
|
|
|
#include "devices/screen.h"
|
2021-12-28 16:47:35 -05:00
|
|
|
#include "devices/audio.h"
|
2021-11-05 17:32:45 -04:00
|
|
|
#include "devices/file.h"
|
2021-12-27 12:24:43 -05:00
|
|
|
#include "devices/controller.h"
|
2021-12-27 00:02:24 -05:00
|
|
|
#include "devices/mouse.h"
|
2022-01-07 13:02:28 -05:00
|
|
|
#include "devices/datetime.h"
|
2023-03-19 17:04:58 -04:00
|
|
|
#if defined(_WIN32) && defined(_WIN32_WINNT) && _WIN32_WINNT > 0x0602
|
2022-04-09 07:22:24 -04:00
|
|
|
#include <processthreadsapi.h>
|
2023-03-19 17:04:58 -04:00
|
|
|
#elif defined(_WIN32)
|
|
|
|
#include <windows.h>
|
|
|
|
#include <string.h>
|
2022-04-09 07:22:24 -04:00
|
|
|
#endif
|
2023-03-20 11:58:09 -04:00
|
|
|
#ifndef __plan9__
|
|
|
|
#define USED(x) (void)(x)
|
|
|
|
#endif
|
2021-06-27 13:53:54 -04:00
|
|
|
#pragma GCC diagnostic pop
|
2021-12-25 15:27:23 -05:00
|
|
|
#pragma clang diagnostic pop
|
2021-02-08 17:18:01 -05:00
|
|
|
|
|
|
|
/*
|
2023-01-02 09:40:23 -05:00
|
|
|
Copyright (c) 2021-2023 Devine Lu Linvega, Andrew Alderwick
|
2021-02-08 17:18:01 -05:00
|
|
|
|
|
|
|
Permission to use, copy, modify, and distribute this software for any
|
|
|
|
purpose with or without fee is hereby granted, provided that the above
|
|
|
|
copyright notice and this permission notice appear in all copies.
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
|
|
WITH REGARD TO THIS SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2023-07-26 00:43:26 -04:00
|
|
|
#define PAD 2
|
|
|
|
#define PAD2 4
|
2021-09-21 18:41:59 -04:00
|
|
|
#define WIDTH 64 * 8
|
|
|
|
#define HEIGHT 40 * 8
|
2022-06-10 01:31:07 -04:00
|
|
|
#define TIMEOUT_MS 334
|
2021-08-04 23:30:57 -04:00
|
|
|
|
2023-06-07 11:03:28 -04:00
|
|
|
static SDL_Window *emu_window;
|
|
|
|
static SDL_Texture *emu_texture;
|
|
|
|
static SDL_Renderer *emu_renderer;
|
2023-07-26 11:37:58 -04:00
|
|
|
static SDL_Rect emu_viewport;
|
2021-09-16 22:48:00 -04:00
|
|
|
static SDL_AudioDeviceID audio_id;
|
2022-04-09 07:22:24 -04:00
|
|
|
static SDL_Thread *stdin_thread;
|
2021-12-28 16:37:26 -05:00
|
|
|
|
2021-09-16 22:48:00 -04:00
|
|
|
/* devices */
|
2021-12-28 16:37:26 -05:00
|
|
|
|
2023-11-11 23:32:52 -05:00
|
|
|
static int window_created, fullscreen, borderless;
|
2023-06-07 11:03:28 -04:00
|
|
|
static Uint32 stdin_event, audio0_event, zoom = 1;
|
2022-06-10 01:31:07 -04:00
|
|
|
static Uint64 exec_deadline, deadline_interval, ms_interval;
|
2021-02-18 21:16:39 -05:00
|
|
|
|
2023-07-26 00:43:26 -04:00
|
|
|
static int
|
|
|
|
clamp(int v, int min, int max)
|
|
|
|
{
|
|
|
|
return v < min ? min : v > max ? max
|
|
|
|
: v;
|
|
|
|
}
|
2023-07-26 11:37:58 -04:00
|
|
|
|
2023-01-02 10:01:55 -05:00
|
|
|
static void
|
|
|
|
audio_deo(int instance, Uint8 *d, Uint8 port, Uxn *u)
|
|
|
|
{
|
|
|
|
if(!audio_id) return;
|
|
|
|
if(port == 0xf) {
|
|
|
|
SDL_LockAudioDevice(audio_id);
|
|
|
|
audio_start(instance, d, u);
|
|
|
|
SDL_UnlockAudioDevice(audio_id);
|
2023-10-20 11:54:25 -04:00
|
|
|
SDL_PauseAudioDevice(audio_id, 0);
|
2023-01-02 10:01:55 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-03-05 13:44:23 -05:00
|
|
|
Uint8
|
2023-07-23 22:18:11 -04:00
|
|
|
emu_dei(Uxn *u, Uint8 addr)
|
2023-01-01 17:18:27 -05:00
|
|
|
{
|
|
|
|
Uint8 p = addr & 0x0f, d = addr & 0xf0;
|
|
|
|
switch(d) {
|
2023-08-19 10:34:14 -04:00
|
|
|
case 0x00: return system_dei(u, addr);
|
2023-03-01 14:28:14 -05:00
|
|
|
case 0x20: return screen_dei(u, addr);
|
2023-01-02 10:01:55 -05:00
|
|
|
case 0x30: return audio_dei(0, &u->dev[d], p);
|
|
|
|
case 0x40: return audio_dei(1, &u->dev[d], p);
|
|
|
|
case 0x50: return audio_dei(2, &u->dev[d], p);
|
|
|
|
case 0x60: return audio_dei(3, &u->dev[d], p);
|
2023-03-01 14:28:14 -05:00
|
|
|
case 0xc0: return datetime_dei(u, addr);
|
2023-01-01 17:18:27 -05:00
|
|
|
}
|
|
|
|
return u->dev[addr];
|
|
|
|
}
|
|
|
|
|
2023-03-05 13:44:23 -05:00
|
|
|
void
|
2023-10-30 17:14:02 -04:00
|
|
|
emu_deo(Uxn *u, Uint8 addr, Uint8 value)
|
2023-01-01 17:18:27 -05:00
|
|
|
{
|
|
|
|
Uint8 p = addr & 0x0f, d = addr & 0xf0;
|
2023-10-30 17:14:02 -04:00
|
|
|
u->dev[addr] = value;
|
2023-01-01 17:18:27 -05:00
|
|
|
switch(d) {
|
|
|
|
case 0x00:
|
|
|
|
system_deo(u, &u->dev[d], p);
|
2023-11-11 23:32:52 -05:00
|
|
|
if(p > 0x7 && p < 0xe) screen_palette(&u->dev[0x8]);
|
2023-01-01 17:18:27 -05:00
|
|
|
break;
|
|
|
|
case 0x10: console_deo(&u->dev[d], p); break;
|
2024-01-02 14:29:02 -05:00
|
|
|
case 0x20: screen_deo(u->ram, &u->dev[0x20], p); break;
|
2023-01-02 10:01:55 -05:00
|
|
|
case 0x30: audio_deo(0, &u->dev[d], p, u); break;
|
|
|
|
case 0x40: audio_deo(1, &u->dev[d], p, u); break;
|
|
|
|
case 0x50: audio_deo(2, &u->dev[d], p, u); break;
|
|
|
|
case 0x60: audio_deo(3, &u->dev[d], p, u); break;
|
2023-01-01 17:18:27 -05:00
|
|
|
case 0xa0: file_deo(0, u->ram, &u->dev[d], p); break;
|
|
|
|
case 0xb0: file_deo(1, u->ram, &u->dev[d], p); break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-07-24 12:48:49 -04:00
|
|
|
/* Handlers */
|
2021-09-21 18:41:59 -04:00
|
|
|
|
|
|
|
void
|
2022-03-17 12:59:36 -04:00
|
|
|
audio_finished_handler(int instance)
|
2021-09-21 18:41:59 -04:00
|
|
|
{
|
|
|
|
SDL_Event event;
|
2022-03-17 12:59:36 -04:00
|
|
|
event.type = audio0_event + instance;
|
2021-09-21 18:41:59 -04:00
|
|
|
SDL_PushEvent(&event);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
stdin_handler(void *p)
|
|
|
|
{
|
|
|
|
SDL_Event event;
|
2023-03-20 11:58:09 -04:00
|
|
|
USED(p);
|
2021-09-21 18:41:59 -04:00
|
|
|
event.type = stdin_event;
|
2022-03-28 11:49:54 -04:00
|
|
|
while(read(0, &event.cbutton.button, 1) > 0 && SDL_PushEvent(&event) >= 0)
|
2022-03-28 11:24:35 -04:00
|
|
|
;
|
2021-09-21 18:41:59 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-09-21 16:21:48 -04:00
|
|
|
static void
|
|
|
|
set_window_size(SDL_Window *window, int w, int h)
|
|
|
|
{
|
2023-11-11 23:32:52 -05:00
|
|
|
SDL_Point win_old;
|
2021-09-21 18:56:42 -04:00
|
|
|
SDL_GetWindowSize(window, &win_old.x, &win_old.y);
|
2022-01-19 20:24:22 -05:00
|
|
|
if(w == win_old.x && h == win_old.y) return;
|
2023-06-07 11:23:42 -04:00
|
|
|
SDL_RenderClear(emu_renderer);
|
2021-09-21 16:21:48 -04:00
|
|
|
SDL_SetWindowSize(window, w, h);
|
|
|
|
}
|
|
|
|
|
2023-07-25 17:42:10 -04:00
|
|
|
static void
|
|
|
|
set_zoom(Uint8 z, int win)
|
|
|
|
{
|
2023-11-11 23:32:52 -05:00
|
|
|
if(z < 1) return;
|
|
|
|
if(win)
|
|
|
|
set_window_size(emu_window, (uxn_screen.width + PAD2) * z, (uxn_screen.height + PAD2) * z);
|
|
|
|
zoom = z;
|
2023-07-25 17:42:10 -04:00
|
|
|
}
|
|
|
|
|
2023-10-24 21:22:05 -04:00
|
|
|
static void
|
2023-10-25 17:16:23 -04:00
|
|
|
set_fullscreen(int value, int win)
|
2023-10-24 21:22:05 -04:00
|
|
|
{
|
|
|
|
Uint32 flags = 0; /* windowed mode; SDL2 has no constant for this */
|
2023-10-25 18:25:32 -04:00
|
|
|
fullscreen = value;
|
2023-11-11 23:32:52 -05:00
|
|
|
if(fullscreen)
|
2023-10-24 21:22:05 -04:00
|
|
|
flags = SDL_WINDOW_FULLSCREEN_DESKTOP;
|
2023-10-25 11:24:37 -04:00
|
|
|
if(win)
|
|
|
|
SDL_SetWindowFullscreen(emu_window, flags);
|
2023-10-24 21:22:05 -04:00
|
|
|
}
|
|
|
|
|
2023-10-25 17:16:23 -04:00
|
|
|
static void
|
|
|
|
set_borderless(int value)
|
|
|
|
{
|
2023-10-25 18:23:56 -04:00
|
|
|
if(fullscreen) return;
|
2023-10-25 17:16:23 -04:00
|
|
|
borderless = value;
|
|
|
|
SDL_SetWindowBordered(emu_window, !value);
|
|
|
|
}
|
|
|
|
|
2023-10-25 18:23:56 -04:00
|
|
|
static void
|
|
|
|
set_debugger(Uxn *u, int value)
|
|
|
|
{
|
|
|
|
u->dev[0x0e] = value;
|
2023-11-11 23:44:15 -05:00
|
|
|
screen_fill(uxn_screen.fg, 0);
|
2023-10-25 18:23:56 -04:00
|
|
|
screen_redraw(u);
|
|
|
|
}
|
|
|
|
|
2023-07-25 17:42:10 -04:00
|
|
|
/* emulator primitives */
|
|
|
|
|
2023-07-23 22:18:11 -04:00
|
|
|
int
|
2023-07-24 12:48:49 -04:00
|
|
|
emu_resize(int width, int height)
|
2023-07-23 22:18:11 -04:00
|
|
|
{
|
2023-07-25 17:30:51 -04:00
|
|
|
if(!window_created)
|
|
|
|
return 0;
|
2023-06-07 11:03:28 -04:00
|
|
|
if(emu_texture != NULL)
|
|
|
|
SDL_DestroyTexture(emu_texture);
|
2023-07-26 00:43:26 -04:00
|
|
|
SDL_RenderSetLogicalSize(emu_renderer, width + PAD2, height + PAD2);
|
2023-07-24 12:48:49 -04:00
|
|
|
emu_texture = SDL_CreateTexture(emu_renderer, SDL_PIXELFORMAT_RGB888, SDL_TEXTUREACCESS_STATIC, width, height);
|
2023-06-07 11:03:28 -04:00
|
|
|
if(emu_texture == NULL || SDL_SetTextureBlendMode(emu_texture, SDL_BLENDMODE_NONE))
|
2023-06-07 11:23:42 -04:00
|
|
|
return system_error("SDL_SetTextureBlendMode", SDL_GetError());
|
2023-06-07 11:03:28 -04:00
|
|
|
if(SDL_UpdateTexture(emu_texture, NULL, uxn_screen.pixels, sizeof(Uint32)) != 0)
|
2023-04-17 14:03:11 -04:00
|
|
|
return system_error("SDL_UpdateTexture", SDL_GetError());
|
2023-07-26 11:37:58 -04:00
|
|
|
emu_viewport.x = PAD;
|
|
|
|
emu_viewport.y = PAD;
|
|
|
|
emu_viewport.w = uxn_screen.width;
|
|
|
|
emu_viewport.h = uxn_screen.height;
|
2023-07-26 00:43:26 -04:00
|
|
|
set_window_size(emu_window, (width + PAD2) * zoom, (height + PAD2) * zoom);
|
2021-09-22 13:57:43 -04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2021-06-28 17:42:36 -04:00
|
|
|
static void
|
2023-08-08 13:27:41 -04:00
|
|
|
emu_redraw(Uxn *u)
|
2021-02-08 18:46:52 -05:00
|
|
|
{
|
2023-08-16 16:46:07 -04:00
|
|
|
screen_redraw(u);
|
2023-06-07 11:03:28 -04:00
|
|
|
if(SDL_UpdateTexture(emu_texture, NULL, uxn_screen.pixels, uxn_screen.width * sizeof(Uint32)) != 0)
|
2023-04-17 14:03:11 -04:00
|
|
|
system_error("SDL_UpdateTexture", SDL_GetError());
|
2023-07-26 00:43:26 -04:00
|
|
|
SDL_RenderClear(emu_renderer);
|
2023-07-26 11:37:58 -04:00
|
|
|
SDL_RenderCopy(emu_renderer, emu_texture, NULL, &emu_viewport);
|
2023-06-07 11:03:28 -04:00
|
|
|
SDL_RenderPresent(emu_renderer);
|
2021-02-08 18:46:52 -05:00
|
|
|
}
|
|
|
|
|
2021-06-28 17:42:36 -04:00
|
|
|
static int
|
2023-10-10 09:39:47 -04:00
|
|
|
emu_init(Uxn *u)
|
2021-02-08 18:46:52 -05:00
|
|
|
{
|
2021-04-08 16:14:40 -04:00
|
|
|
SDL_AudioSpec as;
|
2021-08-03 18:25:13 -04:00
|
|
|
SDL_zero(as);
|
|
|
|
as.freq = SAMPLE_FREQUENCY;
|
2023-05-14 22:08:58 -04:00
|
|
|
as.format = AUDIO_S16SYS;
|
2021-08-03 18:25:13 -04:00
|
|
|
as.channels = 2;
|
2023-10-10 08:54:44 -04:00
|
|
|
as.callback = audio_handler;
|
|
|
|
as.samples = AUDIO_BUFSIZE;
|
2023-10-10 09:39:47 -04:00
|
|
|
as.userdata = u;
|
2022-04-09 07:19:27 -04:00
|
|
|
if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_JOYSTICK) < 0)
|
2023-04-17 14:03:11 -04:00
|
|
|
return system_error("sdl", SDL_GetError());
|
2021-12-28 20:38:55 -05:00
|
|
|
audio_id = SDL_OpenAudioDevice(NULL, 0, &as, NULL, 0);
|
|
|
|
if(!audio_id)
|
2023-04-17 14:03:11 -04:00
|
|
|
system_error("sdl_audio", SDL_GetError());
|
2021-12-29 12:33:23 -05:00
|
|
|
if(SDL_NumJoysticks() > 0 && SDL_JoystickOpen(0) == NULL)
|
2023-04-17 14:03:11 -04:00
|
|
|
system_error("sdl_joystick", SDL_GetError());
|
2021-09-21 18:41:59 -04:00
|
|
|
stdin_event = SDL_RegisterEvents(1);
|
|
|
|
audio0_event = SDL_RegisterEvents(POLYPHONY);
|
2022-04-09 07:22:24 -04:00
|
|
|
SDL_DetachThread(stdin_thread = SDL_CreateThread(stdin_handler, "stdin", NULL));
|
2021-06-20 17:14:06 -04:00
|
|
|
SDL_StartTextInput();
|
2021-02-18 18:11:02 -05:00
|
|
|
SDL_ShowCursor(SDL_DISABLE);
|
2021-12-16 11:29:09 -05:00
|
|
|
SDL_EventState(SDL_DROPFILE, SDL_ENABLE);
|
2023-07-25 17:42:10 -04:00
|
|
|
SDL_SetRenderDrawColor(emu_renderer, 0x00, 0x00, 0x00, 0xff);
|
2022-06-10 01:31:07 -04:00
|
|
|
ms_interval = SDL_GetPerformanceFrequency() / 1000;
|
|
|
|
deadline_interval = ms_interval * TIMEOUT_MS;
|
2023-08-15 21:44:16 -04:00
|
|
|
exec_deadline = SDL_GetPerformanceCounter() + deadline_interval;
|
|
|
|
screen_resize(WIDTH, HEIGHT);
|
2023-10-20 11:54:25 -04:00
|
|
|
SDL_PauseAudioDevice(audio_id, 1);
|
2021-02-08 18:46:52 -05:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2021-12-27 16:59:22 -05:00
|
|
|
static void
|
2023-08-15 22:19:06 -04:00
|
|
|
emu_restart(Uxn *u, char *rom, int soft)
|
2021-12-27 16:59:22 -05:00
|
|
|
{
|
2023-07-25 17:42:10 -04:00
|
|
|
screen_resize(WIDTH, HEIGHT);
|
2023-11-11 23:44:15 -05:00
|
|
|
screen_fill(uxn_screen.bg, 0);
|
|
|
|
screen_fill(uxn_screen.fg, 0);
|
2023-08-15 22:19:06 -04:00
|
|
|
system_reboot(u, rom, soft);
|
|
|
|
SDL_SetWindowTitle(emu_window, boot_rom);
|
2023-08-13 21:48:32 -04:00
|
|
|
}
|
|
|
|
|
2021-12-27 16:59:22 -05:00
|
|
|
static void
|
|
|
|
capture_screen(void)
|
|
|
|
{
|
|
|
|
const Uint32 format = SDL_PIXELFORMAT_RGB24;
|
2023-05-14 22:08:59 -04:00
|
|
|
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
|
2023-06-07 11:03:28 -04:00
|
|
|
/* SDL_PIXELFORMAT_RGB24 */
|
|
|
|
Uint32 Rmask = 0x000000FF;
|
|
|
|
Uint32 Gmask = 0x0000FF00;
|
|
|
|
Uint32 Bmask = 0x00FF0000;
|
2023-05-14 22:08:59 -04:00
|
|
|
#else
|
2023-06-07 11:03:28 -04:00
|
|
|
/* SDL_PIXELFORMAT_BGR24 */
|
|
|
|
Uint32 Rmask = 0x00FF0000;
|
|
|
|
Uint32 Gmask = 0x0000FF00;
|
|
|
|
Uint32 Bmask = 0x000000FF;
|
2023-05-14 22:08:59 -04:00
|
|
|
#endif
|
2021-12-27 16:59:22 -05:00
|
|
|
time_t t = time(NULL);
|
|
|
|
char fname[64];
|
|
|
|
int w, h;
|
|
|
|
SDL_Surface *surface;
|
2023-06-07 11:03:28 -04:00
|
|
|
SDL_GetRendererOutputSize(emu_renderer, &w, &h);
|
2023-07-10 11:35:35 -04:00
|
|
|
if((surface = SDL_CreateRGBSurface(0, w, h, 24, Rmask, Gmask, Bmask, 0)) == NULL)
|
|
|
|
return;
|
2023-06-07 11:03:28 -04:00
|
|
|
SDL_RenderReadPixels(emu_renderer, NULL, format, surface->pixels, surface->pitch);
|
2021-12-27 16:59:22 -05:00
|
|
|
strftime(fname, sizeof(fname), "screenshot-%Y%m%d-%H%M%S.bmp", localtime(&t));
|
2023-07-16 18:50:19 -04:00
|
|
|
if(SDL_SaveBMP(surface, fname) == 0) {
|
2023-07-10 11:35:35 -04:00
|
|
|
fprintf(stderr, "Saved %s\n", fname);
|
|
|
|
fflush(stderr);
|
|
|
|
}
|
2021-12-27 16:59:22 -05:00
|
|
|
SDL_FreeSurface(surface);
|
|
|
|
}
|
|
|
|
|
2021-12-27 13:04:24 -05:00
|
|
|
static Uint8
|
2021-12-27 09:24:22 -05:00
|
|
|
get_button(SDL_Event *event)
|
2021-12-27 00:33:23 -05:00
|
|
|
{
|
2021-12-27 09:24:22 -05:00
|
|
|
switch(event->key.keysym.sym) {
|
2021-12-27 00:33:23 -05:00
|
|
|
case SDLK_LCTRL: return 0x01;
|
|
|
|
case SDLK_LALT: return 0x02;
|
|
|
|
case SDLK_LSHIFT: return 0x04;
|
2021-12-27 16:42:36 -05:00
|
|
|
case SDLK_HOME: return 0x08;
|
2021-12-27 00:33:23 -05:00
|
|
|
case SDLK_UP: return 0x10;
|
|
|
|
case SDLK_DOWN: return 0x20;
|
|
|
|
case SDLK_LEFT: return 0x40;
|
|
|
|
case SDLK_RIGHT: return 0x80;
|
|
|
|
}
|
|
|
|
return 0x00;
|
|
|
|
}
|
|
|
|
|
2021-12-27 13:04:24 -05:00
|
|
|
static Uint8
|
2021-12-27 14:44:57 -05:00
|
|
|
get_button_joystick(SDL_Event *event)
|
|
|
|
{
|
|
|
|
return 0x01 << (event->jbutton.button & 0x3);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Uint8
|
|
|
|
get_vector_joystick(SDL_Event *event)
|
|
|
|
{
|
|
|
|
if(event->jaxis.value < -3200)
|
|
|
|
return 1;
|
|
|
|
if(event->jaxis.value > 3200)
|
|
|
|
return 2;
|
|
|
|
return 0;
|
2021-12-27 13:04:24 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static Uint8
|
2021-12-27 12:24:43 -05:00
|
|
|
get_key(SDL_Event *event)
|
2021-12-27 00:33:23 -05:00
|
|
|
{
|
2023-02-14 21:32:56 -05:00
|
|
|
int sym = event->key.keysym.sym;
|
2021-12-27 12:24:43 -05:00
|
|
|
SDL_Keymod mods = SDL_GetModState();
|
2023-02-14 21:32:56 -05:00
|
|
|
if(sym < 0x20 || sym == SDLK_DELETE)
|
|
|
|
return sym;
|
|
|
|
if(mods & KMOD_CTRL) {
|
|
|
|
if(sym < SDLK_a)
|
|
|
|
return sym;
|
|
|
|
else if(sym <= SDLK_z)
|
|
|
|
return sym - (mods & KMOD_SHIFT) * 0x20;
|
|
|
|
}
|
2021-12-27 12:24:43 -05:00
|
|
|
return 0x00;
|
2021-12-27 00:33:23 -05:00
|
|
|
}
|
|
|
|
|
2021-09-21 18:41:59 -04:00
|
|
|
static int
|
2022-06-10 01:31:07 -04:00
|
|
|
handle_events(Uxn *u)
|
2021-02-08 17:18:01 -05:00
|
|
|
{
|
2022-03-27 08:16:40 -04:00
|
|
|
SDL_Event event;
|
2022-06-10 01:31:07 -04:00
|
|
|
while(SDL_PollEvent(&event)) {
|
2022-03-27 08:18:37 -04:00
|
|
|
/* Window */
|
|
|
|
if(event.type == SDL_QUIT)
|
2023-06-09 12:29:25 -04:00
|
|
|
return 0;
|
2022-03-27 08:18:37 -04:00
|
|
|
else if(event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_EXPOSED)
|
2023-08-08 13:27:41 -04:00
|
|
|
emu_redraw(u);
|
2022-03-27 08:18:37 -04:00
|
|
|
else if(event.type == SDL_DROPFILE) {
|
2023-08-15 22:19:06 -04:00
|
|
|
emu_restart(u, event.drop.file, 0);
|
2022-03-27 08:18:37 -04:00
|
|
|
SDL_free(event.drop.file);
|
|
|
|
}
|
|
|
|
/* Mouse */
|
|
|
|
else if(event.type == SDL_MOUSEMOTION)
|
2023-07-26 11:37:58 -04:00
|
|
|
mouse_pos(u, &u->dev[0x90], clamp(event.motion.x - PAD, 0, uxn_screen.width - 1), clamp(event.motion.y - PAD, 0, uxn_screen.height - 1));
|
2022-03-27 08:18:37 -04:00
|
|
|
else if(event.type == SDL_MOUSEBUTTONUP)
|
2023-01-01 16:34:20 -05:00
|
|
|
mouse_up(u, &u->dev[0x90], SDL_BUTTON(event.button.button));
|
2022-03-27 08:18:37 -04:00
|
|
|
else if(event.type == SDL_MOUSEBUTTONDOWN)
|
2023-01-01 16:34:20 -05:00
|
|
|
mouse_down(u, &u->dev[0x90], SDL_BUTTON(event.button.button));
|
2022-03-27 08:18:37 -04:00
|
|
|
else if(event.type == SDL_MOUSEWHEEL)
|
2023-01-01 16:34:20 -05:00
|
|
|
mouse_scroll(u, &u->dev[0x90], event.wheel.x, event.wheel.y);
|
2022-03-27 08:18:37 -04:00
|
|
|
/* Controller */
|
|
|
|
else if(event.type == SDL_TEXTINPUT)
|
2023-01-01 16:34:20 -05:00
|
|
|
controller_key(u, &u->dev[0x80], event.text.text[0]);
|
2022-03-27 08:18:37 -04:00
|
|
|
else if(event.type == SDL_KEYDOWN) {
|
|
|
|
int ksym;
|
|
|
|
if(get_key(&event))
|
2023-01-01 16:34:20 -05:00
|
|
|
controller_key(u, &u->dev[0x80], get_key(&event));
|
2022-03-27 08:18:37 -04:00
|
|
|
else if(get_button(&event))
|
2023-01-01 16:34:20 -05:00
|
|
|
controller_down(u, &u->dev[0x80], get_button(&event));
|
2023-07-24 12:48:49 -04:00
|
|
|
else if(event.key.keysym.sym == SDLK_F1)
|
2023-07-25 17:30:51 -04:00
|
|
|
set_zoom(zoom == 3 ? 1 : zoom + 1, 1);
|
2023-07-24 12:48:49 -04:00
|
|
|
else if(event.key.keysym.sym == SDLK_F2)
|
2023-10-25 18:23:56 -04:00
|
|
|
set_debugger(u, !u->dev[0x0e]);
|
2023-07-24 12:48:49 -04:00
|
|
|
else if(event.key.keysym.sym == SDLK_F3)
|
|
|
|
capture_screen();
|
|
|
|
else if(event.key.keysym.sym == SDLK_F4)
|
2023-08-15 22:19:06 -04:00
|
|
|
emu_restart(u, boot_rom, 0);
|
2023-08-13 21:48:32 -04:00
|
|
|
else if(event.key.keysym.sym == SDLK_F5)
|
2023-08-15 22:19:06 -04:00
|
|
|
emu_restart(u, boot_rom, 1);
|
2023-10-24 21:22:05 -04:00
|
|
|
else if(event.key.keysym.sym == SDLK_F11)
|
|
|
|
set_fullscreen(!fullscreen, 1);
|
2023-10-25 17:16:23 -04:00
|
|
|
else if(event.key.keysym.sym == SDLK_F12)
|
|
|
|
set_borderless(!borderless);
|
2022-03-27 08:18:37 -04:00
|
|
|
ksym = event.key.keysym.sym;
|
2023-07-24 12:48:49 -04:00
|
|
|
if(SDL_PeepEvents(&event, 1, SDL_PEEKEVENT, SDL_KEYUP, SDL_KEYUP) == 1 && ksym == event.key.keysym.sym)
|
2022-06-10 01:31:07 -04:00
|
|
|
return 1;
|
2022-03-27 08:18:37 -04:00
|
|
|
} else if(event.type == SDL_KEYUP)
|
2023-01-01 16:34:20 -05:00
|
|
|
controller_up(u, &u->dev[0x80], get_button(&event));
|
2022-03-27 08:18:37 -04:00
|
|
|
else if(event.type == SDL_JOYAXISMOTION) {
|
|
|
|
Uint8 vec = get_vector_joystick(&event);
|
|
|
|
if(!vec)
|
2023-01-01 16:34:20 -05:00
|
|
|
controller_up(u, &u->dev[0x80], (3 << (!event.jaxis.axis * 2)) << 4);
|
2022-03-27 08:18:37 -04:00
|
|
|
else
|
2023-01-01 16:34:20 -05:00
|
|
|
controller_down(u, &u->dev[0x80], (1 << ((vec + !event.jaxis.axis * 2) - 1)) << 4);
|
2022-03-27 08:18:37 -04:00
|
|
|
} else if(event.type == SDL_JOYBUTTONDOWN)
|
2023-01-01 16:34:20 -05:00
|
|
|
controller_down(u, &u->dev[0x80], get_button_joystick(&event));
|
2022-03-27 08:18:37 -04:00
|
|
|
else if(event.type == SDL_JOYBUTTONUP)
|
2023-01-01 16:34:20 -05:00
|
|
|
controller_up(u, &u->dev[0x80], get_button_joystick(&event));
|
2023-04-12 06:48:52 -04:00
|
|
|
else if(event.type == SDL_JOYHATMOTION) {
|
|
|
|
/* NOTE: Assuming there is only one joyhat in the controller */
|
|
|
|
switch(event.jhat.value) {
|
2023-11-11 23:32:52 -05:00
|
|
|
case SDL_HAT_UP: controller_down(u, &u->dev[0x80], 0x10); break;
|
|
|
|
case SDL_HAT_DOWN: controller_down(u, &u->dev[0x80], 0x20); break;
|
|
|
|
case SDL_HAT_LEFT: controller_down(u, &u->dev[0x80], 0x40); break;
|
|
|
|
case SDL_HAT_RIGHT: controller_down(u, &u->dev[0x80], 0x80); break;
|
|
|
|
case SDL_HAT_LEFTDOWN: controller_down(u, &u->dev[0x80], 0x40 | 0x20); break;
|
|
|
|
case SDL_HAT_LEFTUP: controller_down(u, &u->dev[0x80], 0x40 | 0x10); break;
|
|
|
|
case SDL_HAT_RIGHTDOWN: controller_down(u, &u->dev[0x80], 0x80 | 0x20); break;
|
|
|
|
case SDL_HAT_RIGHTUP: controller_down(u, &u->dev[0x80], 0x80 | 0x10); break;
|
|
|
|
case SDL_HAT_CENTERED: controller_up(u, &u->dev[0x80], 0x10 | 0x20 | 0x40 | 0x80); break;
|
2023-04-12 06:48:52 -04:00
|
|
|
}
|
|
|
|
}
|
2022-03-27 08:18:37 -04:00
|
|
|
/* Console */
|
|
|
|
else if(event.type == stdin_event)
|
2023-04-17 00:13:50 -04:00
|
|
|
console_input(u, event.cbutton.button, CONSOLE_STD);
|
2022-06-10 01:31:07 -04:00
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2023-08-15 21:44:16 -04:00
|
|
|
emu_run(Uxn *u, char *rom)
|
2022-06-10 01:31:07 -04:00
|
|
|
{
|
2023-05-09 16:07:17 -04:00
|
|
|
Uint64 next_refresh = 0;
|
|
|
|
Uint64 frame_interval = SDL_GetPerformanceFrequency() / 60;
|
2023-08-30 15:12:30 -04:00
|
|
|
Uint8 *vector_addr = &u->dev[0x20];
|
2023-10-24 21:22:05 -04:00
|
|
|
Uint32 window_flags = SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI;
|
2023-10-25 18:25:32 -04:00
|
|
|
window_created = 1;
|
2023-10-25 11:24:37 -04:00
|
|
|
if(fullscreen)
|
2023-10-24 21:22:05 -04:00
|
|
|
window_flags = window_flags | SDL_WINDOW_FULLSCREEN_DESKTOP;
|
2023-11-11 23:32:52 -05:00
|
|
|
emu_window = SDL_CreateWindow(rom,
|
|
|
|
SDL_WINDOWPOS_UNDEFINED,
|
|
|
|
SDL_WINDOWPOS_UNDEFINED,
|
|
|
|
(uxn_screen.width + PAD2) * zoom,
|
|
|
|
(uxn_screen.height + PAD2) * zoom,
|
|
|
|
window_flags);
|
2023-07-25 17:56:26 -04:00
|
|
|
if(emu_window == NULL)
|
|
|
|
return system_error("sdl_window", SDL_GetError());
|
2023-08-07 20:49:02 -04:00
|
|
|
emu_renderer = SDL_CreateRenderer(emu_window, -1, SDL_RENDERER_ACCELERATED);
|
2023-07-25 17:56:26 -04:00
|
|
|
if(emu_renderer == NULL)
|
|
|
|
return system_error("sdl_renderer", SDL_GetError());
|
|
|
|
emu_resize(uxn_screen.width, uxn_screen.height);
|
|
|
|
/* game loop */
|
2023-01-28 13:54:54 -05:00
|
|
|
for(;;) {
|
2023-04-02 23:27:15 -04:00
|
|
|
Uint16 screen_vector;
|
2023-07-25 17:56:26 -04:00
|
|
|
Uint64 now = SDL_GetPerformanceCounter();
|
2023-01-28 13:54:54 -05:00
|
|
|
/* .System/halt */
|
|
|
|
if(u->dev[0x0f])
|
2023-04-17 14:03:11 -04:00
|
|
|
return system_error("Run", "Ended.");
|
2022-06-10 01:31:07 -04:00
|
|
|
exec_deadline = now + deadline_interval;
|
|
|
|
if(!handle_events(u))
|
|
|
|
return 0;
|
2023-08-30 15:12:30 -04:00
|
|
|
screen_vector = PEEK2(vector_addr);
|
2023-07-25 17:56:26 -04:00
|
|
|
if(now >= next_refresh) {
|
2023-05-09 16:07:17 -04:00
|
|
|
now = SDL_GetPerformanceCounter();
|
|
|
|
next_refresh = now + frame_interval;
|
|
|
|
uxn_eval(u, screen_vector);
|
|
|
|
if(uxn_screen.x2)
|
2023-08-08 13:27:41 -04:00
|
|
|
emu_redraw(u);
|
2023-05-09 16:07:17 -04:00
|
|
|
}
|
2023-07-25 17:56:26 -04:00
|
|
|
if(screen_vector || uxn_screen.x2) {
|
2023-05-09 16:07:17 -04:00
|
|
|
Uint64 delay_ms = (next_refresh - now) / ms_interval;
|
|
|
|
if(delay_ms > 0) SDL_Delay(delay_ms);
|
2023-06-07 11:03:28 -04:00
|
|
|
} else
|
|
|
|
SDL_WaitEvent(NULL);
|
2021-02-08 18:46:52 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-08-15 21:47:34 -04:00
|
|
|
static int
|
2023-08-15 21:44:16 -04:00
|
|
|
emu_end(Uxn *u)
|
|
|
|
{
|
2023-10-20 11:54:25 -04:00
|
|
|
SDL_CloseAudioDevice(audio_id);
|
2023-08-15 21:44:16 -04:00
|
|
|
#ifdef _WIN32
|
|
|
|
#pragma GCC diagnostic ignored "-Wint-to-pointer-cast"
|
|
|
|
TerminateThread((HANDLE)SDL_GetThreadID(stdin_thread), 0);
|
|
|
|
#elif !defined(__APPLE__)
|
|
|
|
close(0); /* make stdin thread exit */
|
|
|
|
#endif
|
|
|
|
SDL_Quit();
|
2023-10-17 14:16:47 -04:00
|
|
|
free(u->ram);
|
2023-08-15 21:44:16 -04:00
|
|
|
return u->dev[0x0f] & 0x7f;
|
|
|
|
}
|
|
|
|
|
2021-02-08 18:46:52 -05:00
|
|
|
int
|
|
|
|
main(int argc, char **argv)
|
|
|
|
{
|
2023-11-11 23:57:28 -05:00
|
|
|
Uint8 *ram;
|
|
|
|
char *rom;
|
2024-01-02 22:20:16 -05:00
|
|
|
Uxn u = {0};
|
2023-12-20 03:20:22 -05:00
|
|
|
Uint8 dev[0x100] = {0};
|
2024-01-02 14:54:12 -05:00
|
|
|
Uxn u_audio = {0};
|
2023-12-20 03:20:22 -05:00
|
|
|
u.dev = (Uint8 *)&dev;
|
|
|
|
u_audio.dev = (Uint8 *)&dev;
|
2023-04-17 12:48:27 -04:00
|
|
|
int i = 1;
|
2024-01-02 22:20:16 -05:00
|
|
|
/* flags */
|
|
|
|
if(argc > 1 && argv[i][0] == '-') {
|
|
|
|
if(!strcmp(argv[i], "-v"))
|
|
|
|
return system_error("Uxnemu - Varvara Emulator(GUI)", "2 Jan 2024.");
|
|
|
|
else if(!strcmp(argv[i], "-2x"))
|
|
|
|
set_zoom(2, 0);
|
|
|
|
else if(!strcmp(argv[i], "-3x"))
|
|
|
|
set_zoom(3, 0);
|
|
|
|
else if(strcmp(argv[i], "-f") == 0)
|
2023-10-24 21:22:05 -04:00
|
|
|
set_fullscreen(1, 0);
|
2024-01-02 22:20:16 -05:00
|
|
|
i++;
|
2023-10-24 21:22:05 -04:00
|
|
|
}
|
2024-01-02 22:20:16 -05:00
|
|
|
if(i == argc)
|
2024-01-02 23:24:42 -05:00
|
|
|
return system_error("usage:", "uxnemu [-v | -f | -2x | -3x] file.rom [args...]");
|
2024-01-02 22:20:16 -05:00
|
|
|
/* start */
|
2023-11-11 23:57:28 -05:00
|
|
|
ram = (Uint8 *)calloc(0x10000 * RAM_PAGES, sizeof(Uint8));
|
|
|
|
rom = argv[i++];
|
|
|
|
if(!system_init(&u, ram, rom) || !system_init(&u_audio, ram, rom))
|
2023-08-15 19:06:29 -04:00
|
|
|
return system_error("Init", "Failed to initialize uxn.");
|
2023-10-10 09:39:47 -04:00
|
|
|
if(!emu_init(&u_audio))
|
|
|
|
return system_error("Init", "Failed to initialize varvara.");
|
2024-01-02 22:20:16 -05:00
|
|
|
/* loop */
|
2023-08-15 19:11:21 -04:00
|
|
|
u.dev[0x17] = argc - i;
|
2023-08-15 21:44:16 -04:00
|
|
|
if(uxn_eval(&u, PAGE_PROGRAM)) {
|
|
|
|
console_listen(&u, i, argc, argv);
|
2023-08-15 21:53:51 -04:00
|
|
|
emu_run(&u, boot_rom);
|
2023-08-15 21:44:16 -04:00
|
|
|
}
|
|
|
|
return emu_end(&u);
|
2021-02-08 17:18:01 -05:00
|
|
|
}
|