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"
|
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.
|
|
|
|
*/
|
|
|
|
|
2021-09-21 18:41:59 -04:00
|
|
|
#define WIDTH 64 * 8
|
|
|
|
#define HEIGHT 40 * 8
|
2021-08-04 23:30:57 -04:00
|
|
|
#define PAD 4
|
2022-06-10 01:31:07 -04:00
|
|
|
#define TIMEOUT_MS 334
|
|
|
|
#define BENCH 0
|
2021-08-04 23:30:57 -04:00
|
|
|
|
2021-03-16 12:01:47 -04:00
|
|
|
static SDL_Window *gWindow;
|
2021-09-16 22:48:00 -04:00
|
|
|
static SDL_Texture *gTexture;
|
|
|
|
static SDL_Renderer *gRenderer;
|
|
|
|
static SDL_AudioDeviceID audio_id;
|
2021-05-19 18:17:58 -04:00
|
|
|
static SDL_Rect gRect;
|
2022-04-09 07:22:24 -04:00
|
|
|
static SDL_Thread *stdin_thread;
|
2021-12-28 16:37:26 -05:00
|
|
|
|
2023-03-14 15:40:31 -04:00
|
|
|
Uint16 deo_mask[] = {0xff08, 0x0300, 0xc028, 0x8000, 0x8000, 0x8000, 0x8000, 0x0000, 0x0000, 0x0000, 0xa260, 0xa260, 0x0000, 0x0000, 0x0000, 0x0000};
|
2023-03-18 00:45:03 -04:00
|
|
|
Uint16 dei_mask[] = {0x0000, 0x0000, 0x003c, 0x0014, 0x0014, 0x0014, 0x0014, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x07ff, 0x0000, 0x0000, 0x0000};
|
2023-03-06 13:36:24 -05:00
|
|
|
|
2021-09-16 22:48:00 -04:00
|
|
|
/* devices */
|
2021-12-28 16:37:26 -05:00
|
|
|
|
2021-09-29 20:58:58 -04:00
|
|
|
static Uint8 zoom = 1;
|
2022-06-10 01:31:07 -04:00
|
|
|
static Uint32 stdin_event, audio0_event;
|
|
|
|
static Uint64 exec_deadline, deadline_interval, ms_interval;
|
2021-02-18 21:16:39 -05:00
|
|
|
|
2022-11-12 00:12:30 -05:00
|
|
|
char *rom_path;
|
|
|
|
|
2021-06-28 17:42:36 -04:00
|
|
|
static int
|
2021-02-14 13:22:42 -05:00
|
|
|
error(char *msg, const char *err)
|
|
|
|
{
|
2021-07-24 20:09:46 -04:00
|
|
|
fprintf(stderr, "%s: %s\n", msg, err);
|
2022-04-09 07:21:39 -04:00
|
|
|
fflush(stderr);
|
2021-02-14 13:22:42 -05:00
|
|
|
return 0;
|
2021-02-09 13:58:06 -05:00
|
|
|
}
|
|
|
|
|
2023-04-12 14:58:32 -04:00
|
|
|
static int
|
|
|
|
clamp(int val, int min, int max)
|
|
|
|
{
|
|
|
|
return (val >= min) ? (val <= max) ? val : max : min;
|
|
|
|
}
|
|
|
|
|
2023-01-02 10:01:55 -05:00
|
|
|
static Uint8
|
|
|
|
audio_dei(int instance, Uint8 *d, Uint8 port)
|
|
|
|
{
|
|
|
|
if(!audio_id) return d[port];
|
|
|
|
switch(port) {
|
|
|
|
case 0x4: return audio_get_vu(instance);
|
2023-03-12 18:25:52 -04:00
|
|
|
case 0x2: POKE2(d + 0x2, audio_get_position(instance)); /* fall through */
|
2023-01-02 10:01:55 -05:00
|
|
|
default: return d[port];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
SDL_PauseAudioDevice(audio_id, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-03-05 13:44:23 -05:00
|
|
|
Uint8
|
|
|
|
uxn_dei(Uxn *u, Uint8 addr)
|
2023-01-01 17:18:27 -05:00
|
|
|
{
|
|
|
|
Uint8 p = addr & 0x0f, d = addr & 0xf0;
|
|
|
|
switch(d) {
|
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
|
|
|
|
uxn_deo(Uxn *u, Uint8 addr)
|
2023-01-01 17:18:27 -05:00
|
|
|
{
|
|
|
|
Uint8 p = addr & 0x0f, d = addr & 0xf0;
|
|
|
|
switch(d) {
|
|
|
|
case 0x00:
|
|
|
|
system_deo(u, &u->dev[d], p);
|
|
|
|
if(p > 0x7 && p < 0xe)
|
|
|
|
screen_palette(&uxn_screen, &u->dev[0x8]);
|
|
|
|
break;
|
|
|
|
case 0x10: console_deo(&u->dev[d], p); break;
|
|
|
|
case 0x20: screen_deo(u->ram, &u->dev[d], 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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-21 18:41:59 -04:00
|
|
|
#pragma mark - Generics
|
|
|
|
|
2021-04-08 16:14:40 -04:00
|
|
|
static void
|
|
|
|
audio_callback(void *u, Uint8 *stream, int len)
|
|
|
|
{
|
2022-03-17 12:59:36 -04:00
|
|
|
int instance, running = 0;
|
2021-04-25 10:12:45 -04:00
|
|
|
Sint16 *samples = (Sint16 *)stream;
|
2023-03-20 11:58:09 -04:00
|
|
|
USED(u);
|
2021-04-25 10:12:45 -04:00
|
|
|
SDL_memset(stream, 0, len);
|
2022-03-17 12:59:36 -04:00
|
|
|
for(instance = 0; instance < POLYPHONY; instance++)
|
|
|
|
running += audio_render(instance, samples, samples + len / 2);
|
2021-07-17 05:13:21 -04:00
|
|
|
if(!running)
|
|
|
|
SDL_PauseAudioDevice(audio_id, 1);
|
2021-04-08 16:14:40 -04:00
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
2021-09-22 13:57:43 -04:00
|
|
|
SDL_Point win, win_old;
|
2021-09-21 18:56:42 -04:00
|
|
|
SDL_GetWindowPosition(window, &win.x, &win.y);
|
|
|
|
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;
|
2021-09-22 13:57:43 -04:00
|
|
|
SDL_SetWindowPosition(window, (win.x + win_old.x / 2) - w / 2, (win.y + win_old.y / 2) - h / 2);
|
2021-09-21 16:21:48 -04:00
|
|
|
SDL_SetWindowSize(window, w, h);
|
|
|
|
}
|
|
|
|
|
2023-01-01 17:18:27 -05:00
|
|
|
static int
|
2022-01-19 20:24:22 -05:00
|
|
|
set_size(void)
|
2021-09-22 13:57:43 -04:00
|
|
|
{
|
|
|
|
gRect.x = PAD;
|
|
|
|
gRect.y = PAD;
|
2021-12-29 12:11:03 -05:00
|
|
|
gRect.w = uxn_screen.width;
|
|
|
|
gRect.h = uxn_screen.height;
|
2021-09-22 13:57:43 -04:00
|
|
|
if(gTexture != NULL) SDL_DestroyTexture(gTexture);
|
2021-12-29 12:11:03 -05:00
|
|
|
SDL_RenderSetLogicalSize(gRenderer, uxn_screen.width + PAD * 2, uxn_screen.height + PAD * 2);
|
2022-01-06 12:24:35 -05:00
|
|
|
gTexture = SDL_CreateTexture(gRenderer, SDL_PIXELFORMAT_RGB888, SDL_TEXTUREACCESS_STATIC, uxn_screen.width, uxn_screen.height);
|
2021-09-22 13:57:43 -04:00
|
|
|
if(gTexture == NULL || SDL_SetTextureBlendMode(gTexture, SDL_BLENDMODE_NONE))
|
2021-10-24 15:48:56 -04:00
|
|
|
return error("gTexture", SDL_GetError());
|
2021-12-29 12:11:03 -05:00
|
|
|
if(SDL_UpdateTexture(gTexture, NULL, uxn_screen.pixels, sizeof(Uint32)) != 0)
|
2021-10-24 15:48:56 -04:00
|
|
|
return error("SDL_UpdateTexture", SDL_GetError());
|
2022-01-19 20:24:22 -05:00
|
|
|
set_window_size(gWindow, (uxn_screen.width + PAD * 2) * zoom, (uxn_screen.height + PAD * 2) * zoom);
|
2021-09-22 13:57:43 -04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2021-06-28 17:42:36 -04:00
|
|
|
static void
|
2022-01-05 23:44:33 -05:00
|
|
|
redraw(void)
|
2021-02-08 18:46:52 -05:00
|
|
|
{
|
2022-01-19 20:24:22 -05:00
|
|
|
if(gRect.w != uxn_screen.width || gRect.h != uxn_screen.height) set_size();
|
2023-03-27 11:38:54 -04:00
|
|
|
screen_redraw(&uxn_screen);
|
2022-01-05 16:45:49 -05:00
|
|
|
if(SDL_UpdateTexture(gTexture, NULL, uxn_screen.pixels, uxn_screen.width * sizeof(Uint32)) != 0)
|
2021-10-24 15:48:56 -04:00
|
|
|
error("SDL_UpdateTexture", SDL_GetError());
|
2021-09-16 22:48:00 -04:00
|
|
|
SDL_RenderClear(gRenderer);
|
2022-01-05 16:45:49 -05:00
|
|
|
SDL_RenderCopy(gRenderer, gTexture, NULL, &gRect);
|
2021-09-16 22:48:00 -04:00
|
|
|
SDL_RenderPresent(gRenderer);
|
2021-02-08 18:46:52 -05:00
|
|
|
}
|
|
|
|
|
2021-06-28 17:42:36 -04:00
|
|
|
static int
|
2021-11-08 10:51:09 -05:00
|
|
|
init(void)
|
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;
|
|
|
|
as.format = AUDIO_S16;
|
|
|
|
as.channels = 2;
|
|
|
|
as.callback = audio_callback;
|
|
|
|
as.samples = 512;
|
|
|
|
as.userdata = NULL;
|
2022-04-09 07:19:27 -04:00
|
|
|
if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_JOYSTICK) < 0)
|
2021-12-28 20:38:55 -05:00
|
|
|
return error("sdl", SDL_GetError());
|
2022-01-28 21:13:01 -05:00
|
|
|
gWindow = SDL_CreateWindow("Uxn", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, (WIDTH + PAD * 2) * zoom, (HEIGHT + PAD * 2) * zoom, SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI);
|
2021-02-08 18:46:52 -05:00
|
|
|
if(gWindow == NULL)
|
2021-07-24 20:09:46 -04:00
|
|
|
return error("sdl_window", SDL_GetError());
|
2021-09-16 22:48:00 -04:00
|
|
|
gRenderer = SDL_CreateRenderer(gWindow, -1, 0);
|
|
|
|
if(gRenderer == NULL)
|
|
|
|
return error("sdl_renderer", SDL_GetError());
|
2022-01-05 16:45:49 -05:00
|
|
|
SDL_SetRenderDrawColor(gRenderer, 0x00, 0x00, 0x00, 0xff);
|
2021-12-28 20:38:55 -05:00
|
|
|
audio_id = SDL_OpenAudioDevice(NULL, 0, &as, NULL, 0);
|
|
|
|
if(!audio_id)
|
|
|
|
error("sdl_audio", SDL_GetError());
|
2021-12-29 12:33:23 -05:00
|
|
|
if(SDL_NumJoysticks() > 0 && SDL_JoystickOpen(0) == NULL)
|
2021-12-28 20:38:55 -05:00
|
|
|
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);
|
2022-06-10 01:31:07 -04:00
|
|
|
ms_interval = SDL_GetPerformanceFrequency() / 1000;
|
|
|
|
deadline_interval = ms_interval * TIMEOUT_MS;
|
2021-02-08 18:46:52 -05:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2021-02-09 00:59:46 -05:00
|
|
|
#pragma mark - Devices
|
|
|
|
|
2021-11-08 10:51:09 -05:00
|
|
|
/* Boot */
|
|
|
|
|
|
|
|
static int
|
2021-11-08 12:12:17 -05:00
|
|
|
start(Uxn *u, char *rom)
|
2021-11-08 10:51:09 -05:00
|
|
|
{
|
2023-01-31 12:49:32 -05:00
|
|
|
free(u->ram);
|
2023-03-05 13:44:23 -05:00
|
|
|
if(!uxn_boot(u, (Uint8 *)calloc(0x10000 * RAM_PAGES, sizeof(Uint8))))
|
2021-11-08 10:51:09 -05:00
|
|
|
return error("Boot", "Failed to start uxn.");
|
2023-01-31 12:38:06 -05:00
|
|
|
if(!system_load(u, rom))
|
2022-01-06 17:32:28 -05:00
|
|
|
return error("Boot", "Failed to load rom.");
|
2022-06-10 01:31:07 -04:00
|
|
|
exec_deadline = SDL_GetPerformanceCounter() + deadline_interval;
|
2021-11-08 10:51:09 -05:00
|
|
|
if(!uxn_eval(u, PAGE_PROGRAM))
|
2023-01-01 17:18:27 -05:00
|
|
|
return error("Boot", "Failed to eval rom.");
|
|
|
|
SDL_SetWindowTitle(gWindow, rom);
|
2021-11-08 10:51:09 -05:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2021-12-27 16:59:22 -05:00
|
|
|
static void
|
2023-04-17 12:36:55 -04:00
|
|
|
set_zoom(Uint8 z)
|
2021-12-27 16:59:22 -05:00
|
|
|
{
|
2023-04-17 12:36:55 -04:00
|
|
|
zoom = z;
|
2021-12-29 12:11:03 -05:00
|
|
|
set_window_size(gWindow, (uxn_screen.width + PAD * 2) * zoom, (uxn_screen.height + PAD * 2) * zoom);
|
2021-12-27 16:59:22 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
capture_screen(void)
|
|
|
|
{
|
|
|
|
const Uint32 format = SDL_PIXELFORMAT_RGB24;
|
|
|
|
time_t t = time(NULL);
|
|
|
|
char fname[64];
|
|
|
|
int w, h;
|
|
|
|
SDL_Surface *surface;
|
|
|
|
SDL_GetRendererOutputSize(gRenderer, &w, &h);
|
|
|
|
surface = SDL_CreateRGBSurfaceWithFormat(0, w, h, 24, format);
|
|
|
|
SDL_RenderReadPixels(gRenderer, NULL, format, surface->pixels, surface->pitch);
|
|
|
|
strftime(fname, sizeof(fname), "screenshot-%Y%m%d-%H%M%S.bmp", localtime(&t));
|
|
|
|
SDL_SaveBMP(surface, fname);
|
|
|
|
SDL_FreeSurface(surface);
|
|
|
|
fprintf(stderr, "Saved %s\n", fname);
|
2022-04-09 07:21:39 -04:00
|
|
|
fflush(stderr);
|
2021-12-27 16:59:22 -05:00
|
|
|
}
|
|
|
|
|
2021-11-08 12:13:43 -05:00
|
|
|
static void
|
2021-11-08 12:12:17 -05:00
|
|
|
restart(Uxn *u)
|
2021-11-08 10:51:09 -05:00
|
|
|
{
|
2022-01-19 20:24:22 -05:00
|
|
|
screen_resize(&uxn_screen, WIDTH, HEIGHT);
|
2022-11-12 00:12:30 -05:00
|
|
|
if(!start(u, "launcher.rom"))
|
|
|
|
start(u, rom_path);
|
2021-11-08 10:51:09 -05:00
|
|
|
}
|
|
|
|
|
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-11-08 10:51:09 -05:00
|
|
|
static void
|
2021-12-27 12:24:43 -05:00
|
|
|
do_shortcut(Uxn *u, SDL_Event *event)
|
2021-11-08 10:51:09 -05:00
|
|
|
{
|
2021-12-27 12:24:43 -05:00
|
|
|
if(event->key.keysym.sym == SDLK_F1)
|
2023-04-17 12:36:55 -04:00
|
|
|
set_zoom(zoom == 3 ? 1 : zoom + 1);
|
2021-12-27 16:59:22 -05:00
|
|
|
else if(event->key.keysym.sym == SDLK_F2)
|
2022-01-13 11:34:32 -05:00
|
|
|
system_inspect(u);
|
2021-12-27 16:59:22 -05:00
|
|
|
else if(event->key.keysym.sym == SDLK_F3)
|
2021-12-27 12:24:43 -05:00
|
|
|
capture_screen();
|
|
|
|
else if(event->key.keysym.sym == SDLK_F4)
|
|
|
|
restart(u);
|
2021-11-08 10:51:09 -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)
|
|
|
|
return error("Run", "Quit.");
|
|
|
|
else if(event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_EXPOSED)
|
|
|
|
redraw();
|
|
|
|
else if(event.type == SDL_DROPFILE) {
|
|
|
|
screen_resize(&uxn_screen, WIDTH, HEIGHT);
|
|
|
|
start(u, event.drop.file);
|
|
|
|
SDL_free(event.drop.file);
|
|
|
|
}
|
|
|
|
/* Audio */
|
2023-04-12 23:00:17 -04:00
|
|
|
else if(event.type >= audio0_event && event.type < audio0_event + POLYPHONY)
|
2023-03-12 18:25:52 -04:00
|
|
|
uxn_eval(u, PEEK2(&u->dev[0x30 + 0x10 * (event.type - audio0_event)]));
|
2022-03-27 08:18:37 -04:00
|
|
|
/* Mouse */
|
|
|
|
else if(event.type == SDL_MOUSEMOTION)
|
2023-01-01 16:34:20 -05: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));
|
2022-03-27 08:18:37 -04:00
|
|
|
else
|
|
|
|
do_shortcut(u, &event);
|
|
|
|
ksym = event.key.keysym.sym;
|
|
|
|
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:16:40 -04:00
|
|
|
}
|
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) {
|
|
|
|
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:
|
|
|
|
/* Set all directions to down */
|
|
|
|
controller_up(u, &u->dev[0x80], 0x10 | 0x20 | 0x40 | 0x80);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Ignore */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
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
|
|
|
|
run(Uxn *u)
|
|
|
|
{
|
2023-01-28 13:54:54 -05:00
|
|
|
Uint64 now = SDL_GetPerformanceCounter(), frame_end, frame_interval = SDL_GetPerformanceFrequency() / 60;
|
|
|
|
for(;;) {
|
2023-04-02 23:27:15 -04:00
|
|
|
Uint16 screen_vector;
|
2023-01-28 13:54:54 -05:00
|
|
|
/* .System/halt */
|
|
|
|
if(u->dev[0x0f])
|
|
|
|
return error("Run", "Ended.");
|
|
|
|
frame_end = now + frame_interval;
|
2022-06-10 01:31:07 -04:00
|
|
|
exec_deadline = now + deadline_interval;
|
|
|
|
if(!handle_events(u))
|
|
|
|
return 0;
|
2023-04-02 23:27:15 -04:00
|
|
|
screen_vector = PEEK2(&u->dev[0x20]);
|
2023-03-04 14:07:11 -05:00
|
|
|
uxn_eval(u, screen_vector);
|
2022-06-10 01:31:07 -04:00
|
|
|
if(uxn_screen.fg.changed || uxn_screen.bg.changed)
|
|
|
|
redraw();
|
2023-01-28 13:54:54 -05:00
|
|
|
now = SDL_GetPerformanceCounter();
|
2023-03-04 14:07:11 -05:00
|
|
|
if(screen_vector) {
|
2023-01-28 13:54:54 -05:00
|
|
|
if(!BENCH && ((Sint64)(frame_end - now)) > 0) {
|
|
|
|
SDL_Delay((frame_end - now) / ms_interval);
|
|
|
|
now = frame_end;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
SDL_WaitEvent(NULL);
|
2021-02-08 18:46:52 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
main(int argc, char **argv)
|
|
|
|
{
|
2021-09-22 13:42:17 -04:00
|
|
|
SDL_DisplayMode DM;
|
2022-03-29 13:23:59 -04:00
|
|
|
Uxn u = {0};
|
2023-04-17 12:36:55 -04:00
|
|
|
int i = 1, loaded = 0;
|
2021-11-08 10:51:09 -05:00
|
|
|
if(!init())
|
|
|
|
return error("Init", "Failed to initialize emulator.");
|
2022-01-19 20:24:22 -05:00
|
|
|
screen_resize(&uxn_screen, WIDTH, HEIGHT);
|
2021-09-22 14:21:57 -04:00
|
|
|
/* set default zoom */
|
2023-04-17 12:36:55 -04:00
|
|
|
if(strcmp(argv[i], "-1x") == 0 || strcmp(argv[i], "-2x") == 0 || strcmp(argv[i], "-3x") == 0)
|
|
|
|
set_zoom(argv[i++][1] - '0');
|
|
|
|
else if(SDL_GetCurrentDisplayMode(0, &DM) == 0)
|
2021-10-24 15:31:25 -04:00
|
|
|
set_zoom(DM.w / 1280);
|
2023-04-17 12:36:55 -04:00
|
|
|
for(; i < argc; i++) {
|
|
|
|
if(!loaded++) {
|
2021-11-08 12:12:17 -05:00
|
|
|
if(!start(&u, argv[i]))
|
2021-11-08 10:51:09 -05:00
|
|
|
return error("Boot", "Failed to boot.");
|
2022-11-12 00:12:30 -05:00
|
|
|
rom_path = argv[i];
|
2021-10-13 17:56:38 -04:00
|
|
|
} else {
|
|
|
|
char *p = argv[i];
|
2023-04-17 00:13:50 -04:00
|
|
|
while(*p) console_input(&u, *p++, CONSOLE_ARG);
|
2023-04-17 12:36:55 -04:00
|
|
|
console_input(&u, '\n', i == argc - 1 ? CONSOLE_END : CONSOLE_EOA);
|
2021-09-21 18:56:42 -04:00
|
|
|
}
|
|
|
|
}
|
2022-01-10 23:35:34 -05:00
|
|
|
if(!loaded && !start(&u, "launcher.rom"))
|
2021-11-02 23:15:25 -04:00
|
|
|
return error("usage", "uxnemu [-s scale] file.rom");
|
2021-06-29 09:43:28 -04:00
|
|
|
run(&u);
|
2022-06-03 17:41:25 -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
|
2021-12-25 15:44:19 -05:00
|
|
|
SDL_Quit();
|
2021-02-08 17:18:01 -05:00
|
|
|
return 0;
|
|
|
|
}
|