Correctly free resources in uiLoadGame

README.md

@@ -13,3 +13,7 @@ Run
 ```sh
 make build
 ```
+
+## Dependencies
+
+This program uses a vendored version of [nuklear](https://github.com/Immediate-Mode-UI/Nuklear/tree/6566d9075d5fed48af014c93f87c4aed8c4bd21c) for GUIs.

assets.h

@@ -9,4 +9,9 @@ const uint8_t *LEFT_EYE_DEFAULT = &_binary_assets_lefteye_bin_start;
 extern const uint8_t _binary_assets_righteye_bin_start;
 const uint8_t *RIGHT_EYE_DEFAULT = &_binary_assets_righteye_bin_start; 
 
+extern const uint8_t _binary_assets_selawk_bin_start;
+extern const uint8_t _binary_assets_selawk_bin_end;
+const uint8_t *SELAWIK = &_binary_assets_selawk_bin_start;
+#define SELAWIK_LEN (&_binary_assets_selawk_bin_end - &_binary_assets_selawk_bin_start)
+
 #endif

audio.c

@@ -37,6 +37,10 @@ int audioInit(AudioContext *aud) {
     return 0;
 }
 
+void audioDestroy(AudioContext *aud) {
+    SDL_CloseAudioDevice(aud->id);
+}
+
 int audioUpdate(AudioContext *aud, void *data, uint32_t bytes) {
     int filled;
     if (!aud->id) return -1;

audio.h

@@ -13,6 +13,7 @@ typedef struct {
 } AudioContext;
 
 int audioInit(AudioContext *aud);
+void audioDestroy(AudioContext *aud);
 int audioUpdate(AudioContext *aud, void *data, uint32_t bytes);
 
 #endif

cli.c

@@ -2,10 +2,15 @@
 #include <stdio.h>
 
 int parseCLIArgs(int argc, char **argv, CLIArgs *args) {
-    if (argc != 2) {
-        fprintf(stderr, "usage: %s /path/to/rom.vb\n", argv[0]);
-        return 1;
+    int arg;
+
+    args->filename = NULL;
+    for (arg = 1; arg < argc; ++arg) {
+        if (args->filename) {
+            fprintf(stderr, "usage: %s /path/to/rom.vb\n", argv[0]);
+            return 1;
+        }
+        args->filename = argv[arg];
     }
-    args->filename = argv[1];
     return 0;
 }

emulation.c

@@ -0,0 +1,75 @@
+#include "emulation.h"
+#include <stdlib.h>
+
+static int onFrame(VB *sim) {
+    SimContext *ctx = vbGetUserData(sim);
+    ctx->hasFrame = true;
+    return 1;
+}
+
+int emuInit(EmulationContext *emu) {
+    emu->sim = malloc(vbSizeOf());
+    vbInit(emu->sim);
+
+    emu->ctx = malloc(sizeof(SimContext));
+    emu->ctx->hasFrame = false;
+    emu->ctx->currentSample = 0;
+    vbSetSamples(emu->sim, emu->ctx->samples[emu->ctx->currentSample], VB_S16, 834);
+    vbSetUserData(emu->sim, emu->ctx);
+    vbSetFrameCallback(emu->sim, &onFrame);
+
+    return 0;
+}
+
+void emuDestroy(EmulationContext *emu) {
+    uint8_t *rom = vbGetCartROM(emu->sim, NULL);
+    SimContext *ctx = vbGetUserData(emu->sim);
+
+    if (rom) free(rom);
+    if (ctx) free(ctx);
+    free(emu->sim);
+}
+
+void emuLoadGame(EmulationContext *emu, uint8_t *rom, uint32_t romSize) {
+    uint8_t *oldRom = vbGetCartROM(emu->sim, NULL);
+    if (oldRom) free(oldRom);
+    vbSetCartROM(emu->sim, rom, romSize);
+    vbReset(emu->sim);
+}
+
+void emuReset(EmulationContext *emu) {
+    vbReset(emu->sim);
+}
+
+bool emuIsGameLoaded(EmulationContext *emu) {
+    return vbGetCartROM(emu->sim, NULL) != NULL;
+}
+
+#define MAX_STEP_CLOCKS 20000000
+void emuTick(EmulationContext *emu) {
+    uint32_t clocks = MAX_STEP_CLOCKS;
+    vbEmulate(emu->sim, &clocks);
+}
+
+bool emuReadPixels(EmulationContext *emu, uint8_t *left, uint8_t *right) {
+    if (!emu->ctx->hasFrame) {
+        return false;
+    }
+    emu->ctx->hasFrame = false;
+    vbGetPixels(emu->sim, left, 1, 384, right, 1, 384);
+    return true;
+}
+
+void emuReadSamples(EmulationContext *emu, void **data, uint32_t *bytes) {
+    uint32_t samplePairs;
+
+    *data = vbGetSamples(emu->sim, NULL, NULL, &samplePairs);
+    *bytes = samplePairs * 4;
+    emu->ctx->currentSample += 1;
+    emu->ctx->currentSample %= 2;
+    vbSetSamples(emu->sim, emu->ctx->samples[emu->ctx->currentSample], VB_S16, 834);
+}
+
+void emuSetKeys(EmulationContext *emu, uint16_t keys) {
+    vbSetKeys(emu->sim, keys);
+}

emulation.h

@@ -0,0 +1,30 @@
+#ifndef SHROOMS_VB_NATIVE_EMULATION_
+#define SHROOMS_VB_NATIVE_EMULATION_
+
+#include "shrooms-vb-core/core/vb.h"
+#include <stdbool.h>
+#include <stdint.h>
+
+typedef struct SimContext {
+    bool hasFrame;
+    uint32_t samples[2][834];
+    uint32_t currentSample;
+} SimContext;
+
+typedef struct EmulationContext {
+    VB *sim;
+    SimContext *ctx;
+} EmulationContext;
+
+int emuInit(EmulationContext *emu);
+void emuDestroy(EmulationContext *emu);
+void emuLoadGame(EmulationContext *emu, uint8_t *rom, uint32_t romSize);
+void emuReset(EmulationContext *emu);
+bool emuIsGameLoaded(EmulationContext *emu);
+
+void emuTick(EmulationContext *emu);
+bool emuReadPixels(EmulationContext *emu, uint8_t *left, uint8_t *right);
+void emuReadSamples(EmulationContext *emu, void **data, uint32_t *bytes);
+void emuSetKeys(EmulationContext *emu, uint16_t keys);
+
+#endif

external/nuklear_sdl_renderer.h

@@ -0,0 +1,393 @@
+/*
+ * Nuklear - 4.9.4 - public domain
+ */
+/*
+ * ==============================================================
+ *
+ *                              API
+ *
+ * ===============================================================
+ */
+#ifndef NK_SDL_RENDERER_H_
+#define NK_SDL_RENDERER_H_
+
+#ifndef NK_SDL_RENDERER_SDL_H
+#define NK_SDL_RENDERER_SDL_H <SDL.h>
+#endif
+#include NK_SDL_RENDERER_SDL_H
+NK_API struct nk_context*   nk_sdl_init(SDL_Window *win, SDL_Renderer *renderer);
+NK_API void                 nk_sdl_font_stash_begin(struct nk_font_atlas **atlas);
+NK_API void                 nk_sdl_font_stash_end(void);
+NK_API int                  nk_sdl_handle_event(SDL_Event *evt);
+NK_API void                 nk_sdl_render(enum nk_anti_aliasing);
+NK_API void                 nk_sdl_shutdown(void);
+NK_API void                 nk_sdl_handle_grab(void);
+
+#if SDL_COMPILEDVERSION < SDL_VERSIONNUM(2, 0, 22)
+/* Metal API does not support cliprects with negative coordinates or large
+ * dimensions. The issue is fixed in SDL2 with version 2.0.22 but until
+ * that version is released, the NK_SDL_CLAMP_CLIP_RECT flag can be used to
+ * ensure the cliprect is itself clipped to the viewport.
+ * See discussion at https://discourse.libsdl.org/t/rendergeometryraw-producing-different-results-in-metal-vs-opengl/34953
+ */
+#define NK_SDL_CLAMP_CLIP_RECT
+#endif
+
+#endif /* NK_SDL_RENDERER_H_ */
+
+/*
+ * ==============================================================
+ *
+ *                          IMPLEMENTATION
+ *
+ * ===============================================================
+ */
+#ifdef NK_SDL_RENDERER_IMPLEMENTATION
+#include <string.h>
+#include <stdlib.h>
+
+struct nk_sdl_device {
+    struct nk_buffer cmds;
+    struct nk_draw_null_texture tex_null;
+    SDL_Texture *font_tex;
+};
+
+struct nk_sdl_vertex {
+    float position[2];
+    float uv[2];
+    nk_byte col[4];
+};
+
+static struct nk_sdl {
+    SDL_Window *win;
+    SDL_Renderer *renderer;
+    struct nk_sdl_device ogl;
+    struct nk_context ctx;
+    struct nk_font_atlas atlas;
+    Uint64 time_of_last_frame;
+} sdl;
+
+NK_INTERN void
+nk_sdl_device_upload_atlas(const void *image, int width, int height)
+{
+    struct nk_sdl_device *dev = &sdl.ogl;
+
+    SDL_Texture *g_SDLFontTexture = SDL_CreateTexture(sdl.renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STATIC, width, height);
+    if (g_SDLFontTexture == NULL) {
+        SDL_Log("error creating texture");
+        return;
+    }
+    SDL_UpdateTexture(g_SDLFontTexture, NULL, image, 4 * width);
+    SDL_SetTextureBlendMode(g_SDLFontTexture, SDL_BLENDMODE_BLEND);
+    dev->font_tex = g_SDLFontTexture;
+}
+
+NK_API void
+nk_sdl_render(enum nk_anti_aliasing AA)
+{
+    /* setup global state */
+    struct nk_sdl_device *dev = &sdl.ogl;
+
+    {
+        SDL_Rect saved_clip;
+#ifdef NK_SDL_CLAMP_CLIP_RECT
+        SDL_Rect viewport;
+#endif
+        SDL_bool clipping_enabled;
+        int vs = sizeof(struct nk_sdl_vertex);
+        size_t vp = offsetof(struct nk_sdl_vertex, position);
+        size_t vt = offsetof(struct nk_sdl_vertex, uv);
+        size_t vc = offsetof(struct nk_sdl_vertex, col);
+
+        /* convert from command queue into draw list and draw to screen */
+        const struct nk_draw_command *cmd;
+        const nk_draw_index *offset = NULL;
+        struct nk_buffer vbuf, ebuf;
+
+        /* fill converting configuration */
+        struct nk_convert_config config;
+        static const struct nk_draw_vertex_layout_element vertex_layout[] = {
+            {NK_VERTEX_POSITION, NK_FORMAT_FLOAT, NK_OFFSETOF(struct nk_sdl_vertex, position)},
+            {NK_VERTEX_TEXCOORD, NK_FORMAT_FLOAT, NK_OFFSETOF(struct nk_sdl_vertex, uv)},
+            {NK_VERTEX_COLOR, NK_FORMAT_R8G8B8A8, NK_OFFSETOF(struct nk_sdl_vertex, col)},
+            {NK_VERTEX_LAYOUT_END}
+        };
+
+        Uint64 now = SDL_GetTicks64();
+        sdl.ctx.delta_time_seconds = (float)(now - sdl.time_of_last_frame) / 1000;
+        sdl.time_of_last_frame = now;
+
+        NK_MEMSET(&config, 0, sizeof(config));
+        config.vertex_layout = vertex_layout;
+        config.vertex_size = sizeof(struct nk_sdl_vertex);
+        config.vertex_alignment = NK_ALIGNOF(struct nk_sdl_vertex);
+        config.tex_null = dev->tex_null;
+        config.circle_segment_count = 22;
+        config.curve_segment_count = 22;
+        config.arc_segment_count = 22;
+        config.global_alpha = 1.0f;
+        config.shape_AA = AA;
+        config.line_AA = AA;
+
+        /* convert shapes into vertexes */
+        nk_buffer_init_default(&vbuf);
+        nk_buffer_init_default(&ebuf);
+        nk_convert(&sdl.ctx, &dev->cmds, &vbuf, &ebuf, &config);
+
+        /* iterate over and execute each draw command */
+        offset = (const nk_draw_index*)nk_buffer_memory_const(&ebuf);
+
+        clipping_enabled = SDL_RenderIsClipEnabled(sdl.renderer);
+        SDL_RenderGetClipRect(sdl.renderer, &saved_clip);
+#ifdef NK_SDL_CLAMP_CLIP_RECT
+        SDL_RenderGetViewport(sdl.renderer, &viewport);
+#endif
+
+        nk_draw_foreach(cmd, &sdl.ctx, &dev->cmds)
+        {
+            if (!cmd->elem_count) continue;
+
+            {
+                SDL_Rect r;
+                r.x = cmd->clip_rect.x;
+                r.y = cmd->clip_rect.y;
+                r.w = cmd->clip_rect.w;
+                r.h = cmd->clip_rect.h;
+#ifdef NK_SDL_CLAMP_CLIP_RECT
+                if (r.x < 0) {
+                    r.w += r.x;
+                    r.x = 0;
+                }
+                if (r.y < 0) {
+                    r.h += r.y;
+                    r.y = 0;
+                }
+                if (r.h > viewport.h) {
+                    r.h = viewport.h;
+                }
+                if (r.w > viewport.w) {
+                    r.w = viewport.w;
+                }
+#endif
+                SDL_RenderSetClipRect(sdl.renderer, &r);
+            }
+
+            {
+                const void *vertices = nk_buffer_memory_const(&vbuf);
+
+                SDL_RenderGeometryRaw(sdl.renderer,
+                        (SDL_Texture *)cmd->texture.ptr,
+                        (const float*)((const nk_byte*)vertices + vp), vs,
+                        (const SDL_Color*)((const nk_byte*)vertices + vc), vs,
+                        (const float*)((const nk_byte*)vertices + vt), vs,
+                        (vbuf.needed / vs),
+                        (void *) offset, cmd->elem_count, 2);
+
+                offset += cmd->elem_count;
+            }
+        }
+
+        SDL_RenderSetClipRect(sdl.renderer, &saved_clip);
+        if (!clipping_enabled) {
+            SDL_RenderSetClipRect(sdl.renderer, NULL);
+        }
+
+        nk_clear(&sdl.ctx);
+        nk_buffer_clear(&dev->cmds);
+        nk_buffer_free(&vbuf);
+        nk_buffer_free(&ebuf);
+    }
+}
+
+static void
+nk_sdl_clipboard_paste(nk_handle usr, struct nk_text_edit *edit)
+{
+    const char *text = SDL_GetClipboardText();
+    if (text) nk_textedit_paste(edit, text, nk_strlen(text));
+    (void)usr;
+}
+
+static void
+nk_sdl_clipboard_copy(nk_handle usr, const char *text, int len)
+{
+    char *str = 0;
+    (void)usr;
+    if (!len) return;
+    str = (char*)malloc((size_t)len+1);
+    if (!str) return;
+    memcpy(str, text, (size_t)len);
+    str[len] = '\0';
+    SDL_SetClipboardText(str);
+    free(str);
+}
+
+NK_API struct nk_context*
+nk_sdl_init(SDL_Window *win, SDL_Renderer *renderer)
+{
+#ifndef NK_SDL_CLAMP_CLIP_RECT
+    SDL_RendererInfo info;
+    SDL_version runtimeVer;
+
+    /* warn for cases where NK_SDL_CLAMP_CLIP_RECT should have been set but isn't */
+    SDL_GetRendererInfo(renderer, &info);
+    SDL_GetVersion(&runtimeVer);
+    if (strncmp("metal", info.name, 5) == 0 &&
+        SDL_VERSIONNUM(runtimeVer.major, runtimeVer.minor, runtimeVer.patch) < SDL_VERSIONNUM(2, 0, 22))
+    {
+        SDL_LogWarn(
+            SDL_LOG_CATEGORY_APPLICATION,
+            "renderer is using Metal API but runtime SDL version %d.%d.%d is older than compiled version %d.%d.%d, "
+            "which may cause issues with rendering",
+            runtimeVer.major, runtimeVer.minor, runtimeVer.patch,
+            SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL
+        );
+    }
+#endif
+    sdl.win = win;
+    sdl.renderer = renderer;
+    sdl.time_of_last_frame = SDL_GetTicks64();
+    nk_init_default(&sdl.ctx, 0);
+    sdl.ctx.clip.copy = nk_sdl_clipboard_copy;
+    sdl.ctx.clip.paste = nk_sdl_clipboard_paste;
+    sdl.ctx.clip.userdata = nk_handle_ptr(0);
+    nk_buffer_init_default(&sdl.ogl.cmds);
+    return &sdl.ctx;
+}
+
+NK_API void
+nk_sdl_font_stash_begin(struct nk_font_atlas **atlas)
+{
+    nk_font_atlas_init_default(&sdl.atlas);
+    nk_font_atlas_begin(&sdl.atlas);
+    *atlas = &sdl.atlas;
+}
+
+NK_API void
+nk_sdl_font_stash_end(void)
+{
+    const void *image; int w, h;
+    image = nk_font_atlas_bake(&sdl.atlas, &w, &h, NK_FONT_ATLAS_RGBA32);
+    nk_sdl_device_upload_atlas(image, w, h);
+    nk_font_atlas_end(&sdl.atlas, nk_handle_ptr(sdl.ogl.font_tex), &sdl.ogl.tex_null);
+    if (sdl.atlas.default_font)
+        nk_style_set_font(&sdl.ctx, &sdl.atlas.default_font->handle);
+}
+
+NK_API void
+nk_sdl_handle_grab(void)
+{
+    struct nk_context *ctx = &sdl.ctx;
+    if (ctx->input.mouse.grab) {
+        SDL_SetRelativeMouseMode(SDL_TRUE);
+    } else if (ctx->input.mouse.ungrab) {
+        /* better support for older SDL by setting mode first; causes an extra mouse motion event */
+        SDL_SetRelativeMouseMode(SDL_FALSE);
+        SDL_WarpMouseInWindow(sdl.win, (int)ctx->input.mouse.prev.x, (int)ctx->input.mouse.prev.y);
+    } else if (ctx->input.mouse.grabbed) {
+        ctx->input.mouse.pos.x = ctx->input.mouse.prev.x;
+        ctx->input.mouse.pos.y = ctx->input.mouse.prev.y;
+    }
+}
+
+NK_API int
+nk_sdl_handle_event(SDL_Event *evt)
+{
+    struct nk_context *ctx = &sdl.ctx;
+
+    switch(evt->type)
+    {
+        case SDL_KEYUP: /* KEYUP & KEYDOWN share same routine */
+        case SDL_KEYDOWN:
+            {
+                int down = evt->type == SDL_KEYDOWN;
+                const Uint8* state = SDL_GetKeyboardState(0);
+                switch(evt->key.keysym.sym)
+                {
+                    case SDLK_RSHIFT: /* RSHIFT & LSHIFT share same routine */
+                    case SDLK_LSHIFT:    nk_input_key(ctx, NK_KEY_SHIFT, down); break;
+                    case SDLK_DELETE:    nk_input_key(ctx, NK_KEY_DEL, down); break;
+                    case SDLK_RETURN:    nk_input_key(ctx, NK_KEY_ENTER, down); break;
+                    case SDLK_TAB:       nk_input_key(ctx, NK_KEY_TAB, down); break;
+                    case SDLK_BACKSPACE: nk_input_key(ctx, NK_KEY_BACKSPACE, down); break;
+                    case SDLK_HOME:      nk_input_key(ctx, NK_KEY_TEXT_START, down);
+                                         nk_input_key(ctx, NK_KEY_SCROLL_START, down); break;
+                    case SDLK_END:       nk_input_key(ctx, NK_KEY_TEXT_END, down);
+                                         nk_input_key(ctx, NK_KEY_SCROLL_END, down); break;
+                    case SDLK_PAGEDOWN:  nk_input_key(ctx, NK_KEY_SCROLL_DOWN, down); break;
+                    case SDLK_PAGEUP:    nk_input_key(ctx, NK_KEY_SCROLL_UP, down); break;
+                    case SDLK_z:         nk_input_key(ctx, NK_KEY_TEXT_UNDO, down && state[SDL_SCANCODE_LCTRL]); break;
+                    case SDLK_r:         nk_input_key(ctx, NK_KEY_TEXT_REDO, down && state[SDL_SCANCODE_LCTRL]); break;
+                    case SDLK_c:         nk_input_key(ctx, NK_KEY_COPY, down && state[SDL_SCANCODE_LCTRL]); break;
+                    case SDLK_v:         nk_input_key(ctx, NK_KEY_PASTE, down && state[SDL_SCANCODE_LCTRL]); break;
+                    case SDLK_x:         nk_input_key(ctx, NK_KEY_CUT, down && state[SDL_SCANCODE_LCTRL]); break;
+                    case SDLK_b:         nk_input_key(ctx, NK_KEY_TEXT_LINE_START, down && state[SDL_SCANCODE_LCTRL]); break;
+                    case SDLK_e:         nk_input_key(ctx, NK_KEY_TEXT_LINE_END, down && state[SDL_SCANCODE_LCTRL]); break;
+                    case SDLK_UP:        nk_input_key(ctx, NK_KEY_UP, down); break;
+                    case SDLK_DOWN:      nk_input_key(ctx, NK_KEY_DOWN, down); break;
+                    case SDLK_LEFT:
+                        if (state[SDL_SCANCODE_LCTRL])
+                            nk_input_key(ctx, NK_KEY_TEXT_WORD_LEFT, down);
+                        else nk_input_key(ctx, NK_KEY_LEFT, down);
+                        break;
+                    case SDLK_RIGHT:
+                        if (state[SDL_SCANCODE_LCTRL])
+                            nk_input_key(ctx, NK_KEY_TEXT_WORD_RIGHT, down);
+                        else nk_input_key(ctx, NK_KEY_RIGHT, down);
+                        break;
+                }
+            }
+            return 1;
+
+        case SDL_MOUSEBUTTONUP: /* MOUSEBUTTONUP & MOUSEBUTTONDOWN share same routine */
+        case SDL_MOUSEBUTTONDOWN:
+            {
+                int down = evt->type == SDL_MOUSEBUTTONDOWN;
+                const int x = evt->button.x, y = evt->button.y;
+                switch(evt->button.button)
+                {
+                    case SDL_BUTTON_LEFT:
+                        if (evt->button.clicks > 1)
+                            nk_input_button(ctx, NK_BUTTON_DOUBLE, x, y, down);
+                        nk_input_button(ctx, NK_BUTTON_LEFT, x, y, down); break;
+                    case SDL_BUTTON_MIDDLE: nk_input_button(ctx, NK_BUTTON_MIDDLE, x, y, down); break;
+                    case SDL_BUTTON_RIGHT:  nk_input_button(ctx, NK_BUTTON_RIGHT, x, y, down); break;
+                }
+            }
+            return 1;
+
+        case SDL_MOUSEMOTION:
+            if (ctx->input.mouse.grabbed) {
+                int x = (int)ctx->input.mouse.prev.x, y = (int)ctx->input.mouse.prev.y;
+                nk_input_motion(ctx, x + evt->motion.xrel, y + evt->motion.yrel);
+            }
+            else nk_input_motion(ctx, evt->motion.x, evt->motion.y);
+            return 1;
+
+        case SDL_TEXTINPUT:
+            {
+                nk_glyph glyph;
+                memcpy(glyph, evt->text.text, NK_UTF_SIZE);
+                nk_input_glyph(ctx, glyph);
+            }
+            return 1;
+
+        case SDL_MOUSEWHEEL:
+            nk_input_scroll(ctx,nk_vec2((float)evt->wheel.x,(float)evt->wheel.y));
+            return 1;
+    }
+    return 0;
+}
+
+NK_API
+void nk_sdl_shutdown(void)
+{
+    struct nk_sdl_device *dev = &sdl.ogl;
+    nk_font_atlas_clear(&sdl.atlas);
+    nk_free(&sdl.ctx);
+    SDL_DestroyTexture(dev->font_tex);
+    /* glDeleteTextures(1, &dev->font_tex); */
+    nk_buffer_free(&dev->cmds);
+    memset(&sdl, 0, sizeof(sdl));
+}
+
+#endif /* NK_SDL_RENDERER_IMPLEMENTATION */

external/tinyfiledialogs.h

@@ -0,0 +1,314 @@
+/* SPDX-License-Identifier: Zlib
+Copyright (c) 2014 - 2024 Guillaume Vareille http://ysengrin.com
+	 ____________________________________________________________________
+	|                                                                    |
+	| 100% compatible C C++  ->  You can rename tinfiledialogs.c as .cpp |
+	|____________________________________________________________________|
+
+********* TINY FILE DIALOGS OFFICIAL WEBSITE IS ON SOURCEFORGE *********
+  _________
+ /         \ tinyfiledialogs.h v3.18.2 [Jun 8, 2024]
+ |tiny file| Unique header file created [November 9, 2014]
+ | dialogs |
+ \____  ___/ http://tinyfiledialogs.sourceforge.net
+      \|     git clone http://git.code.sf.net/p/tinyfiledialogs/code tinyfd
+ ____________________________________________
+|                                            |
+|   email: tinyfiledialogs at ysengrin.com   |
+|____________________________________________|
+ ________________________________________________________________________________
+|  ____________________________________________________________________________  |
+| |                                                                            | |
+| |  - in tinyfiledialogs, char is UTF-8 by default (since v3.6)               | |
+| |                                                                            | |
+| | on windows:                                                                | |
+| |  - for UTF-16, use the wchar_t functions at the bottom of the header file  | |
+| |                                                                            | |
+| |  - _wfopen() requires wchar_t                                              | |
+| |  - fopen() uses char but expects ASCII or MBCS (not UTF-8)                 | |
+| |  - if you want char to be MBCS: set tinyfd_winUtf8 to 0                    | |
+| |                                                                            | |
+| |  - alternatively, tinyfiledialogs provides                                 | |
+| |                        functions to convert between UTF-8, UTF-16 and MBCS | |
+| |____________________________________________________________________________| |
+|________________________________________________________________________________|
+
+If you like tinyfiledialogs, please upvote my stackoverflow answer
+https://stackoverflow.com/a/47651444
+
+- License -
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+1. The origin of this software must not be misrepresented; you must not
+claim that you wrote the original software.  If you use this software
+in a product, an acknowledgment in the product documentation would be
+appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+
+     __________________________________________
+    |  ______________________________________  |
+    | |                                      | |
+    | | DO NOT USE USER INPUT IN THE DIALOGS | |
+    | |______________________________________| |
+    |__________________________________________|
+*/
+
+#ifndef TINYFILEDIALOGS_H
+#define TINYFILEDIALOGS_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/******************************************************************************************************/
+/**************************************** UTF-8 on Windows ********************************************/
+/******************************************************************************************************/
+#ifdef _WIN32
+/* On windows, if you want to use UTF-8 ( instead of the UTF-16/wchar_t functions at the end of this file )
+Make sure your code is really prepared for UTF-8 (on windows, functions like fopen() expect MBCS and not UTF-8) */
+extern int tinyfd_winUtf8; /* on windows char strings can be 1:UTF-8(default) or 0:MBCS */
+/* for MBCS change this to 0, in tinyfiledialogs.c or in your code */
+
+/* Here are some functions to help you convert between UTF-16 UTF-8 MBSC */
+char * tinyfd_utf8toMbcs(char const * aUtf8string);
+char * tinyfd_utf16toMbcs(wchar_t const * aUtf16string);
+wchar_t * tinyfd_mbcsTo16(char const * aMbcsString);
+char * tinyfd_mbcsTo8(char const * aMbcsString);
+wchar_t * tinyfd_utf8to16(char const * aUtf8string);
+char * tinyfd_utf16to8(wchar_t const * aUtf16string);
+#endif
+/******************************************************************************************************/
+/******************************************************************************************************/
+/******************************************************************************************************/
+
+/************* 3 funtions for C# (you don't need this in C or C++) : */
+char const * tinyfd_getGlobalChar(char const * aCharVariableName); /* returns NULL on error */
+int tinyfd_getGlobalInt(char const * aIntVariableName); /* returns -1 on error */
+int tinyfd_setGlobalInt(char const * aIntVariableName, int aValue); /* returns -1 on error */
+/* aCharVariableName: "tinyfd_version" "tinyfd_needs" "tinyfd_response"
+   aIntVariableName : "tinyfd_verbose" "tinyfd_silent" "tinyfd_allowCursesDialogs"
+				      "tinyfd_forceConsole" "tinyfd_assumeGraphicDisplay" "tinyfd_winUtf8"
+**************/
+
+extern char tinyfd_version[8]; /* contains tinyfd current version number */
+extern char tinyfd_needs[]; /* info about requirements */
+extern int tinyfd_verbose; /* 0 (default) or 1 : on unix, prints the command line calls */
+extern int tinyfd_silent; /* 1 (default) or 0 : on unix, hide errors and warnings from called dialogs */
+
+/** Curses dialogs are difficult to use and counter-intuitive.
+On windows they are only ascii and still uses the unix backslash ! **/
+extern int tinyfd_allowCursesDialogs; /* 0 (default) or 1 */
+
+extern int tinyfd_forceConsole;  /* 0 (default) or 1 */
+/* for unix & windows: 0 (graphic mode) or 1 (console mode).
+0: try to use a graphic solution, if it fails then it uses console mode.
+1: forces all dialogs into console mode even when an X server is present.
+   if enabled, it can use the package Dialog or dialog.exe.
+   on windows it only make sense for console applications */
+
+extern int tinyfd_assumeGraphicDisplay; /* 0 (default) or 1  */
+/* some systems don't set the environment variable DISPLAY even when a graphic display is present.
+set this to 1 to tell tinyfiledialogs to assume the existence of a graphic display */
+
+extern char tinyfd_response[1024];
+/* if you pass "tinyfd_query" as aTitle,
+the functions will not display the dialogs
+but will return 0 for console mode, 1 for graphic mode.
+tinyfd_response is then filled with the retain solution.
+possible values for tinyfd_response are (all lowercase)
+for graphic mode:
+  windows_wchar windows applescript kdialog zenity zenity3 yad matedialog
+  shellementary qarma python2-tkinter python3-tkinter python-dbus
+  perl-dbus gxmessage gmessage xmessage xdialog gdialog dunst
+for console mode:
+  dialog whiptail basicinput no_solution */
+
+void tinyfd_beep(void);
+
+int tinyfd_notifyPopup(
+	char const * aTitle, /* NULL or "" */
+	char const * aMessage, /* NULL or "" may contain \n \t */
+	char const * aIconType); /* "info" "warning" "error" */
+		/* return has only meaning for tinyfd_query */
+
+int tinyfd_messageBox(
+	char const * aTitle , /* NULL or "" */
+	char const * aMessage , /* NULL or "" may contain \n \t */
+	char const * aDialogType , /* "ok" "okcancel" "yesno" "yesnocancel" */
+	char const * aIconType , /* "info" "warning" "error" "question" */
+	int aDefaultButton ) ;
+		/* 0 for cancel/no , 1 for ok/yes , 2 for no in yesnocancel */
+
+char * tinyfd_inputBox(
+	char const * aTitle , /* NULL or "" */
+	char const * aMessage , /* NULL or "" (\n and \t have no effect) */
+	char const * aDefaultInput ) ;  /* NULL = passwordBox, "" = inputbox */
+		/* returns NULL on cancel */
+
+char * tinyfd_saveFileDialog(
+	char const * aTitle , /* NULL or "" */
+	char const * aDefaultPathAndOrFile , /* NULL or "" , ends with / to set only a directory */
+	int aNumOfFilterPatterns , /* 0  (1 in the following example) */
+	char const * const * aFilterPatterns , /* NULL or char const * lFilterPatterns[1]={"*.txt"} */
+	char const * aSingleFilterDescription ) ; /* NULL or "text files" */
+		/* returns NULL on cancel */
+
+char * tinyfd_openFileDialog(
+	char const * aTitle, /* NULL or "" */
+	char const * aDefaultPathAndOrFile, /* NULL or "" , ends with / to set only a directory */
+	int aNumOfFilterPatterns , /* 0 (2 in the following example) */
+	char const * const * aFilterPatterns, /* NULL or char const * lFilterPatterns[2]={"*.png","*.jpg"}; */
+	char const * aSingleFilterDescription, /* NULL or "image files" */
+	int aAllowMultipleSelects ) ; /* 0 or 1 */
+		/* in case of multiple files, the separator is | */
+		/* returns NULL on cancel */
+
+char * tinyfd_selectFolderDialog(
+	char const * aTitle, /* NULL or "" */
+	char const * aDefaultPath); /* NULL or "" */
+		/* returns NULL on cancel */
+
+char * tinyfd_colorChooser(
+	char const * aTitle, /* NULL or "" */
+	char const * aDefaultHexRGB, /* NULL or "" or "#FF0000" */
+	unsigned char const aDefaultRGB[3] , /* unsigned char lDefaultRGB[3] = { 0 , 128 , 255 }; */
+	unsigned char aoResultRGB[3] ) ; /* unsigned char lResultRGB[3]; */
+		/* aDefaultRGB is used only if aDefaultHexRGB is absent */
+		/* aDefaultRGB and aoResultRGB can be the same array */
+		/* returns NULL on cancel */
+		/* returns the hexcolor as a string "#FF0000" */
+		/* aoResultRGB also contains the result */
+
+
+/************ WINDOWS ONLY SECTION ************************/
+#ifdef _WIN32
+
+/* windows only - utf-16 version */
+int tinyfd_notifyPopupW(
+	wchar_t const * aTitle, /* NULL or L"" */
+	wchar_t const * aMessage, /* NULL or L"" may contain \n \t */
+	wchar_t const * aIconType); /* L"info" L"warning" L"error" */
+
+/* windows only - utf-16 version */
+int tinyfd_messageBoxW(
+	wchar_t const * aTitle, /* NULL or L"" */
+	wchar_t const * aMessage, /* NULL or L"" may contain \n \t */
+	wchar_t const * aDialogType, /* L"ok" L"okcancel" L"yesno" */
+	wchar_t const * aIconType, /* L"info" L"warning" L"error" L"question" */
+	int aDefaultButton ); /* 0 for cancel/no , 1 for ok/yes */
+		/* returns 0 for cancel/no , 1 for ok/yes */
+
+/* windows only - utf-16 version */
+wchar_t * tinyfd_inputBoxW(
+	wchar_t const * aTitle, /* NULL or L"" */
+	wchar_t const * aMessage, /* NULL or L"" (\n nor \t not respected) */
+	wchar_t const * aDefaultInput); /* NULL passwordBox, L"" inputbox */
+
+/* windows only - utf-16 version */
+wchar_t * tinyfd_saveFileDialogW(
+	wchar_t const * aTitle, /* NULL or L"" */
+	wchar_t const * aDefaultPathAndOrFile, /* NULL or L"" , ends with / to set only a directory */
+	int aNumOfFilterPatterns, /* 0 (1 in the following example) */
+	wchar_t const * const * aFilterPatterns, /* NULL or wchar_t const * lFilterPatterns[1]={L"*.txt"} */
+	wchar_t const * aSingleFilterDescription); /* NULL or L"text files" */
+		/* returns NULL on cancel */
+
+/* windows only - utf-16 version */
+wchar_t * tinyfd_openFileDialogW(
+	wchar_t const * aTitle, /* NULL or L"" */
+	wchar_t const * aDefaultPathAndOrFile, /* NULL or L"" , ends with / to set only a directory */
+	int aNumOfFilterPatterns , /* 0 (2 in the following example) */
+	wchar_t const * const * aFilterPatterns, /* NULL or wchar_t const * lFilterPatterns[2]={L"*.png","*.jpg"} */
+	wchar_t const * aSingleFilterDescription, /* NULL or L"image files" */
+	int aAllowMultipleSelects ) ; /* 0 or 1 */
+		/* in case of multiple files, the separator is | */
+		/* returns NULL on cancel */
+
+/* windows only - utf-16 version */
+wchar_t * tinyfd_selectFolderDialogW(
+	wchar_t const * aTitle, /* NULL or L"" */
+	wchar_t const * aDefaultPath); /* NULL or L"" */
+		/* returns NULL on cancel */
+
+/* windows only - utf-16 version */
+wchar_t * tinyfd_colorChooserW(
+	wchar_t const * aTitle, /* NULL or L"" */
+	wchar_t const * aDefaultHexRGB, /* NULL or L"#FF0000" */
+	unsigned char const aDefaultRGB[3], /* unsigned char lDefaultRGB[3] = { 0 , 128 , 255 }; */
+	unsigned char aoResultRGB[3]); /* unsigned char lResultRGB[3]; */
+		/* returns the hexcolor as a string L"#FF0000" */
+		/* aoResultRGB also contains the result */
+		/* aDefaultRGB is used only if aDefaultHexRGB is NULL */
+		/* aDefaultRGB and aoResultRGB can be the same array */
+		/* returns NULL on cancel */
+
+#endif /*_WIN32 */
+
+#ifdef	__cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /* TINYFILEDIALOGS_H */
+
+/*
+ ________________________________________________________________________________
+|  ____________________________________________________________________________  |
+| |                                                                            | |
+| | on windows:                                                                | |
+| |  - for UTF-16, use the wchar_t functions at the bottom of the header file  | |
+| |  - _wfopen() requires wchar_t                                              | |
+| |                                                                            | |
+| |  - in tinyfiledialogs, char is UTF-8 by default (since v3.6)               | |
+| |  - but fopen() expects MBCS (not UTF-8)                                    | |
+| |  - if you want char to be MBCS: set tinyfd_winUtf8 to 0                    | |
+| |                                                                            | |
+| |  - alternatively, tinyfiledialogs provides                                 | |
+| |                        functions to convert between UTF-8, UTF-16 and MBCS | |
+| |____________________________________________________________________________| |
+|________________________________________________________________________________|
+
+- This is not for ios nor android (it works in termux though).
+- The files can be renamed with extension ".cpp" as the code is 100% compatible C C++
+  (just comment out << extern "C" >> in the header file)
+- Windows is fully supported from XP to 10 (maybe even older versions)
+- C# & LUA via dll, see files in the folder EXTRAS
+- OSX supported from 10.4 to latest (maybe even older versions)
+- Do not use " and ' as the dialogs will be displayed with a warning
+  instead of the title, message, etc...
+- There's one file filter only, it may contain several patterns.
+- If no filter description is provided,
+  the list of patterns will become the description.
+- On windows link against Comdlg32.lib and Ole32.lib
+  (on windows the no linking claim is a lie)
+- On unix: it tries command line calls, so no such need (NO LINKING).
+- On unix you need one of the following:
+  applescript, kdialog, zenity, matedialog, shellementary, qarma, yad,
+  python (2 or 3)/tkinter/python-dbus (optional), Xdialog
+  or curses dialogs (opens terminal if running without console).
+- One of those is already included on most (if not all) desktops.
+- In the absence of those it will use gdialog, gxmessage or whiptail
+  with a textinputbox. If nothing is found, it switches to basic console input,
+  it opens a console if needed (requires xterm + bash).
+- for curses dialogs you must set tinyfd_allowCursesDialogs=1
+- You can query the type of dialog that will be used (pass "tinyfd_query" as aTitle)
+- String memory is preallocated statically for all the returned values.
+- File and path names are tested before return, they should be valid.
+- tinyfd_forceConsole=1; at run time, forces dialogs into console mode.
+- On windows, console mode only make sense for console applications.
+- On windows, console mode is not implemented for wchar_T UTF-16.
+- Mutiple selects are not possible in console mode.
+- The package dialog must be installed to run in curses dialogs in console mode.
+  It is already installed on most unix systems.
+- On osx, the package dialog can be installed via
+  http://macappstore.org/dialog or http://macports.org
+- On windows, for curses dialogs console mode,
+  dialog.exe should be copied somewhere on your executable path.
+  It can be found at the bottom of the following page:
+  http://andrear.altervista.org/home/cdialog.php
+*/

game.c

@@ -1,71 +0,0 @@
-#include <audio.h>
-#include <assets.h>
-#include <controller.h>
-#include <game.h>
-#include <SDL2/SDL.h>
-#include <stdbool.h>
-#include <time.h>
-
-typedef struct {
-    GraphicsContext *gfx;
-    AudioContext aud;
-    int16_t audioBuffer[834 * 2];
-} GameState;
-
-int onFrame(VB *sim) {
-    static uint8_t leftEye[384*224];
-    static uint8_t rightEye[384*224];
-    GameState *state;
-    void *samples;
-    uint32_t samplePairs;
-
-    state = vbGetUserData(sim);
-    
-    vbGetPixels(sim, leftEye, 1, 384, rightEye, 1, 384);
-    gfxUpdateLeftEye(state->gfx, leftEye);
-    gfxUpdateRightEye(state->gfx, rightEye);
-
-    samples = vbGetSamples(sim, NULL, &samplePairs);
-    audioUpdate(&state->aud, samples, samplePairs * 4);
-    vbSetSamples(sim, samples, 834);
-    gfxRender(state->gfx);
-    return 1;
-}
-
-#define MAX_STEP_CLOCKS 20000000
-
-int runGame(VB *sim, GraphicsContext *gfx) {
-    uint32_t clocks;
-    SDL_Event event;
-    GameState state;
-    ControllerState ctrl;
-
-    state.gfx = gfx;
-    audioInit(&state.aud);
-    vbSetSamples(sim, &state.audioBuffer, 834);
-    vbSetUserData(sim, &state);
-    vbSetFrameCallback(sim, &onFrame);
-
-    ctrlInit(&ctrl);
-
-    gfxUpdateLeftEye(gfx, LEFT_EYE_DEFAULT);
-    gfxUpdateRightEye(gfx, RIGHT_EYE_DEFAULT);
-
-    while (1) {
-        clocks = MAX_STEP_CLOCKS;
-        vbEmulate(sim, &clocks);
-
-        while (SDL_PollEvent(&event)) {
-            if (event.type == SDL_QUIT) {
-                return 0;
-            }
-            if (event.type == SDL_KEYDOWN) {
-                ctrlKeyDown(&ctrl, event.key.keysym.sym);
-            }
-            if (event.type == SDL_KEYUP) {
-                ctrlKeyUp(&ctrl, event.key.keysym.sym);
-            }
-        }
-        vbSetKeys(sim, ctrlKeys(&ctrl));
-    }
-}

game.h

@@ -1,9 +0,0 @@
-#ifndef SHROOMS_VB_NATIVE_GAME_
-#define SHROOMS_VB_NATIVE_GAME_
-
-#include "graphics.h"
-#include "shrooms-vb-core/core/vb.h"
-
-int runGame(VB *sim, GraphicsContext *gfx);
-
-#endif

graphics.c

@@ -1,92 +0,0 @@
-#include <graphics.h>
-
-static void copyScreenTexture(uint8_t *dst, const uint8_t *src, int pitch) {
-    int x, y, i;
-    uint8_t color;
-    int delta = pitch / 384;
-    for (y = 0; y < 224; ++y) {
-        for (x = 0; x < 384; x += 1) {
-            color = src[(y * 384) + x];
-            for (i = 0; i < delta; ++i) {
-                dst[(y * pitch) + (x * delta) + i] = color;
-            }
-        }
-    }
-}
-
-int gfxInit(GraphicsContext *gfx) {
-    gfx->window = SDL_CreateWindow("Shrooms VB",
-        SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
-        1536, 896, SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI);
-    if (!gfx->window) {
-        fprintf(stderr, "Error creating window: %s\n", SDL_GetError());
-        return 1;
-    }
-
-    gfx->renderer = SDL_CreateRenderer(gfx->window, -1, 0);
-    if (!gfx->renderer) {
-        fprintf(stderr, "Error creating renderer: %s\n", SDL_GetError());
-        goto cleanup_window;
-    }
-
-    gfx->winSurface = SDL_GetWindowSurface(gfx->window);
-    if (!gfx->winSurface) {
-        fprintf(stderr, "Error getting surface: %s\n", SDL_GetError());
-        goto cleanup_window;
-    }
-
-    gfx->leftEye = SDL_CreateTexture(gfx->renderer, SDL_PIXELFORMAT_RGB24, SDL_TEXTUREACCESS_STREAMING, 384, 224);
-    if (!gfx->leftEye) {
-        fprintf(stderr, "Error creating left eye texture: %s\n", SDL_GetError());
-        goto cleanup_window;
-    }
-    SDL_SetTextureColorMod(gfx->leftEye, 0xff, 0, 0);
-
-    gfx->rightEye = SDL_CreateTexture(gfx->renderer, SDL_PIXELFORMAT_RGB24, SDL_TEXTUREACCESS_STREAMING, 384, 224);
-    if (!gfx->rightEye) {
-        fprintf(stderr, "Error creating left eye texture: %s\n", SDL_GetError());
-        goto cleanup_left_eye;
-    }
-    SDL_SetTextureColorMod(gfx->rightEye, 0, 0xc6, 0xf0);
-    SDL_SetTextureBlendMode(gfx->rightEye, SDL_BLENDMODE_ADD);
-
-    return 0;
-
-cleanup_left_eye:
-    SDL_DestroyTexture(gfx->leftEye);
-cleanup_window:
-    SDL_DestroyWindow(gfx->window);
-    return 1;
-}
-
-void gfxDestroy(GraphicsContext *gfx) {
-    SDL_DestroyTexture(gfx->rightEye);
-    SDL_DestroyTexture(gfx->leftEye);
-    SDL_DestroyWindow(gfx->window);
-}
-
-static void gfxUpdateEye(SDL_Texture *eye, const uint8_t *bytes) {
-    void *target;
-    int pitch;
-    if (SDL_LockTexture(eye, NULL, &target, &pitch)) {
-        fprintf(stderr, "Error locking buffer for eye: %s\n", SDL_GetError());
-        return;
-    }
-    copyScreenTexture(target, bytes, pitch);
-    SDL_UnlockTexture(eye);
-}
-
-void gfxUpdateLeftEye(GraphicsContext *gfx, const uint8_t *bytes) {
-    gfxUpdateEye(gfx->leftEye, bytes);
-}
-void gfxUpdateRightEye(GraphicsContext *gfx, const uint8_t *bytes) {
-    gfxUpdateEye(gfx->rightEye, bytes);
-}
-
-void gfxRender(GraphicsContext *gfx) {
-    SDL_RenderClear(gfx->renderer);
-    SDL_RenderCopy(gfx->renderer, gfx->leftEye, NULL, NULL);
-    SDL_RenderCopy(gfx->renderer, gfx->rightEye, NULL, NULL);
-    SDL_RenderPresent(gfx->renderer);
-}
-

graphics.h

@@ -1,22 +0,0 @@
-#ifndef SHROOMS_VB_NATIVE_GRAPHICS_
-#define SHROOMS_VB_NATIVE_GRAPHICS_
-
-#include <SDL2/SDL.h>
-
-typedef struct {
-    SDL_Window *window;
-    SDL_Surface *winSurface;
-    SDL_Renderer *renderer;
-    SDL_Texture *leftEye;
-    SDL_Texture *rightEye;
-} GraphicsContext;
-
-int gfxInit(GraphicsContext *gfx);
-void gfxDestroy(GraphicsContext *gfx);
-
-void gfxUpdateLeftEye(GraphicsContext *gfx, const uint8_t *bytes);
-void gfxUpdateRightEye(GraphicsContext *gfx, const uint8_t *bytes);
-
-void gfxRender(GraphicsContext *gfx);
-
-#endif

main.c

@@ -1,85 +1,41 @@
-#include <cli.h>
-#include <game.h>
-#include <graphics.h>
+#include "cli.h"
 #include <SDL2/SDL.h>
-#include "shrooms-vb-core/core/vb.h"
+#include <stdbool.h>
 #include <stdio.h>
-
-uint8_t *readROM(char *filename, uint32_t *size) {
-    FILE *file = fopen(filename, "rb");
-    uint8_t *rom;
-    long filesize;
-
-    if (!file) {
-        perror("could not open file");
-        return NULL;
-    }
-
-    if (fseek(file, 0, SEEK_END)) {
-        perror("could not seek file end");
-        return NULL;
-    }
-    filesize = ftell(file);
-    if (filesize == -1) {
-        perror("could not read file size");
-        return NULL;
-    }
-    if (fseek(file, 0, SEEK_SET)) {
-        perror("could not seek file start");
-        return NULL;
-    }
-
-    *size = (uint32_t) filesize;
-    rom = malloc(*size);
-    if (!rom) {
-        perror("could not allocate ROM");
-        return NULL;
-    }
-    fread(rom, 1, *size, file);
-    if (ferror(file)) {
-        perror("could not read file");
-        return NULL;
-    }
-    if (fclose(file)) {
-        perror("could not close file");
-        return NULL;
-    }
-
-    return rom;
-}
+#include "ui.h"
 
 int main(int argc, char **argv) {
-    VB *sim;
-    uint8_t *rom;
-    uint32_t romSize;
-    GraphicsContext gfx;
     CLIArgs args;
+    UIContext *ui;
     int status;
+    bool running = false;
 
     if (parseCLIArgs(argc, argv, &args)) {
         return 1;
     }
 
-    rom = readROM(args.filename, &romSize);
-    if (!rom) {
-        return 1;
-    }
-
-    sim = malloc(vbSizeOf());
-    vbInit(sim);
-    vbSetCartROM(sim, rom, romSize);
-
+    SDL_SetHint(SDL_HINT_VIDEO_HIGHDPI_DISABLED, "0");
+    SDL_SetHint(SDL_HINT_WINDOWS_DPI_AWARENESS, "system");
     if (SDL_Init(SDL_INIT_EVERYTHING)) {
         fprintf(stderr, "Error initializing SDL: %s\n", SDL_GetError());
         return 1;
     }
 
-    if (gfxInit(&gfx)) {
+    ui = uiInit();
+    if (!ui) {
         SDL_Quit();
         return 1;
     }
 
-    status = runGame(sim, &gfx);
+    if (args.filename) {
+        if (uiLoadGame(ui, args.filename)) {
+            return 1;
+        }
+        running = true;
+    }
+
+    status = uiRun(ui, running);
+    uiDestroy(ui);
     SDL_Quit();
     return status;
 }

makefile

@@ -1,13 +1,12 @@
 CC?=gcc
 LD?=ld
-SHROOMSFLAGS=shrooms-vb-core/core/vb.c -I shrooms-vb-core/core
 msys_version := $(if $(findstring Msys, $(shell uname -o)),$(word 1, $(subst ., ,$(shell uname -r))),0)
 
 ifeq ($(msys_version), 0)
-SDL2FLAGS=$(shell pkg-config sdl2 --cflags --libs)
+PKGFLAGS=$(shell pkg-config sdl2 --cflags --libs)
 BINLINKFLAGS=-z noexecstack
 else
-SDL2FLAGS=$(shell pkg-config sdl2 --cflags --libs) -mwindows -mconsole
+PKGFLAGS=$(shell pkg-config sdl2 --cflags --libs) -mwindows -mconsole -lcomdlg32 -lole32
 BINLINKFLAGS=
 endif
 
@@ -19,23 +18,30 @@ CFILES := $(foreach dir,./,$(notdir $(wildcard $(dir)/*.c)))
 BINFILES := $(foreach dir,assets/,$(notdir $(wildcard $(dir)/*.bin)))
 
 COBJS := $(CFILES:%.c=output/%.o)
-SHROOMSOBJS := output/vb.o
+EXTOBJS = output/vb.o output/tinyfiledialogs.o
 BINOBJS := $(BINFILES:%.bin=output/%.o)
 
-OFILES := $(COBJS) $(SHROOMSOBJS) $(BINOBJS)
+OFILES := $(COBJS) $(EXTOBJS) $(BINOBJS)
 
 output/%.o: %.c
 	@mkdir -p output
 	@$(CC) -c -o $@ $< -I . \
-		-I shrooms-vb-core/core $(SDL2FLAGS) \
-		-O3 -flto -fno-strict-aliasing \
+		-I shrooms-vb-core/core $(PKGFLAGS) \
+		-O3 -flto=auto -Wno-long-long \
 		-Werror -std=c90 -Wall -Wextra -Wpedantic
 
 output/vb.o: shrooms-vb-core/core/vb.c
 	@mkdir -p output
 	@$(CC) -c -o $@ $< -I . \
-		-I shrooms-vb-core/core $(SDL2FLAGS) \
-		-O3 -flto -fno-strict-aliasing \
+		-I shrooms-vb-core/core \
+		-O3 -flto=auto -fno-strict-aliasing \
+		-Werror -std=c90 -Wall -Wextra -Wpedantic
+
+output/tinyfiledialogs.o: external/tinyfiledialogs.c
+	@mkdir -p output
+	@$(CC) -c -o $@ $< -I . \
+		-I external \
+		-O3 -flto=auto -fno-strict-aliasing -Wno-cast-function-type \
 		-Werror -std=c90 -Wall -Wextra -Wpedantic
 
 output/%.o: assets/%.bin
@@ -43,6 +49,6 @@ output/%.o: assets/%.bin
 	@$(LD) -r -b binary $(BINLINKFLAGS) -o $@ $<
 
 shrooms-vb: $(OFILES)
-	@$(CC) -o $@ $(OFILES) $(SDL2FLAGS) -flto
+	@$(CC) -o $@ $(OFILES) $(PKGFLAGS) -lm -flto=auto
 
 build: shrooms-vb

nuklear.c

@@ -0,0 +1,3 @@
+#define NK_IMPLEMENTATION
+#define NK_SDL_RENDERER_IMPLEMENTATION
+#include "nuklear.h"

nuklear.h

@@ -0,0 +1,17 @@
+#ifndef SHROOMS_VB_NATIVE_NUKLEAR_
+#define SHROOMS_VB_NATIVE_NUKLEAR_
+
+#define NK_INCLUDE_FIXED_TYPES
+#define NK_INCLUDE_STANDARD_BOOL
+#define NK_INCLUDE_STANDARD_IO
+#define NK_INCLUDE_STANDARD_VARARGS
+#define NK_INCLUDE_DEFAULT_ALLOCATOR
+#define NK_INCLUDE_VERTEX_BUFFER_OUTPUT
+#define NK_INCLUDE_FONT_BAKING
+#define NK_INCLUDE_DEFAULT_FONT
+#include "external/nuklear.h"
+
+#define NK_SDL_RENDERER_SDL_H <SDL2/SDL.h>
+#include "external/nuklear_sdl_renderer.h"
+
+#endif

shrooms-vb-core

@@ -1 +1 @@
-Subproject commit bcd80d291b1be0e334bd5da481ca69211b16e6b0
+Subproject commit ae22c95dbee3d0b338168bfdf98143e6eddc6c70

ui.c

@@ -0,0 +1,218 @@
+#include "audio.h"
+#include "controller.h"
+#include "emulation.h"
+#include "external/tinyfiledialogs.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include "ui.h"
+#include "window.h"
+
+struct UIContext {
+    EmulationContext emu;
+    WindowContext win;
+    AudioContext aud;
+    ControllerState ctrl;
+};
+
+UIContext *uiInit() {
+    UIContext *ui = malloc(sizeof(UIContext));
+    if (emuInit(&ui->emu)) {
+        goto destroy_ui;
+    }
+    if (windowInit(&ui->win, "Shrooms VB")) {
+        goto destroy_emu;
+    }
+    if (audioInit(&ui->aud)) {
+        goto destroy_window;
+    }
+    ctrlInit(&ui->ctrl);
+    return ui;
+
+destroy_window:
+    windowDestroy(&ui->win);
+destroy_emu:
+    emuDestroy(&ui->emu);
+destroy_ui:
+    free(ui);
+    return NULL;
+}
+
+void uiDestroy(UIContext *ui) {
+    audioDestroy(&ui->aud);
+    windowDestroy(&ui->win);
+    emuDestroy(&ui->emu);
+    free(ui);
+}
+
+int uiLoadGame(UIContext *ui, const char *path) {
+    FILE *file = fopen(path, "rb");
+    uint8_t *rom = NULL;
+    long fileSize;
+    uint32_t romSize;
+    int result;
+
+    if (!file) {
+        perror("could not open file");
+        return -1;
+    }
+
+    if (fseek(file, 0, SEEK_END)) {
+        perror("could not seek file end");
+        goto close_file;
+    }
+    fileSize = ftell(file);
+    if (fileSize == -1) {
+        perror("could not read file size");
+        goto close_file;
+    }
+    if (fseek(file, 0, SEEK_SET)) {
+        perror("could not seek file start");
+        goto close_file;
+    }
+    romSize = (uint32_t) fileSize;
+
+    rom = malloc(romSize);
+    if (!rom) {
+        perror("could not allocate ROM");
+        goto close_file;
+    }
+    fread(rom, 1, romSize, file);
+    if (ferror(file)) {
+        perror("could not read file");
+        goto free_rom;
+    }
+    result = fclose(file);
+    file = NULL;
+    if (result) {
+        perror("could not close file");
+        goto free_rom;
+    }
+
+    emuLoadGame(&ui->emu, rom, romSize);
+    return 0;
+
+free_rom:
+    free(rom);
+close_file:
+    if (file) fclose(file);
+    return -1;
+}
+
+static const char *MENU_ITEMS[4] = {
+    "File",
+    "Emulation",
+    "Video",
+    NULL
+};
+
+static const char *ROM_EXTENSIONS[2] = {
+    "*.vb",
+    NULL
+};
+
+typedef enum status_t {
+    status_paused,
+    status_running
+} status_t;
+
+int uiRun(UIContext *ui, bool running) {
+    static uint8_t leftEye[384*224] = {0};
+    static uint8_t rightEye[384*224] = {0};
+    status_t status = running ? status_running : status_paused;
+    windowUpdate(&ui->win, leftEye, rightEye);
+
+    while (1) {
+        struct nk_context *ctx;
+        SDL_Event event;
+        void *samples;
+        uint32_t bytes;
+        ctx = ui->win.nk;
+
+        if (status == status_running) {
+            emuTick(&ui->emu);
+        }
+
+        if (emuReadPixels(&ui->emu, leftEye, rightEye)) {
+            windowUpdate(&ui->win, leftEye, rightEye);
+        }
+        emuReadSamples(&ui->emu, &samples, &bytes);
+        if (bytes) {
+            audioUpdate(&ui->aud, samples, bytes);
+        }
+
+        windowDisplayBegin(&ui->win);
+        /* GUI */
+        if (windowGuiBegin(&ui->win, "Shrooms VB")) {
+            windowMenubarBegin(&ui->win, MENU_ITEMS);
+
+            if (windowMenuBegin(&ui->win, "File", 100)) {
+                if (windowMenuItemLabel(&ui->win, "Open ROM")) {
+                    char *file = tinyfd_openFileDialog("Pick a ROM", NULL, 1, ROM_EXTENSIONS, "Virtual Boy ROM files", false);
+                    if (file) {
+                        uiLoadGame(ui, file);
+                        status = status_running;
+                    }
+                }
+                if (windowMenuItemLabel(&ui->win, "Quit")) {
+                    SDL_Event QuitEvent;
+                    QuitEvent.type = SDL_QUIT;
+                    QuitEvent.quit.timestamp = SDL_GetTicks();
+                    SDL_PushEvent(&QuitEvent);
+                }
+                windowMenuEnd(&ui->win);
+            }
+
+            if (windowMenuBegin(&ui->win, "Emulation", 100)) {
+                const char *label = status == status_paused ? "Resume" : "Pause";
+                if (windowMenuItemLabel(&ui->win, label)) {
+                    if (status == status_paused)
+                        status = status_running;
+                    else
+                        status = status_paused;
+                }
+                if (windowMenuItemLabel(&ui->win, "Reset")) {
+                    emuReset(&ui->emu);
+                    status = emuIsGameLoaded(&ui->emu) ? status_running : status_paused;
+                }
+                windowMenuEnd(&ui->win);
+            }
+
+            if (windowMenuBegin(&ui->win, "Video", 100)) {
+                float multiplier = windowGetScreenSizeMultiplier(&ui->win);
+                if (windowMenuItemLabelChecked(&ui->win, "x1", multiplier == 1.0f)) {
+                    windowSetScreenSizeMultiplier(&ui->win, 1.0f);
+                }
+                if (windowMenuItemLabelChecked(&ui->win, "x2", multiplier == 2.0f)) {
+                    windowSetScreenSizeMultiplier(&ui->win, 2.0f);
+                }
+                if (windowMenuItemLabelChecked(&ui->win, "x3", multiplier == 3.0f)) {
+                    windowSetScreenSizeMultiplier(&ui->win, 3.0f);
+                }
+                if (windowMenuItemLabelChecked(&ui->win, "x4", multiplier == 4.0f)) {
+                    windowSetScreenSizeMultiplier(&ui->win, 4.0f);
+                }
+                windowMenuEnd(&ui->win);
+            }
+
+            windowMenubarEnd(&ui->win);
+        }
+        windowGuiEnd(&ui->win);
+        windowDisplayEnd(&ui->win);
+
+        nk_input_begin(ctx);
+        while (SDL_PollEvent(&event)) {
+            nk_sdl_handle_event(&event);
+            if (event.type == SDL_QUIT) {
+                return 0;
+            }
+            if (event.type == SDL_KEYDOWN) {
+                ctrlKeyDown(&ui->ctrl, event.key.keysym.sym);
+            }
+            if (event.type == SDL_KEYUP) {
+                ctrlKeyUp(&ui->ctrl, event.key.keysym.sym);
+            }
+        }
+        nk_input_end(ctx);
+        emuSetKeys(&ui->emu, ctrlKeys(&ui->ctrl));
+    }
+}

ui.h

@@ -0,0 +1,13 @@
+#ifndef SHROOMS_VB_NATIVE_UI_
+#define SHROOMS_VB_NATIVE_UI_
+
+#include <stdbool.h>
+
+typedef struct UIContext UIContext;
+
+UIContext *uiInit();
+void uiDestroy(UIContext *ui);
+int uiLoadGame(UIContext *ui, const char *path);
+int uiRun(UIContext *ui, bool running);
+
+#endif

window.c

@@ -0,0 +1,291 @@
+#include "assets.h"
+#include "nuklear.h"
+#include <string.h>
+#include "window.h"
+
+#define MENU_HEIGHT 20
+#define SCREEN_WIDTH 384
+#define SCREEN_HEIGHT 224
+
+static void setColorTable(struct nk_color *table) {
+    table[NK_COLOR_TEXT] = nk_rgb(40, 40, 40);
+    table[NK_COLOR_WINDOW] = nk_rgb(255, 255, 255);
+    table[NK_COLOR_HEADER] = nk_rgb(40, 40, 40);
+    table[NK_COLOR_BORDER] = nk_rgb(175, 175, 175);
+    table[NK_COLOR_BUTTON] = nk_rgb(255, 255, 255);
+    table[NK_COLOR_BUTTON_HOVER] = nk_rgb(215, 215, 215);
+    table[NK_COLOR_BUTTON_ACTIVE] = nk_rgb(175, 175, 175);
+    table[NK_COLOR_TOGGLE] = nk_rgb(100, 100, 100);
+    table[NK_COLOR_TOGGLE_HOVER] = nk_rgb(120, 120, 120);
+    table[NK_COLOR_TOGGLE_CURSOR] = nk_rgb(45, 45, 45);
+    table[NK_COLOR_SELECT] = nk_rgb(45, 45, 45);
+    table[NK_COLOR_SELECT_ACTIVE] = nk_rgb(35, 35, 35);
+    table[NK_COLOR_SLIDER] = nk_rgb(38, 38, 38);
+    table[NK_COLOR_SLIDER_CURSOR] = nk_rgb(100, 100, 100);
+    table[NK_COLOR_SLIDER_CURSOR_HOVER] = nk_rgb(120, 120, 120);
+    table[NK_COLOR_SLIDER_CURSOR_ACTIVE] = nk_rgb(150, 150, 150);
+    table[NK_COLOR_PROPERTY] = nk_rgb(38, 38, 38);
+    table[NK_COLOR_EDIT] = nk_rgb(38, 38, 38);
+    table[NK_COLOR_EDIT_CURSOR] = nk_rgb(175, 175, 175);
+    table[NK_COLOR_COMBO] = nk_rgb(45, 45, 45);
+    table[NK_COLOR_CHART] = nk_rgb(120, 120, 120);
+    table[NK_COLOR_CHART_COLOR] = nk_rgb(45, 45, 45);
+    table[NK_COLOR_CHART_COLOR_HIGHLIGHT] = nk_rgb(255, 0, 0);
+    table[NK_COLOR_SCROLLBAR] = nk_rgb(40, 40, 40);
+    table[NK_COLOR_SCROLLBAR_CURSOR] = nk_rgb(100, 100, 100);
+    table[NK_COLOR_SCROLLBAR_CURSOR_HOVER] = nk_rgb(120, 120, 120);
+    table[NK_COLOR_SCROLLBAR_CURSOR_ACTIVE] = nk_rgb(150, 150, 150);
+    table[NK_COLOR_TAB_HEADER] = nk_rgb(40, 40, 40);
+    table[NK_COLOR_KNOB] = nk_rgb(38, 38, 38);
+    table[NK_COLOR_KNOB_CURSOR] = nk_rgb(100, 100, 100);
+    table[NK_COLOR_KNOB_CURSOR_HOVER] = nk_rgb(120, 120, 120);
+    table[NK_COLOR_KNOB_CURSOR_ACTIVE] = nk_rgb(150, 150, 150);
+}
+
+static void applyStyles(struct nk_context *ctx, float scaleX, float scaleY) {
+    struct nk_color table[NK_COLOR_COUNT];
+    setColorTable(table);
+    nk_style_from_table(ctx, table);
+    ctx->style.window.padding = nk_vec2(0, 0);
+    ctx->style.window.spacing = nk_vec2(0, 0);
+    ctx->style.window.menu_padding = nk_vec2(0, 0);
+    ctx->style.window.menu_border = 0;
+
+    ctx->style.menu_button.hover = nk_style_item_color(table[NK_COLOR_BUTTON_HOVER]);
+    ctx->style.menu_button.active = nk_style_item_color(table[NK_COLOR_BUTTON_ACTIVE]);
+    ctx->style.menu_button.padding = nk_vec2(2 * scaleX, 2 * scaleY);
+    ctx->style.contextual_button.padding = nk_vec2(20 * scaleX, 4 * scaleY);
+}
+
+/* scale the window for High-DPI displays */
+static void scaleWindow(WindowContext *win) {
+    int renderW, renderH;
+    int oldWindowX, oldWindowY;
+    int newWindowX, newWindowY;
+    int oldWindowW, oldWindowH;
+    int newWindowW, newWindowH;
+    float scaleX, scaleY;
+    float hdpi, vdpi;
+    SDL_GetRendererOutputSize(win->renderer, &renderW, &renderH);
+    SDL_GetWindowPosition(win->window, &oldWindowX, &oldWindowY);
+    SDL_GetWindowSize(win->window, &oldWindowW, &oldWindowH);
+    SDL_GetDisplayDPI(SDL_GetWindowDisplayIndex(win->window), NULL, &hdpi, &vdpi);
+    scaleX = (float)(renderW) / (float)(oldWindowW);
+    scaleY = (float)(renderH) / (float)(oldWindowH);
+    win->screenScaleX = (hdpi / 96) * scaleX;
+    win->screenScaleY = (vdpi / 96) * scaleY;
+
+    newWindowW = SCREEN_WIDTH * win->screenSizeMultiplier * (hdpi / 96) / scaleX;
+    newWindowH = (SCREEN_HEIGHT * win->screenSizeMultiplier + MENU_HEIGHT) * (vdpi / 96) / scaleY;
+    newWindowX = oldWindowX - (newWindowW - oldWindowW) / 2;
+    newWindowY = oldWindowY - (newWindowH - oldWindowH) / 2;
+    if (newWindowX < 0) newWindowX = 0;
+    if (newWindowY < 0) newWindowY = 0;
+    SDL_SetWindowSize(win->window, newWindowW, newWindowH);
+    SDL_SetWindowPosition(win->window, newWindowX, newWindowY);
+}
+
+int windowInit(WindowContext *win, const char *title) {
+    win->screenSizeMultiplier = 1.0f;
+
+    win->window = SDL_CreateWindow(title,
+        SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+        SCREEN_WIDTH, SCREEN_HEIGHT + MENU_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI);
+    if (!win->window) {
+        fprintf(stderr, "Error creating window: %s\n", SDL_GetError());
+        return -1;
+    }
+
+    win->renderer = SDL_CreateRenderer(win->window, -1, 0);
+    if (!win->renderer) {
+        fprintf(stderr, "Error creating renderer: %s\n", SDL_GetError());
+        goto cleanup_window;
+    }
+
+    win->leftEye = SDL_CreateTexture(win->renderer, SDL_PIXELFORMAT_RGB24, SDL_TEXTUREACCESS_STREAMING, 384, 224);
+    if (!win->leftEye) {
+        fprintf(stderr, "Error creating left eye texture: %s\n", SDL_GetError());
+        goto cleanup_renderer;
+    }
+    SDL_SetTextureColorMod(win->leftEye, 0xff, 0, 0);
+
+    win->rightEye = SDL_CreateTexture(win->renderer, SDL_PIXELFORMAT_RGB24, SDL_TEXTUREACCESS_STREAMING, 384, 224);
+    if (!win->rightEye) {
+        fprintf(stderr, "Error creating right eye texture: %s\n", SDL_GetError());
+        goto cleanup_left_eye;
+    }
+    SDL_SetTextureColorMod(win->rightEye, 0, 0xc6, 0xf0);
+    SDL_SetTextureBlendMode(win->rightEye, SDL_BLENDMODE_ADD);
+
+    scaleWindow(win);
+
+    win->nk = nk_sdl_init(win->window, win->renderer);
+    applyStyles(win->nk, win->screenScaleX, win->screenScaleY);
+    /* tell nuklear the mouse moved somewhere so it doesn't think we're hovering in the top left */
+    nk_input_motion(win->nk, 1024, 1024);
+
+    {
+        struct nk_font_atlas *atlas;
+        struct nk_font_config config = nk_font_config(0);
+        config.pixel_snap = 1;
+        config.oversample_h = 8;
+        config.oversample_v = 8;
+        
+        nk_sdl_font_stash_begin(&atlas);
+        win->font = nk_font_atlas_add_from_memory(atlas, (void*) SELAWIK, SELAWIK_LEN, 13 * win->screenScaleY, &config);
+        nk_sdl_font_stash_end();
+
+        nk_style_set_font(win->nk, &win->font->handle);
+    }
+
+    return 0;
+
+cleanup_left_eye:
+    SDL_DestroyTexture(win->leftEye);
+cleanup_renderer:
+    SDL_DestroyRenderer(win->renderer);
+cleanup_window:
+    SDL_DestroyWindow(win->window);
+    return -1;
+}
+
+void windowDestroy(WindowContext *win) {
+    SDL_DestroyTexture(win->rightEye);
+    SDL_DestroyTexture(win->leftEye);
+    SDL_DestroyRenderer(win->renderer);
+    SDL_DestroyWindow(win->window);
+}
+
+float windowGetScreenSizeMultiplier(WindowContext *win) {
+    return win->screenSizeMultiplier;
+}
+
+void windowSetScreenSizeMultiplier(WindowContext *win, float multiplier) {
+    win->screenSizeMultiplier = multiplier;
+    scaleWindow(win);
+    applyStyles(win->nk, win->screenScaleX, win->screenScaleY);
+}
+
+static void copyScreenTexture(uint8_t *dst, const uint8_t *src, int pitch) {
+    int x, y, i;
+    uint8_t color;
+    int delta = pitch / 384;
+    for (y = 0; y < 224; ++y) {
+        for (x = 0; x < 384; x += 1) {
+            color = src[(y * 384) + x];
+            for (i = 0; i < delta; ++i) {
+                dst[(y * pitch) + (x * delta) + i] = color;
+            }
+        }
+    }
+}
+
+static void updateEye(SDL_Texture *eye, const uint8_t *bytes) {
+    void *target;
+    int pitch;
+    if (SDL_LockTexture(eye, NULL, &target, &pitch)) {
+        fprintf(stderr, "Error locking buffer for eye: %s\n", SDL_GetError());
+        return;
+    }
+    copyScreenTexture(target, bytes, pitch);
+    SDL_UnlockTexture(eye);
+}
+
+void windowUpdate(WindowContext *win, const uint8_t *left, const uint8_t *right) {
+    updateEye(win->leftEye, left);
+    updateEye(win->rightEye, right);
+}
+
+int windowScaleX(WindowContext *win, int x) {
+    return x * win->screenScaleX;
+}
+
+int windowScaleY(WindowContext *win, int y) {
+    return y * win->screenScaleY;
+}
+
+int windowGetMenuHeight(WindowContext *win) {
+    return (MENU_HEIGHT + 2) * win->screenScaleY;
+}
+
+int windowGetScreenHeight(WindowContext *win) {
+    return SCREEN_HEIGHT * win->screenSizeMultiplier * win->screenScaleY;
+}
+
+void windowDisplayBegin(WindowContext *win) {
+    SDL_Rect dst;
+    dst.x = 0;
+    dst.y = MENU_HEIGHT * win->screenScaleY;
+    dst.w = SCREEN_WIDTH * win->screenSizeMultiplier * win->screenScaleX;
+    dst.h = SCREEN_HEIGHT * win->screenSizeMultiplier * win->screenScaleY;
+
+    SDL_RenderClear(win->renderer);
+    SDL_RenderCopy(win->renderer, win->leftEye, NULL, &dst);
+    SDL_RenderCopy(win->renderer, win->rightEye, NULL, &dst);
+}
+
+void windowDisplayEnd(WindowContext *win) {
+    nk_sdl_render(NK_ANTI_ALIASING_ON);
+    SDL_RenderPresent(win->renderer);
+}
+
+bool windowGuiBegin(WindowContext *win, const char *title) {
+    return nk_begin(win->nk, title,
+        nk_rect(0, 0, SCREEN_WIDTH * win->screenSizeMultiplier * win->screenScaleX, MENU_HEIGHT * win->screenScaleY),
+        NK_WINDOW_NO_SCROLLBAR | NK_WINDOW_BACKGROUND);
+}
+
+void windowGuiEnd(WindowContext *win) {
+    nk_end(win->nk);
+}
+
+void windowMenubarBegin(WindowContext *win, const char **items) {
+    const char **item;
+    nk_menubar_begin(win->nk);
+    nk_layout_row_template_begin(win->nk, MENU_HEIGHT * win->screenScaleY);
+    for (item = items; *item != NULL; item++) {
+        struct nk_user_font *handle;
+        int len;
+        float width;
+        handle = &win->font->handle;
+        len = nk_strlen(*item);
+        width = handle->width(handle->userdata, handle->height, *item, len) + (16 * win->screenScaleX);
+        nk_layout_row_template_push_static(win->nk, width);
+    }
+    nk_layout_row_template_end(win->nk);
+}
+
+void windowMenubarEnd(WindowContext *win) {
+    nk_menubar_end(win->nk);
+}
+
+bool windowMenuBegin(WindowContext *win, const char *label, int width) {
+    if (!nk_menu_begin_label(win->nk, label, NK_TEXT_ALIGN_CENTERED, nk_vec2(windowScaleX(win, width), windowGetScreenHeight(win)))) {
+        return false;
+    }
+    nk_layout_row_dynamic(win->nk, windowGetMenuHeight(win), 1);
+    return true;
+}
+
+void windowMenuEnd(WindowContext *win) {
+    nk_menu_end(win->nk);
+}
+
+bool windowMenuItemLabel(WindowContext *win, const char *label) {
+    return nk_menu_item_label(win->nk, label, NK_TEXT_ALIGN_LEFT);
+}
+
+bool windowMenuItemLabelChecked(WindowContext *win, const char *label, bool checked) {
+    char buffer[80];
+    bool result;
+    if (!checked) {
+        return windowMenuItemLabel(win, label);
+    }
+    strcpy(buffer, "  *  ");
+    strncpy(buffer + 5, label, 74);
+    buffer[79] = '\0';
+    nk_style_push_vec2(win->nk, &win->nk->style.contextual_button.padding, nk_vec2(4 * win->screenScaleX, 4 * win->screenScaleY));
+    result = nk_menu_item_label(win->nk, buffer, NK_TEXT_ALIGN_LEFT);
+    nk_style_pop_vec2(win->nk);
+    return result;
+}

window.h

@@ -0,0 +1,41 @@
+#ifndef SHROOMS_VB_NATIVE_WINDOW_
+#define SHROOMS_VB_NATIVE_WINDOW_
+
+#include <SDL2/SDL.h>
+#include "nuklear.h"
+
+typedef struct WindowContext {
+    SDL_Window *window;
+    float screenSizeMultiplier;
+    float screenScaleX, screenScaleY;
+    SDL_Renderer *renderer;
+    SDL_Texture *leftEye;
+    SDL_Texture *rightEye;
+    struct nk_context *nk;
+    struct nk_font *font;
+} WindowContext;
+
+int windowInit(WindowContext *win, const char *title);
+void windowDestroy(WindowContext *win);
+
+float windowGetScreenSizeMultiplier(WindowContext *win);
+void windowSetScreenSizeMultiplier(WindowContext *win, float multiplier);
+void windowUpdate(WindowContext *win, const uint8_t *left, const uint8_t *right);
+
+int windowScaleX(WindowContext *win, int x);
+int windowScaleY(WindowContext *win, int y);
+int windowGetMenuHeight(WindowContext *win);
+int windowGetScreenHeight(WindowContext *win);
+
+void windowDisplayBegin(WindowContext *win);
+void windowDisplayEnd(WindowContext *win);
+bool windowGuiBegin(WindowContext *win, const char *title);
+void windowGuiEnd(WindowContext *win);
+void windowMenubarBegin(WindowContext *win, const char **items);
+void windowMenubarEnd(WindowContext *win);
+bool windowMenuBegin(WindowContext *win, const char *label, int width);
+void windowMenuEnd(WindowContext *win);
+bool windowMenuItemLabel(WindowContext *win, const char *label);
+bool windowMenuItemLabelChecked(WindowContext *win, const char *label, bool checked);
+
+#endif