initial commit

.gitignore

@@ -0,0 +1,3 @@
+.vscode/
+.DS_Store
+build/Bytepusher++

build/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

click.toml

@@ -0,0 +1,11 @@
+name        = "Bytepusher++"
+compiler    = "g++"
+extensions  = [".cpp"]
+outputDir   = "build"
+auxOutput   = true
+ignoreDirs  = [".vscode"]
+ignoreFiles = []
+flags       = ["-Wall", "-std=c++17", "`sdl2-config --cflags --libs`"]
+libs        = []
+includes    = ["include", "lib/imgui/include", "lib/ImGuiFileDialog"]
+linkDirs    = []

include/audio.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+/**
+ * The Bytepusher's audio device. 8-bit mono sound with 256 samples
+ * per frame, their location in memory being indicated by bytes 6
+ * and 7 in the memory map.
+ * With the audio I largely helped myself with David Jolly's (majestic53)
+ * implementation `bpvm` which you can find on his GitHub. Thanks David!
+ */
+
+#include <stdlib.h>
+#include <SDL2/SDL.h>
+
+class Bus;
+
+class Audio {
+public:
+    Audio(Bus* bus);
+    ~Audio();
+
+    void Play();
+private:
+    Bus* bus;
+    SDL_AudioSpec spec;
+    SDL_AudioDeviceID device;
+};

include/bus.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+/**
+ * A simple "system bus" which allows for interconnection between
+ * components, saving us passing pointers or references to each
+ * other every function call.
+ */
+
+class CPU;
+class Display;
+class Audio;
+class Memory;
+class Input;
+
+class Bus {
+public:
+    Bus();
+    ~Bus();
+
+    Memory*  memory;
+    CPU*     cpu;
+    Display* display;
+    Audio*   audio;
+    Input*   input;
+};

include/cpu.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+/**
+ * The Bytepusher's CPU, powered by a OISC (one instruction-set computer)
+ * called ByteByteJump. During an instruction, the CPU reads in three 3-byte values
+ * from memory (pointed to by the PC, program counter) A, B, and C. It then performs two steps,
+ * 1. copy the value from memory[A] to memory[B],
+ * 2. set the PC to C.
+ */
+
+#include <iostream>
+#include "memory.hpp"
+
+class Bus;
+
+class CPU {
+public:
+    CPU(Bus* bus);
+    ~CPU();
+
+    void Step();
+    void Reset();
+    void setKeyBit(uint8_t index);
+    void clearKeyBit(uint8_t index);
+
+private:
+    Bus* bus;
+    uint8_t* pc;
+};

include/display.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+/**
+ * The Bytepusher has a display of dimensions 256 x 256,
+ * 1 byte per pixel (we scale it to 512x512 anyway). That makes
+ * the display data 65 536 bytes large. The location of that display
+ * data is indicated by byte 5 in the memory map.
+ * The color palette has 216 colors, leaving the remaining 256-216=40 colors
+ * simply black.
+ * Each color is a combination of red, green, and blue, of which each
+ * can have an intensity from 0 to 5. That makes the increment 0x33:
+ * 
+ * ---------------------------------------------------------
+ * intensity || 0    || 1    || 2    || 3    || 4    || 5
+ * value     || 0x00 || 0x33 || 0x66 || 0x99 || 0xCC || 0xFF
+ * ---------------------------------------------------------
+ */
+
+#include <SDL2/SDL.h>
+class Bus;
+
+class Display {
+public:
+    Display(Bus* bus, SDL_Renderer* ren);
+    ~Display();
+
+    void PrepareColorPalette();
+    void UpdateTexture();
+    void Reset();
+
+    SDL_Texture* displayTexture;
+
+    static const int width = 256;
+    static const int height = 256;
+    SDL_Color display[width * height];
+    
+private:
+    Bus* bus;
+    SDL_Color colorPalette[256];
+};

include/input.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+/**
+ * The Bytepusher's controller consists of 16 keys
+ * in a 4x4 keyboard labelled 0-F;
+ * 
+ * 1 (1) || 2 (2) || 3 (3) || C (4)
+ * --------------------------------
+ * 4 (Q) || 5 (W) || 6 (E) || D (R)
+ * --------------------------------
+ * 7 (A) || 8 (S) || 9 (D) || E (F)
+ * --------------------------------
+ * A (Z) || 0 (X) || B (C) || C (V)
+ * 
+ * whose states correspond to those of their respective
+ * bits in the first two bytes of memory. The actual
+ * keyboard state can be seen in the debug window.
+ */
+
+#include <SDL2/SDL.h>
+
+class Bus;
+
+class Input {
+public:
+    Input(Bus* bus);
+    ~Input();
+
+    void HandleKeyDown(SDL_Keycode keycode);
+    void HandleKeyUp(SDL_Keycode keycode);
+    void SetKeyBit(uint8_t bit);
+    void UnsetKeyBit(uint8_t bit);
+
+private:
+    Bus* bus;
+};

include/memory.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+/**
+ * The memory of the Bytepusher. 16 MiB (0x1000008 bytes).
+ * The memory map is located at the beginning of memory and
+ * looks like this:
+ * 
+ * memory (byte) | description
+ * --------------|----------------
+ * 0, 1          | Keyboard state, if key X is
+ *               | pressed then bit X is on
+ *               |
+ * 2, 3, 4       | The program counter starts here
+ *               |
+ * 5             | Graphics block location. A value
+ *               | of ZZ means color of pixel at coordinate (XX, YY)
+ *               | is at ZZYYXX
+ *               |
+ * 6, 7          | Sound block location. A value of XXYY
+ *               | means audio sample ZZ is at address XXYY
+ * -------------------------------
+ * The byte ordering used by Bytepusher is big-endian.
+ */
+
+#include <stdlib.h>
+#include <string>
+class Bus;
+
+class Memory {
+public:
+    Memory(Bus* bus);
+    ~Memory();
+
+    static const size_t MEMORY_SIZE = 0x1000008;
+    uint8_t             mem[MEMORY_SIZE];
+    bool                ROMLoaded;
+    std::string         ROMFilepath;
+    size_t              ROMSize;
+    std::string         ROMLoadError;
+    std::string         snapshotError;
+    std::string         snapshotLast;
+
+
+    void Reset();
+    bool LoadROM(std::string filepath);
+    bool SnapshotRAM(std::string filepath);
+private:
+    Bus* bus;
+};

lib/imgui/include/imconfig.h

@@ -0,0 +1,123 @@
+//-----------------------------------------------------------------------------
+// COMPILE-TIME OPTIONS FOR DEAR IMGUI
+// Runtime options (clipboard callbacks, enabling various features, etc.) can generally be set via the ImGuiIO structure.
+// You can use ImGui::SetAllocatorFunctions() before calling ImGui::CreateContext() to rewire memory allocation functions.
+//-----------------------------------------------------------------------------
+// A) You may edit imconfig.h (and not overwrite it when updating Dear ImGui, or maintain a patch/rebased branch with your modifications to it)
+// B) or '#define IMGUI_USER_CONFIG "my_imgui_config.h"' in your project and then add directives in your own file without touching this template.
+//-----------------------------------------------------------------------------
+// You need to make sure that configuration settings are defined consistently _everywhere_ Dear ImGui is used, which include the imgui*.cpp
+// files but also _any_ of your code that uses Dear ImGui. This is because some compile-time options have an affect on data structures.
+// Defining those options in imconfig.h will ensure every compilation unit gets to see the same data structure layouts.
+// Call IMGUI_CHECKVERSION() from your .cpp files to verify that the data structures your files are using are matching the ones imgui.cpp is using.
+//-----------------------------------------------------------------------------
+
+#pragma once
+
+//---- Define assertion handler. Defaults to calling assert().
+// If your macro uses multiple statements, make sure is enclosed in a 'do { .. } while (0)' block so it can be used as a single statement.
+//#define IM_ASSERT(_EXPR)  MyAssert(_EXPR)
+//#define IM_ASSERT(_EXPR)  ((void)(_EXPR))     // Disable asserts
+
+//---- Define attributes of all API symbols declarations, e.g. for DLL under Windows
+// Using Dear ImGui via a shared library is not recommended, because of function call overhead and because we don't guarantee backward nor forward ABI compatibility.
+// DLL users: heaps and globals are not shared across DLL boundaries! You will need to call SetCurrentContext() + SetAllocatorFunctions()
+// for each static/DLL boundary you are calling from. Read "Context and Memory Allocators" section of imgui.cpp for more details.
+//#define IMGUI_API __declspec( dllexport )
+//#define IMGUI_API __declspec( dllimport )
+
+//---- Don't define obsolete functions/enums/behaviors. Consider enabling from time to time after updating to avoid using soon-to-be obsolete function/names.
+//#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+
+//---- Disable all of Dear ImGui or don't implement standard windows.
+// It is very strongly recommended to NOT disable the demo windows during development. Please read comments in imgui_demo.cpp.
+//#define IMGUI_DISABLE                                     // Disable everything: all headers and source files will be empty.
+//#define IMGUI_DISABLE_DEMO_WINDOWS                        // Disable demo windows: ShowDemoWindow()/ShowStyleEditor() will be empty. Not recommended.
+//#define IMGUI_DISABLE_METRICS_WINDOW                      // Disable metrics/debugger window: ShowMetricsWindow() will be empty.
+
+//---- Don't implement some functions to reduce linkage requirements.
+//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS   // [Win32] Don't implement default clipboard handler. Won't use and link with OpenClipboard/GetClipboardData/CloseClipboard etc. (user32.lib/.a, kernel32.lib/.a)
+//#define IMGUI_ENABLE_WIN32_DEFAULT_IME_FUNCTIONS          // [Win32] [Default with Visual Studio] Implement default IME handler (require imm32.lib/.a, auto-link for Visual Studio, -limm32 on command-line for MinGW)
+//#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS         // [Win32] [Default with non-Visual Studio compilers] Don't implement default IME handler (won't require imm32.lib/.a)
+//#define IMGUI_DISABLE_WIN32_FUNCTIONS                     // [Win32] Won't use and link with any Win32 function (clipboard, ime).
+//#define IMGUI_ENABLE_OSX_DEFAULT_CLIPBOARD_FUNCTIONS      // [OSX] Implement default OSX clipboard handler (need to link with '-framework ApplicationServices', this is why this is not the default).
+//#define IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS            // Don't implement ImFormatString/ImFormatStringV so you can implement them yourself (e.g. if you don't want to link with vsnprintf)
+//#define IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS              // Don't implement ImFabs/ImSqrt/ImPow/ImFmod/ImCos/ImSin/ImAcos/ImAtan2 so you can implement them yourself.
+//#define IMGUI_DISABLE_FILE_FUNCTIONS                      // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle at all (replace them with dummies)
+//#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS              // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle so you can implement them yourself if you don't want to link with fopen/fclose/fread/fwrite. This will also disable the LogToTTY() function.
+//#define IMGUI_DISABLE_DEFAULT_ALLOCATORS                  // Don't implement default allocators calling malloc()/free() to avoid linking with them. You will need to call ImGui::SetAllocatorFunctions().
+//#define IMGUI_DISABLE_SSE                                 // Disable use of SSE intrinsics even if available
+
+//---- Include imgui_user.h at the end of imgui.h as a convenience
+//#define IMGUI_INCLUDE_IMGUI_USER_H
+
+//---- Pack colors to BGRA8 instead of RGBA8 (to avoid converting from one to another)
+//#define IMGUI_USE_BGRA_PACKED_COLOR
+
+//---- Use 32-bit for ImWchar (default is 16-bit) to support unicode planes 1-16. (e.g. point beyond 0xFFFF like emoticons, dingbats, symbols, shapes, ancient languages, etc...)
+//#define IMGUI_USE_WCHAR32
+
+//---- Avoid multiple STB libraries implementations, or redefine path/filenames to prioritize another version
+// By default the embedded implementations are declared static and not available outside of Dear ImGui sources files.
+//#define IMGUI_STB_TRUETYPE_FILENAME   "my_folder/stb_truetype.h"
+//#define IMGUI_STB_RECT_PACK_FILENAME  "my_folder/stb_rect_pack.h"
+//#define IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION
+//#define IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION
+
+//---- Use stb_printf's faster implementation of vsnprintf instead of the one from libc (unless IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS is defined)
+// Requires 'stb_sprintf.h' to be available in the include path. Compatibility checks of arguments and formats done by clang and GCC will be disabled in order to support the extra formats provided by STB sprintf.
+// #define IMGUI_USE_STB_SPRINTF
+
+//---- Use FreeType to build and rasterize the font atlas (instead of stb_truetype which is embedded by default in Dear ImGui)
+// Requires FreeType headers to be available in the include path. Requires program to be compiled with 'misc/freetype/imgui_freetype.cpp' (in this repository) + the FreeType library (not provided).
+// On Windows you may use vcpkg with 'vcpkg install freetype --triplet=x64-windows' + 'vcpkg integrate install'.
+//#define IMGUI_ENABLE_FREETYPE
+
+//---- Use stb_truetype to build and rasterize the font atlas (default)
+// The only purpose of this define is if you want force compilation of the stb_truetype backend ALONG with the FreeType backend.
+//#define IMGUI_ENABLE_STB_TRUETYPE
+
+//---- Define constructor and implicit cast operators to convert back<>forth between your math types and ImVec2/ImVec4.
+// This will be inlined as part of ImVec2 and ImVec4 class declarations.
+/*
+#define IM_VEC2_CLASS_EXTRA                                                 \
+        ImVec2(const MyVec2& f) { x = f.x; y = f.y; }                       \
+        operator MyVec2() const { return MyVec2(x,y); }
+
+#define IM_VEC4_CLASS_EXTRA                                                 \
+        ImVec4(const MyVec4& f) { x = f.x; y = f.y; z = f.z; w = f.w; }     \
+        operator MyVec4() const { return MyVec4(x,y,z,w); }
+*/
+
+//---- Use 32-bit vertex indices (default is 16-bit) is one way to allow large meshes with more than 64K vertices.
+// Your renderer backend will need to support it (most example renderer backends support both 16/32-bit indices).
+// Another way to allow large meshes while keeping 16-bit indices is to handle ImDrawCmd::VtxOffset in your renderer.
+// Read about ImGuiBackendFlags_RendererHasVtxOffset for details.
+//#define ImDrawIdx unsigned int
+
+//---- Override ImDrawCallback signature (will need to modify renderer backends accordingly)
+//struct ImDrawList;
+//struct ImDrawCmd;
+//typedef void (*MyImDrawCallback)(const ImDrawList* draw_list, const ImDrawCmd* cmd, void* my_renderer_user_data);
+//#define ImDrawCallback MyImDrawCallback
+
+//---- Debug Tools: Macro to break in Debugger
+// (use 'Metrics->Tools->Item Picker' to pick widgets with the mouse and break into them for easy debugging.)
+//#define IM_DEBUG_BREAK  IM_ASSERT(0)
+//#define IM_DEBUG_BREAK  __debugbreak()
+
+//---- Debug Tools: Have the Item Picker break in the ItemAdd() function instead of ItemHoverable(),
+// (which comes earlier in the code, will catch a few extra items, allow picking items other than Hovered one.)
+// This adds a small runtime cost which is why it is not enabled by default.
+//#define IMGUI_DEBUG_TOOL_ITEM_PICKER_EX
+
+//---- Debug Tools: Enable slower asserts
+//#define IMGUI_DEBUG_PARANOID
+
+//---- Tip: You can add extra functions within the ImGui:: namespace, here or in your own headers files.
+/*
+namespace ImGui
+{
+    void MyFunction(const char* name, const MyMatrix44& v);
+}
+*/

lib/imgui/include/imgui_impl_sdl.h

@@ -0,0 +1,34 @@
+// dear imgui: Platform Backend for SDL2
+// This needs to be used along with a Renderer (e.g. DirectX11, OpenGL3, Vulkan..)
+// (Info: SDL2 is a cross-platform general purpose library for handling windows, inputs, graphics context creation, etc.)
+
+// Implemented features:
+//  [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
+//  [X] Platform: Clipboard support.
+//  [X] Platform: Keyboard arrays indexed using SDL_SCANCODE_* codes, e.g. ImGui::IsKeyPressed(SDL_SCANCODE_SPACE).
+//  [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
+// Missing features:
+//  [ ] Platform: SDL2 handling of IME under Windows appears to be broken and it explicitly disable the regular Windows IME. You can restore Windows IME by compiling SDL with SDL_DISABLE_WINDOWS_IME.
+
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
+// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
+// Read online: https://github.com/ocornut/imgui/tree/master/docs
+
+#pragma once
+#include "imgui.h"      // IMGUI_IMPL_API
+
+struct SDL_Window;
+typedef union SDL_Event SDL_Event;
+
+IMGUI_IMPL_API bool     ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window, void* sdl_gl_context);
+IMGUI_IMPL_API bool     ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
+IMGUI_IMPL_API bool     ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
+IMGUI_IMPL_API bool     ImGui_ImplSDL2_InitForMetal(SDL_Window* window);
+IMGUI_IMPL_API void     ImGui_ImplSDL2_Shutdown();
+IMGUI_IMPL_API void     ImGui_ImplSDL2_NewFrame();
+IMGUI_IMPL_API bool     ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);
+
+#ifndef IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+static inline void ImGui_ImplSDL2_NewFrame(SDL_Window*) { ImGui_ImplSDL2_NewFrame(); } // 1.84: removed unnecessary parameter
+#endif

lib/imgui/include/imgui_sdl.h

@@ -0,0 +1,17 @@
+#pragma once
+
+struct ImDrawData;
+struct SDL_Renderer;
+
+namespace ImGuiSDL
+{
+	// Call this to initialize the SDL renderer device that is internally used by the renderer.
+	void Initialize(SDL_Renderer* renderer, int windowWidth, int windowHeight);
+	// Call this before destroying your SDL renderer or ImGui to ensure that proper cleanup is done. This doesn't do anything critically important though,
+	// so if you're fine with small memory leaks at the end of your application, you can even omit this.
+	void Deinitialize();
+
+	// Call this every frame after ImGui::Render with ImGui::GetDrawData(). This will use the SDL_Renderer provided to the interfrace with Initialize
+	// to draw the contents of the draw data to the screen.
+	void Render(ImDrawData* drawData);
+}

lib/imgui/include/imstb_rectpack.h

@@ -0,0 +1,639 @@
+// [DEAR IMGUI]
+// This is a slightly modified version of stb_rect_pack.h 1.00.
+// Those changes would need to be pushed into nothings/stb:
+// - Added STBRP__CDECL
+// Grep for [DEAR IMGUI] to find the changes.
+
+// stb_rect_pack.h - v1.00 - public domain - rectangle packing
+// Sean Barrett 2014
+//
+// Useful for e.g. packing rectangular textures into an atlas.
+// Does not do rotation.
+//
+// Not necessarily the awesomest packing method, but better than
+// the totally naive one in stb_truetype (which is primarily what
+// this is meant to replace).
+//
+// Has only had a few tests run, may have issues.
+//
+// More docs to come.
+//
+// No memory allocations; uses qsort() and assert() from stdlib.
+// Can override those by defining STBRP_SORT and STBRP_ASSERT.
+//
+// This library currently uses the Skyline Bottom-Left algorithm.
+//
+// Please note: better rectangle packers are welcome! Please
+// implement them to the same API, but with a different init
+// function.
+//
+// Credits
+//
+//  Library
+//    Sean Barrett
+//  Minor features
+//    Martins Mozeiko
+//    github:IntellectualKitty
+//
+//  Bugfixes / warning fixes
+//    Jeremy Jaussaud
+//    Fabian Giesen
+//
+// Version history:
+//
+//     1.00  (2019-02-25)  avoid small space waste; gracefully fail too-wide rectangles
+//     0.99  (2019-02-07)  warning fixes
+//     0.11  (2017-03-03)  return packing success/fail result
+//     0.10  (2016-10-25)  remove cast-away-const to avoid warnings
+//     0.09  (2016-08-27)  fix compiler warnings
+//     0.08  (2015-09-13)  really fix bug with empty rects (w=0 or h=0)
+//     0.07  (2015-09-13)  fix bug with empty rects (w=0 or h=0)
+//     0.06  (2015-04-15)  added STBRP_SORT to allow replacing qsort
+//     0.05:  added STBRP_ASSERT to allow replacing assert
+//     0.04:  fixed minor bug in STBRP_LARGE_RECTS support
+//     0.01:  initial release
+//
+// LICENSE
+//
+//   See end of file for license information.
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//       INCLUDE SECTION
+//
+
+#ifndef STB_INCLUDE_STB_RECT_PACK_H
+#define STB_INCLUDE_STB_RECT_PACK_H
+
+#define STB_RECT_PACK_VERSION  1
+
+#ifdef STBRP_STATIC
+#define STBRP_DEF static
+#else
+#define STBRP_DEF extern
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct stbrp_context stbrp_context;
+typedef struct stbrp_node    stbrp_node;
+typedef struct stbrp_rect    stbrp_rect;
+
+#ifdef STBRP_LARGE_RECTS
+typedef int            stbrp_coord;
+#else
+typedef unsigned short stbrp_coord;
+#endif
+
+STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects);
+// Assign packed locations to rectangles. The rectangles are of type
+// 'stbrp_rect' defined below, stored in the array 'rects', and there
+// are 'num_rects' many of them.
+//
+// Rectangles which are successfully packed have the 'was_packed' flag
+// set to a non-zero value and 'x' and 'y' store the minimum location
+// on each axis (i.e. bottom-left in cartesian coordinates, top-left
+// if you imagine y increasing downwards). Rectangles which do not fit
+// have the 'was_packed' flag set to 0.
+//
+// You should not try to access the 'rects' array from another thread
+// while this function is running, as the function temporarily reorders
+// the array while it executes.
+//
+// To pack into another rectangle, you need to call stbrp_init_target
+// again. To continue packing into the same rectangle, you can call
+// this function again. Calling this multiple times with multiple rect
+// arrays will probably produce worse packing results than calling it
+// a single time with the full rectangle array, but the option is
+// available.
+//
+// The function returns 1 if all of the rectangles were successfully
+// packed and 0 otherwise.
+
+struct stbrp_rect
+{
+   // reserved for your use:
+   int            id;
+
+   // input:
+   stbrp_coord    w, h;
+
+   // output:
+   stbrp_coord    x, y;
+   int            was_packed;  // non-zero if valid packing
+
+}; // 16 bytes, nominally
+
+
+STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes);
+// Initialize a rectangle packer to:
+//    pack a rectangle that is 'width' by 'height' in dimensions
+//    using temporary storage provided by the array 'nodes', which is 'num_nodes' long
+//
+// You must call this function every time you start packing into a new target.
+//
+// There is no "shutdown" function. The 'nodes' memory must stay valid for
+// the following stbrp_pack_rects() call (or calls), but can be freed after
+// the call (or calls) finish.
+//
+// Note: to guarantee best results, either:
+//       1. make sure 'num_nodes' >= 'width'
+//   or  2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
+//
+// If you don't do either of the above things, widths will be quantized to multiples
+// of small integers to guarantee the algorithm doesn't run out of temporary storage.
+//
+// If you do #2, then the non-quantized algorithm will be used, but the algorithm
+// may run out of temporary storage and be unable to pack some rectangles.
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem);
+// Optionally call this function after init but before doing any packing to
+// change the handling of the out-of-temp-memory scenario, described above.
+// If you call init again, this will be reset to the default (false).
+
+
+STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic);
+// Optionally select which packing heuristic the library should use. Different
+// heuristics will produce better/worse results for different data sets.
+// If you call init again, this will be reset to the default.
+
+enum
+{
+   STBRP_HEURISTIC_Skyline_default=0,
+   STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
+   STBRP_HEURISTIC_Skyline_BF_sortHeight
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// the details of the following structures don't matter to you, but they must
+// be visible so you can handle the memory allocations for them
+
+struct stbrp_node
+{
+   stbrp_coord  x,y;
+   stbrp_node  *next;
+};
+
+struct stbrp_context
+{
+   int width;
+   int height;
+   int align;
+   int init_mode;
+   int heuristic;
+   int num_nodes;
+   stbrp_node *active_head;
+   stbrp_node *free_head;
+   stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//     IMPLEMENTATION SECTION
+//
+
+#ifdef STB_RECT_PACK_IMPLEMENTATION
+#ifndef STBRP_SORT
+#include <stdlib.h>
+#define STBRP_SORT qsort
+#endif
+
+#ifndef STBRP_ASSERT
+#include <assert.h>
+#define STBRP_ASSERT assert
+#endif
+
+// [DEAR IMGUI] Added STBRP__CDECL
+#ifdef _MSC_VER
+#define STBRP__NOTUSED(v)  (void)(v)
+#define STBRP__CDECL __cdecl
+#else
+#define STBRP__NOTUSED(v)  (void)sizeof(v)
+#define STBRP__CDECL
+#endif
+
+enum
+{
+   STBRP__INIT_skyline = 1
+};
+
+STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)
+{
+   switch (context->init_mode) {
+      case STBRP__INIT_skyline:
+         STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
+         context->heuristic = heuristic;
+         break;
+      default:
+         STBRP_ASSERT(0);
+   }
+}
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)
+{
+   if (allow_out_of_mem)
+      // if it's ok to run out of memory, then don't bother aligning them;
+      // this gives better packing, but may fail due to OOM (even though
+      // the rectangles easily fit). @TODO a smarter approach would be to only
+      // quantize once we've hit OOM, then we could get rid of this parameter.
+      context->align = 1;
+   else {
+      // if it's not ok to run out of memory, then quantize the widths
+      // so that num_nodes is always enough nodes.
+      //
+      // I.e. num_nodes * align >= width
+      //                  align >= width / num_nodes
+      //                  align = ceil(width/num_nodes)
+
+      context->align = (context->width + context->num_nodes-1) / context->num_nodes;
+   }
+}
+
+STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
+{
+   int i;
+#ifndef STBRP_LARGE_RECTS
+   STBRP_ASSERT(width <= 0xffff && height <= 0xffff);
+#endif
+
+   for (i=0; i < num_nodes-1; ++i)
+      nodes[i].next = &nodes[i+1];
+   nodes[i].next = NULL;
+   context->init_mode = STBRP__INIT_skyline;
+   context->heuristic = STBRP_HEURISTIC_Skyline_default;
+   context->free_head = &nodes[0];
+   context->active_head = &context->extra[0];
+   context->width = width;
+   context->height = height;
+   context->num_nodes = num_nodes;
+   stbrp_setup_allow_out_of_mem(context, 0);
+
+   // node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
+   context->extra[0].x = 0;
+   context->extra[0].y = 0;
+   context->extra[0].next = &context->extra[1];
+   context->extra[1].x = (stbrp_coord) width;
+#ifdef STBRP_LARGE_RECTS
+   context->extra[1].y = (1<<30);
+#else
+   context->extra[1].y = 65535;
+#endif
+   context->extra[1].next = NULL;
+}
+
+// find minimum y position if it starts at x1
+static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)
+{
+   stbrp_node *node = first;
+   int x1 = x0 + width;
+   int min_y, visited_width, waste_area;
+
+   STBRP__NOTUSED(c);
+
+   STBRP_ASSERT(first->x <= x0);
+
+   #if 0
+   // skip in case we're past the node
+   while (node->next->x <= x0)
+      ++node;
+   #else
+   STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency
+   #endif
+
+   STBRP_ASSERT(node->x <= x0);
+
+   min_y = 0;
+   waste_area = 0;
+   visited_width = 0;
+   while (node->x < x1) {
+      if (node->y > min_y) {
+         // raise min_y higher.
+         // we've accounted for all waste up to min_y,
+         // but we'll now add more waste for everything we've visted
+         waste_area += visited_width * (node->y - min_y);
+         min_y = node->y;
+         // the first time through, visited_width might be reduced
+         if (node->x < x0)
+            visited_width += node->next->x - x0;
+         else
+            visited_width += node->next->x - node->x;
+      } else {
+         // add waste area
+         int under_width = node->next->x - node->x;
+         if (under_width + visited_width > width)
+            under_width = width - visited_width;
+         waste_area += under_width * (min_y - node->y);
+         visited_width += under_width;
+      }
+      node = node->next;
+   }
+
+   *pwaste = waste_area;
+   return min_y;
+}
+
+typedef struct
+{
+   int x,y;
+   stbrp_node **prev_link;
+} stbrp__findresult;
+
+static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)
+{
+   int best_waste = (1<<30), best_x, best_y = (1 << 30);
+   stbrp__findresult fr;
+   stbrp_node **prev, *node, *tail, **best = NULL;
+
+   // align to multiple of c->align
+   width = (width + c->align - 1);
+   width -= width % c->align;
+   STBRP_ASSERT(width % c->align == 0);
+
+   // if it can't possibly fit, bail immediately
+   if (width > c->width || height > c->height) {
+      fr.prev_link = NULL;
+      fr.x = fr.y = 0;
+      return fr;
+   }
+
+   node = c->active_head;
+   prev = &c->active_head;
+   while (node->x + width <= c->width) {
+      int y,waste;
+      y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
+      if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL
+         // bottom left
+         if (y < best_y) {
+            best_y = y;
+            best = prev;
+         }
+      } else {
+         // best-fit
+         if (y + height <= c->height) {
+            // can only use it if it first vertically
+            if (y < best_y || (y == best_y && waste < best_waste)) {
+               best_y = y;
+               best_waste = waste;
+               best = prev;
+            }
+         }
+      }
+      prev = &node->next;
+      node = node->next;
+   }
+
+   best_x = (best == NULL) ? 0 : (*best)->x;
+
+   // if doing best-fit (BF), we also have to try aligning right edge to each node position
+   //
+   // e.g, if fitting
+   //
+   //     ____________________
+   //    |____________________|
+   //
+   //            into
+   //
+   //   |                         |
+   //   |             ____________|
+   //   |____________|
+   //
+   // then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
+   //
+   // This makes BF take about 2x the time
+
+   if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) {
+      tail = c->active_head;
+      node = c->active_head;
+      prev = &c->active_head;
+      // find first node that's admissible
+      while (tail->x < width)
+         tail = tail->next;
+      while (tail) {
+         int xpos = tail->x - width;
+         int y,waste;
+         STBRP_ASSERT(xpos >= 0);
+         // find the left position that matches this
+         while (node->next->x <= xpos) {
+            prev = &node->next;
+            node = node->next;
+         }
+         STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
+         y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
+         if (y + height <= c->height) {
+            if (y <= best_y) {
+               if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) {
+                  best_x = xpos;
+                  STBRP_ASSERT(y <= best_y);
+                  best_y = y;
+                  best_waste = waste;
+                  best = prev;
+               }
+            }
+         }
+         tail = tail->next;
+      }
+   }
+
+   fr.prev_link = best;
+   fr.x = best_x;
+   fr.y = best_y;
+   return fr;
+}
+
+static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)
+{
+   // find best position according to heuristic
+   stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
+   stbrp_node *node, *cur;
+
+   // bail if:
+   //    1. it failed
+   //    2. the best node doesn't fit (we don't always check this)
+   //    3. we're out of memory
+   if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) {
+      res.prev_link = NULL;
+      return res;
+   }
+
+   // on success, create new node
+   node = context->free_head;
+   node->x = (stbrp_coord) res.x;
+   node->y = (stbrp_coord) (res.y + height);
+
+   context->free_head = node->next;
+
+   // insert the new node into the right starting point, and
+   // let 'cur' point to the remaining nodes needing to be
+   // stiched back in
+
+   cur = *res.prev_link;
+   if (cur->x < res.x) {
+      // preserve the existing one, so start testing with the next one
+      stbrp_node *next = cur->next;
+      cur->next = node;
+      cur = next;
+   } else {
+      *res.prev_link = node;
+   }
+
+   // from here, traverse cur and free the nodes, until we get to one
+   // that shouldn't be freed
+   while (cur->next && cur->next->x <= res.x + width) {
+      stbrp_node *next = cur->next;
+      // move the current node to the free list
+      cur->next = context->free_head;
+      context->free_head = cur;
+      cur = next;
+   }
+
+   // stitch the list back in
+   node->next = cur;
+
+   if (cur->x < res.x + width)
+      cur->x = (stbrp_coord) (res.x + width);
+
+#ifdef _DEBUG
+   cur = context->active_head;
+   while (cur->x < context->width) {
+      STBRP_ASSERT(cur->x < cur->next->x);
+      cur = cur->next;
+   }
+   STBRP_ASSERT(cur->next == NULL);
+
+   {
+      int count=0;
+      cur = context->active_head;
+      while (cur) {
+         cur = cur->next;
+         ++count;
+      }
+      cur = context->free_head;
+      while (cur) {
+         cur = cur->next;
+         ++count;
+      }
+      STBRP_ASSERT(count == context->num_nodes+2);
+   }
+#endif
+
+   return res;
+}
+
+// [DEAR IMGUI] Added STBRP__CDECL
+static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
+{
+   const stbrp_rect *p = (const stbrp_rect *) a;
+   const stbrp_rect *q = (const stbrp_rect *) b;
+   if (p->h > q->h)
+      return -1;
+   if (p->h < q->h)
+      return  1;
+   return (p->w > q->w) ? -1 : (p->w < q->w);
+}
+
+// [DEAR IMGUI] Added STBRP__CDECL
+static int STBRP__CDECL rect_original_order(const void *a, const void *b)
+{
+   const stbrp_rect *p = (const stbrp_rect *) a;
+   const stbrp_rect *q = (const stbrp_rect *) b;
+   return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
+}
+
+#ifdef STBRP_LARGE_RECTS
+#define STBRP__MAXVAL  0xffffffff
+#else
+#define STBRP__MAXVAL  0xffff
+#endif
+
+STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)
+{
+   int i, all_rects_packed = 1;
+
+   // we use the 'was_packed' field internally to allow sorting/unsorting
+   for (i=0; i < num_rects; ++i) {
+      rects[i].was_packed = i;
+   }
+
+   // sort according to heuristic
+   STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare);
+
+   for (i=0; i < num_rects; ++i) {
+      if (rects[i].w == 0 || rects[i].h == 0) {
+         rects[i].x = rects[i].y = 0;  // empty rect needs no space
+      } else {
+         stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
+         if (fr.prev_link) {
+            rects[i].x = (stbrp_coord) fr.x;
+            rects[i].y = (stbrp_coord) fr.y;
+         } else {
+            rects[i].x = rects[i].y = STBRP__MAXVAL;
+         }
+      }
+   }
+
+   // unsort
+   STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order);
+
+   // set was_packed flags and all_rects_packed status
+   for (i=0; i < num_rects; ++i) {
+      rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
+      if (!rects[i].was_packed)
+         all_rects_packed = 0;
+   }
+
+   // return the all_rects_packed status
+   return all_rects_packed;
+}
+#endif
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/

lib/imgui/src/imgui_impl_sdl.cpp

@@ -0,0 +1,404 @@
+// dear imgui: Platform Backend for SDL2
+// This needs to be used along with a Renderer (e.g. DirectX11, OpenGL3, Vulkan..)
+// (Info: SDL2 is a cross-platform general purpose library for handling windows, inputs, graphics context creation, etc.)
+// (Requires: SDL 2.0. Prefer SDL 2.0.4+ for full feature support.)
+
+// Implemented features:
+//  [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
+//  [X] Platform: Clipboard support.
+//  [X] Platform: Keyboard arrays indexed using SDL_SCANCODE_* codes, e.g. ImGui::IsKeyPressed(SDL_SCANCODE_SPACE).
+//  [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
+// Missing features:
+//  [ ] Platform: SDL2 handling of IME under Windows appears to be broken and it explicitly disable the regular Windows IME. You can restore Windows IME by compiling SDL with SDL_DISABLE_WINDOWS_IME.
+
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
+// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
+// Read online: https://github.com/ocornut/imgui/tree/master/docs
+
+// CHANGELOG
+// (minor and older changes stripped away, please see git history for details)
+//  2021-06:29: *BREAKING CHANGE* Removed 'SDL_Window* window' parameter to ImGui_ImplSDL2_NewFrame() which was unnecessary.
+//  2021-06-29: Reorganized backend to pull data from a single structure to facilitate usage with multiple-contexts (all g_XXXX access changed to bd->XXXX).
+//  2021-03-22: Rework global mouse pos availability check listing supported platforms explicitly, effectively fixing mouse access on Raspberry Pi. (#2837, #3950)
+//  2020-05-25: Misc: Report a zero display-size when window is minimized, to be consistent with other backends.
+//  2020-02-20: Inputs: Fixed mapping for ImGuiKey_KeyPadEnter (using SDL_SCANCODE_KP_ENTER instead of SDL_SCANCODE_RETURN2).
+//  2019-12-17: Inputs: On Wayland, use SDL_GetMouseState (because there is no global mouse state).
+//  2019-12-05: Inputs: Added support for ImGuiMouseCursor_NotAllowed mouse cursor.
+//  2019-07-21: Inputs: Added mapping for ImGuiKey_KeyPadEnter.
+//  2019-04-23: Inputs: Added support for SDL_GameController (if ImGuiConfigFlags_NavEnableGamepad is set by user application).
+//  2019-03-12: Misc: Preserve DisplayFramebufferScale when main window is minimized.
+//  2018-12-21: Inputs: Workaround for Android/iOS which don't seem to handle focus related calls.
+//  2018-11-30: Misc: Setting up io.BackendPlatformName so it can be displayed in the About Window.
+//  2018-11-14: Changed the signature of ImGui_ImplSDL2_ProcessEvent() to take a 'const SDL_Event*'.
+//  2018-08-01: Inputs: Workaround for Emscripten which doesn't seem to handle focus related calls.
+//  2018-06-29: Inputs: Added support for the ImGuiMouseCursor_Hand cursor.
+//  2018-06-08: Misc: Extracted imgui_impl_sdl.cpp/.h away from the old combined SDL2+OpenGL/Vulkan examples.
+//  2018-06-08: Misc: ImGui_ImplSDL2_InitForOpenGL() now takes a SDL_GLContext parameter.
+//  2018-05-09: Misc: Fixed clipboard paste memory leak (we didn't call SDL_FreeMemory on the data returned by SDL_GetClipboardText).
+//  2018-03-20: Misc: Setup io.BackendFlags ImGuiBackendFlags_HasMouseCursors flag + honor ImGuiConfigFlags_NoMouseCursorChange flag.
+//  2018-02-16: Inputs: Added support for mouse cursors, honoring ImGui::GetMouseCursor() value.
+//  2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.
+//  2018-02-06: Inputs: Added mapping for ImGuiKey_Space.
+//  2018-02-05: Misc: Using SDL_GetPerformanceCounter() instead of SDL_GetTicks() to be able to handle very high framerate (1000+ FPS).
+//  2018-02-05: Inputs: Keyboard mapping is using scancodes everywhere instead of a confusing mixture of keycodes and scancodes.
+//  2018-01-20: Inputs: Added Horizontal Mouse Wheel support.
+//  2018-01-19: Inputs: When available (SDL 2.0.4+) using SDL_CaptureMouse() to retrieve coordinates outside of client area when dragging. Otherwise (SDL 2.0.3 and before) testing for SDL_WINDOW_INPUT_FOCUS instead of SDL_WINDOW_MOUSE_FOCUS.
+//  2018-01-18: Inputs: Added mapping for ImGuiKey_Insert.
+//  2017-08-25: Inputs: MousePos set to -FLT_MAX,-FLT_MAX when mouse is unavailable/missing (instead of -1,-1).
+//  2016-10-15: Misc: Added a void* user_data parameter to Clipboard function handlers.
+
+#include "imgui.h"
+#include "imgui_impl_sdl.h"
+
+// SDL
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_syswm.h>
+#if defined(__APPLE__)
+#include "TargetConditionals.h"
+#endif
+
+#define SDL_HAS_CAPTURE_AND_GLOBAL_MOUSE    SDL_VERSION_ATLEAST(2,0,4)
+#define SDL_HAS_VULKAN                      SDL_VERSION_ATLEAST(2,0,6)
+
+struct ImGui_ImplSDL2_Data
+{
+    SDL_Window* Window;
+    Uint64      Time;
+    bool        MousePressed[3];
+    SDL_Cursor* MouseCursors[ImGuiMouseCursor_COUNT];
+    char*       ClipboardTextData;
+    bool        MouseCanUseGlobalState;
+
+    ImGui_ImplSDL2_Data()   { memset(this, 0, sizeof(*this)); }
+};
+
+// Backend data stored in io.BackendPlatformUserData to allow support for multiple Dear ImGui contexts
+// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
+// FIXME: multi-context support is not well tested and probably dysfunctional in this backend.
+// FIXME: some shared resources (mouse cursor shape, gamepad) are mishandled when using multi-context.
+static ImGui_ImplSDL2_Data* ImGui_ImplSDL2_GetBackendData()
+{
+    return ImGui::GetCurrentContext() ? (ImGui_ImplSDL2_Data*)ImGui::GetIO().BackendPlatformUserData : NULL;
+}
+
+// Functions
+static const char* ImGui_ImplSDL2_GetClipboardText(void*)
+{
+    ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
+    if (bd->ClipboardTextData)
+        SDL_free(bd->ClipboardTextData);
+    bd->ClipboardTextData = SDL_GetClipboardText();
+    return bd->ClipboardTextData;
+}
+
+static void ImGui_ImplSDL2_SetClipboardText(void*, const char* text)
+{
+    SDL_SetClipboardText(text);
+}
+
+// You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
+// - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application.
+// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application.
+// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
+// If you have multiple SDL events and some of them are not meant to be used by dear imgui, you may need to filter events based on their windowID field.
+bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event)
+{
+    ImGuiIO& io = ImGui::GetIO();
+    ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
+
+    switch (event->type)
+    {
+    case SDL_MOUSEWHEEL:
+        {
+            if (event->wheel.x > 0) io.MouseWheelH += 1;
+            if (event->wheel.x < 0) io.MouseWheelH -= 1;
+            if (event->wheel.y > 0) io.MouseWheel += 1;
+            if (event->wheel.y < 0) io.MouseWheel -= 1;
+            return true;
+        }
+    case SDL_MOUSEBUTTONDOWN:
+        {
+            if (event->button.button == SDL_BUTTON_LEFT) { bd->MousePressed[0] = true; }
+            if (event->button.button == SDL_BUTTON_RIGHT) { bd->MousePressed[1] = true; }
+            if (event->button.button == SDL_BUTTON_MIDDLE) { bd->MousePressed[2] = true; }
+            return true;
+        }
+    case SDL_TEXTINPUT:
+        {
+            io.AddInputCharactersUTF8(event->text.text);
+            return true;
+        }
+    case SDL_KEYDOWN:
+    case SDL_KEYUP:
+        {
+            int key = event->key.keysym.scancode;
+            IM_ASSERT(key >= 0 && key < IM_ARRAYSIZE(io.KeysDown));
+            io.KeysDown[key] = (event->type == SDL_KEYDOWN);
+            io.KeyShift = ((SDL_GetModState() & KMOD_SHIFT) != 0);
+            io.KeyCtrl = ((SDL_GetModState() & KMOD_CTRL) != 0);
+            io.KeyAlt = ((SDL_GetModState() & KMOD_ALT) != 0);
+#ifdef _WIN32
+            io.KeySuper = false;
+#else
+            io.KeySuper = ((SDL_GetModState() & KMOD_GUI) != 0);
+#endif
+            return true;
+        }
+    }
+    return false;
+}
+
+static bool ImGui_ImplSDL2_Init(SDL_Window* window)
+{
+    ImGuiIO& io = ImGui::GetIO();
+    IM_ASSERT(io.BackendPlatformUserData == NULL && "Already initialized a platform backend!");
+
+    // Setup backend capabilities flags
+    ImGui_ImplSDL2_Data* bd = IM_NEW(ImGui_ImplSDL2_Data)();
+    io.BackendPlatformUserData = (void*)bd;
+    io.BackendPlatformName = "imgui_impl_sdl";
+    io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors;       // We can honor GetMouseCursor() values (optional)
+    io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos;        // We can honor io.WantSetMousePos requests (optional, rarely used)
+
+    bd->Window = window;
+
+    // Keyboard mapping. Dear ImGui will use those indices to peek into the io.KeysDown[] array.
+    io.KeyMap[ImGuiKey_Tab] = SDL_SCANCODE_TAB;
+    io.KeyMap[ImGuiKey_LeftArrow] = SDL_SCANCODE_LEFT;
+    io.KeyMap[ImGuiKey_RightArrow] = SDL_SCANCODE_RIGHT;
+    io.KeyMap[ImGuiKey_UpArrow] = SDL_SCANCODE_UP;
+    io.KeyMap[ImGuiKey_DownArrow] = SDL_SCANCODE_DOWN;
+    io.KeyMap[ImGuiKey_PageUp] = SDL_SCANCODE_PAGEUP;
+    io.KeyMap[ImGuiKey_PageDown] = SDL_SCANCODE_PAGEDOWN;
+    io.KeyMap[ImGuiKey_Home] = SDL_SCANCODE_HOME;
+    io.KeyMap[ImGuiKey_End] = SDL_SCANCODE_END;
+    io.KeyMap[ImGuiKey_Insert] = SDL_SCANCODE_INSERT;
+    io.KeyMap[ImGuiKey_Delete] = SDL_SCANCODE_DELETE;
+    io.KeyMap[ImGuiKey_Backspace] = SDL_SCANCODE_BACKSPACE;
+    io.KeyMap[ImGuiKey_Space] = SDL_SCANCODE_SPACE;
+    io.KeyMap[ImGuiKey_Enter] = SDL_SCANCODE_RETURN;
+    io.KeyMap[ImGuiKey_Escape] = SDL_SCANCODE_ESCAPE;
+    io.KeyMap[ImGuiKey_KeyPadEnter] = SDL_SCANCODE_KP_ENTER;
+    io.KeyMap[ImGuiKey_A] = SDL_SCANCODE_A;
+    io.KeyMap[ImGuiKey_C] = SDL_SCANCODE_C;
+    io.KeyMap[ImGuiKey_V] = SDL_SCANCODE_V;
+    io.KeyMap[ImGuiKey_X] = SDL_SCANCODE_X;
+    io.KeyMap[ImGuiKey_Y] = SDL_SCANCODE_Y;
+    io.KeyMap[ImGuiKey_Z] = SDL_SCANCODE_Z;
+
+    io.SetClipboardTextFn = ImGui_ImplSDL2_SetClipboardText;
+    io.GetClipboardTextFn = ImGui_ImplSDL2_GetClipboardText;
+    io.ClipboardUserData = NULL;
+
+    // Load mouse cursors
+    bd->MouseCursors[ImGuiMouseCursor_Arrow] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
+    bd->MouseCursors[ImGuiMouseCursor_TextInput] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_IBEAM);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeAll] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZEALL);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeNS] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENS);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeEW] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZEWE);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeNESW] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENESW);
+    bd->MouseCursors[ImGuiMouseCursor_ResizeNWSE] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENWSE);
+    bd->MouseCursors[ImGuiMouseCursor_Hand] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_HAND);
+    bd->MouseCursors[ImGuiMouseCursor_NotAllowed] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_NO);
+
+    // Check and store if we are on a SDL backend that supports global mouse position
+    // ("wayland" and "rpi" don't support it, but we chose to use a white-list instead of a black-list)
+    const char* sdl_backend = SDL_GetCurrentVideoDriver();
+    const char* global_mouse_whitelist[] = { "windows", "cocoa", "x11", "DIVE", "VMAN" };
+    bd->MouseCanUseGlobalState = false;
+    for (int n = 0; n < IM_ARRAYSIZE(global_mouse_whitelist); n++)
+        if (strncmp(sdl_backend, global_mouse_whitelist[n], strlen(global_mouse_whitelist[n])) == 0)
+            bd->MouseCanUseGlobalState = true;
+
+#ifdef _WIN32
+    SDL_SysWMinfo wmInfo;
+    SDL_VERSION(&wmInfo.version);
+    SDL_GetWindowWMInfo(window, &wmInfo);
+    io.ImeWindowHandle = wmInfo.info.win.window;
+#else
+    (void)window;
+#endif
+
+    return true;
+}
+
+bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window, void* sdl_gl_context)
+{
+    IM_UNUSED(sdl_gl_context); // Viewport branch will need this.
+    return ImGui_ImplSDL2_Init(window);
+}
+
+bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window)
+{
+#if !SDL_HAS_VULKAN
+    IM_ASSERT(0 && "Unsupported");
+#endif
+    return ImGui_ImplSDL2_Init(window);
+}
+
+bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window)
+{
+#if !defined(_WIN32)
+    IM_ASSERT(0 && "Unsupported");
+#endif
+    return ImGui_ImplSDL2_Init(window);
+}
+
+bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window)
+{
+    return ImGui_ImplSDL2_Init(window);
+}
+
+void ImGui_ImplSDL2_Shutdown()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
+
+    if (bd->ClipboardTextData)
+        SDL_free(bd->ClipboardTextData);
+    for (ImGuiMouseCursor cursor_n = 0; cursor_n < ImGuiMouseCursor_COUNT; cursor_n++)
+        SDL_FreeCursor(bd->MouseCursors[cursor_n]);
+
+    io.BackendPlatformName = NULL;
+    io.BackendPlatformUserData = NULL;
+    IM_DELETE(bd);
+}
+
+static void ImGui_ImplSDL2_UpdateMousePosAndButtons()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
+
+    // Set OS mouse position if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
+    if (io.WantSetMousePos)
+        SDL_WarpMouseInWindow(bd->Window, (int)io.MousePos.x, (int)io.MousePos.y);
+    else
+        io.MousePos = ImVec2(-FLT_MAX, -FLT_MAX);
+
+    int mx, my;
+    Uint32 mouse_buttons = SDL_GetMouseState(&mx, &my);
+    io.MouseDown[0] = bd->MousePressed[0] || (mouse_buttons & SDL_BUTTON(SDL_BUTTON_LEFT)) != 0;  // If a mouse press event came, always pass it as "mouse held this frame", so we don't miss click-release events that are shorter than 1 frame.
+    io.MouseDown[1] = bd->MousePressed[1] || (mouse_buttons & SDL_BUTTON(SDL_BUTTON_RIGHT)) != 0;
+    io.MouseDown[2] = bd->MousePressed[2] || (mouse_buttons & SDL_BUTTON(SDL_BUTTON_MIDDLE)) != 0;
+    bd->MousePressed[0] = bd->MousePressed[1] = bd->MousePressed[2] = false;
+
+#if SDL_HAS_CAPTURE_AND_GLOBAL_MOUSE && !defined(__EMSCRIPTEN__) && !defined(__ANDROID__) && !(defined(__APPLE__) && TARGET_OS_IOS)
+    SDL_Window* focused_window = SDL_GetKeyboardFocus();
+    if (bd->Window == focused_window)
+    {
+        if (bd->MouseCanUseGlobalState)
+        {
+            // SDL_GetMouseState() gives mouse position seemingly based on the last window entered/focused(?)
+            // The creation of a new windows at runtime and SDL_CaptureMouse both seems to severely mess up with that, so we retrieve that position globally.
+            // Won't use this workaround on SDL backends that have no global mouse position, like Wayland or RPI
+            int wx, wy;
+            SDL_GetWindowPosition(focused_window, &wx, &wy);
+            SDL_GetGlobalMouseState(&mx, &my);
+            mx -= wx;
+            my -= wy;
+        }
+        io.MousePos = ImVec2((float)mx, (float)my);
+    }
+
+    // SDL_CaptureMouse() let the OS know e.g. that our imgui drag outside the SDL window boundaries shouldn't e.g. trigger the OS window resize cursor.
+    // The function is only supported from SDL 2.0.4 (released Jan 2016)
+    bool any_mouse_button_down = ImGui::IsAnyMouseDown();
+    SDL_CaptureMouse(any_mouse_button_down ? SDL_TRUE : SDL_FALSE);
+#else
+    if (SDL_GetWindowFlags(bd->Window) & SDL_WINDOW_INPUT_FOCUS)
+        io.MousePos = ImVec2((float)mx, (float)my);
+#endif
+}
+
+static void ImGui_ImplSDL2_UpdateMouseCursor()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    if (io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange)
+        return;
+    ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
+
+    ImGuiMouseCursor imgui_cursor = ImGui::GetMouseCursor();
+    if (io.MouseDrawCursor || imgui_cursor == ImGuiMouseCursor_None)
+    {
+        // Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
+        SDL_ShowCursor(SDL_FALSE);
+    }
+    else
+    {
+        // Show OS mouse cursor
+        SDL_SetCursor(bd->MouseCursors[imgui_cursor] ? bd->MouseCursors[imgui_cursor] : bd->MouseCursors[ImGuiMouseCursor_Arrow]);
+        SDL_ShowCursor(SDL_TRUE);
+    }
+}
+
+static void ImGui_ImplSDL2_UpdateGamepads()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    memset(io.NavInputs, 0, sizeof(io.NavInputs));
+    if ((io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad) == 0)
+        return;
+
+    // Get gamepad
+    SDL_GameController* game_controller = SDL_GameControllerOpen(0);
+    if (!game_controller)
+    {
+        io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad;
+        return;
+    }
+
+    // Update gamepad inputs
+    #define MAP_BUTTON(NAV_NO, BUTTON_NO)       { io.NavInputs[NAV_NO] = (SDL_GameControllerGetButton(game_controller, BUTTON_NO) != 0) ? 1.0f : 0.0f; }
+    #define MAP_ANALOG(NAV_NO, AXIS_NO, V0, V1) { float vn = (float)(SDL_GameControllerGetAxis(game_controller, AXIS_NO) - V0) / (float)(V1 - V0); if (vn > 1.0f) vn = 1.0f; if (vn > 0.0f && io.NavInputs[NAV_NO] < vn) io.NavInputs[NAV_NO] = vn; }
+    const int thumb_dead_zone = 8000;           // SDL_gamecontroller.h suggests using this value.
+    MAP_BUTTON(ImGuiNavInput_Activate,      SDL_CONTROLLER_BUTTON_A);               // Cross / A
+    MAP_BUTTON(ImGuiNavInput_Cancel,        SDL_CONTROLLER_BUTTON_B);               // Circle / B
+    MAP_BUTTON(ImGuiNavInput_Menu,          SDL_CONTROLLER_BUTTON_X);               // Square / X
+    MAP_BUTTON(ImGuiNavInput_Input,         SDL_CONTROLLER_BUTTON_Y);               // Triangle / Y
+    MAP_BUTTON(ImGuiNavInput_DpadLeft,      SDL_CONTROLLER_BUTTON_DPAD_LEFT);       // D-Pad Left
+    MAP_BUTTON(ImGuiNavInput_DpadRight,     SDL_CONTROLLER_BUTTON_DPAD_RIGHT);      // D-Pad Right
+    MAP_BUTTON(ImGuiNavInput_DpadUp,        SDL_CONTROLLER_BUTTON_DPAD_UP);         // D-Pad Up
+    MAP_BUTTON(ImGuiNavInput_DpadDown,      SDL_CONTROLLER_BUTTON_DPAD_DOWN);       // D-Pad Down
+    MAP_BUTTON(ImGuiNavInput_FocusPrev,     SDL_CONTROLLER_BUTTON_LEFTSHOULDER);    // L1 / LB
+    MAP_BUTTON(ImGuiNavInput_FocusNext,     SDL_CONTROLLER_BUTTON_RIGHTSHOULDER);   // R1 / RB
+    MAP_BUTTON(ImGuiNavInput_TweakSlow,     SDL_CONTROLLER_BUTTON_LEFTSHOULDER);    // L1 / LB
+    MAP_BUTTON(ImGuiNavInput_TweakFast,     SDL_CONTROLLER_BUTTON_RIGHTSHOULDER);   // R1 / RB
+    MAP_ANALOG(ImGuiNavInput_LStickLeft,    SDL_CONTROLLER_AXIS_LEFTX, -thumb_dead_zone, -32768);
+    MAP_ANALOG(ImGuiNavInput_LStickRight,   SDL_CONTROLLER_AXIS_LEFTX, +thumb_dead_zone, +32767);
+    MAP_ANALOG(ImGuiNavInput_LStickUp,      SDL_CONTROLLER_AXIS_LEFTY, -thumb_dead_zone, -32767);
+    MAP_ANALOG(ImGuiNavInput_LStickDown,    SDL_CONTROLLER_AXIS_LEFTY, +thumb_dead_zone, +32767);
+
+    io.BackendFlags |= ImGuiBackendFlags_HasGamepad;
+    #undef MAP_BUTTON
+    #undef MAP_ANALOG
+}
+
+void ImGui_ImplSDL2_NewFrame()
+{
+    ImGuiIO& io = ImGui::GetIO();
+    ImGui_ImplSDL2_Data* bd = ImGui_ImplSDL2_GetBackendData();
+    IM_ASSERT(bd != NULL && "Did you call ImGui_ImplSDL2_Init()?");
+
+    // Setup display size (every frame to accommodate for window resizing)
+    int w, h;
+    int display_w, display_h;
+    SDL_GetWindowSize(bd->Window, &w, &h);
+    if (SDL_GetWindowFlags(bd->Window) & SDL_WINDOW_MINIMIZED)
+        w = h = 0;
+    SDL_GL_GetDrawableSize(bd->Window, &display_w, &display_h);
+    io.DisplaySize = ImVec2((float)w, (float)h);
+    if (w > 0 && h > 0)
+        io.DisplayFramebufferScale = ImVec2((float)display_w / w, (float)display_h / h);
+
+    // Setup time step (we don't use SDL_GetTicks() because it is using millisecond resolution)
+    static Uint64 frequency = SDL_GetPerformanceFrequency();
+    Uint64 current_time = SDL_GetPerformanceCounter();
+    io.DeltaTime = bd->Time > 0 ? (float)((double)(current_time - bd->Time) / frequency) : (float)(1.0f / 60.0f);
+    bd->Time = current_time;
+
+    ImGui_ImplSDL2_UpdateMousePosAndButtons();
+    ImGui_ImplSDL2_UpdateMouseCursor();
+
+    // Update game controllers (if enabled and available)
+    ImGui_ImplSDL2_UpdateGamepads();
+}

lib/imgui/src/imgui_sdl.cpp

@@ -0,0 +1,676 @@
+#include "imgui_sdl.h"
+
+#include "SDL2/SDL.h"
+
+#include "imgui.h"
+
+#include <map>
+#include <list>
+#include <cmath>
+#include <array>
+#include <vector>
+#include <memory>
+#include <iostream>
+#include <algorithm>
+#include <functional>
+#include <unordered_map>
+
+namespace
+{
+	struct Device* CurrentDevice = nullptr;
+
+	namespace TupleHash
+	{
+		template <typename T> struct Hash
+		{
+			std::size_t operator()(const T& value) const
+			{
+				return std::hash<T>()(value);
+			}
+		};
+
+		template <typename T> void CombineHash(std::size_t& seed, const T& value)
+		{
+			seed ^= TupleHash::Hash<T>()(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+		}
+
+		template <typename Tuple, std::size_t Index = std::tuple_size<Tuple>::value - 1> struct Hasher
+		{
+			static void Hash(std::size_t& seed, const Tuple& tuple)
+			{
+				Hasher<Tuple, Index - 1>::Hash(seed, tuple);
+				CombineHash(seed, std::get<Index>(tuple));
+			}
+		};
+
+		template <typename Tuple> struct Hasher<Tuple, 0>
+		{
+			static void Hash(std::size_t& seed, const Tuple& tuple)
+			{
+				CombineHash(seed, std::get<0>(tuple));
+			}
+		};
+
+		template <typename... T> struct Hash<std::tuple<T...>>
+		{
+			std::size_t operator()(const std::tuple<T...>& value) const
+			{
+				std::size_t seed = 0;
+				Hasher<std::tuple<T...>>::Hash(seed, value);
+				return seed;
+			}
+		};
+	}
+
+	template <typename Key, typename Value, std::size_t Size> class LRUCache
+	{
+	public:
+		bool Contains(const Key& key) const
+		{
+			return Container.find(key) != Container.end();
+		}
+
+		const Value& At(const Key& key)
+		{
+			assert(Contains(key));
+
+			const auto location = Container.find(key);
+			Order.splice(Order.begin(), Order, location->second);
+			return location->second->second;
+		}
+
+		void Insert(const Key& key, Value value)
+		{
+			const auto existingLocation = Container.find(key);
+			if (existingLocation != Container.end())
+			{
+				Order.erase(existingLocation->second);
+				Container.erase(existingLocation);
+			}
+
+			Order.push_front(std::make_pair(key, std::move(value)));
+			Container.insert(std::make_pair(key, Order.begin()));
+
+			Clean();
+		}
+	private:
+		void Clean()
+		{
+			while (Container.size() > Size)
+			{
+				auto last = Order.end();
+				last--;
+				Container.erase(last->first);
+				Order.pop_back();
+			}
+		}
+
+		std::list<std::pair<Key, Value>> Order;
+		std::unordered_map<Key, decltype(Order.begin()), TupleHash::Hash<Key>> Container;
+	};
+
+	struct Color
+	{
+		const float R, G, B, A;
+
+		explicit Color(uint32_t color)
+			: R(((color >> 0) & 0xff) / 255.0f), G(((color >> 8) & 0xff) / 255.0f), B(((color >> 16) & 0xff) / 255.0f), A(((color >> 24) & 0xff) / 255.0f) { }
+		Color(float r, float g, float b, float a) : R(r), G(g), B(b), A(a) { }
+
+		Color operator*(const Color& c) const { return Color(R * c.R, G * c.G, B * c.B, A * c.A); }
+		Color operator*(float v) const { return Color(R * v, G * v, B * v, A * v); }
+		Color operator+(const Color& c) const { return Color(R + c.R, G + c.G, B + c.B, A + c.A); }
+
+		uint32_t ToInt() const
+		{
+			return	((static_cast<int>(R * 255) & 0xff) << 0)
+				  | ((static_cast<int>(G * 255) & 0xff) << 8)
+				  | ((static_cast<int>(B * 255) & 0xff) << 16)
+				  | ((static_cast<int>(A * 255) & 0xff) << 24);
+		}
+
+		void UseAsDrawColor(SDL_Renderer* renderer) const
+		{
+			SDL_SetRenderDrawColor(renderer,
+				static_cast<uint8_t>(R * 255),
+				static_cast<uint8_t>(G * 255),
+				static_cast<uint8_t>(B * 255),
+				static_cast<uint8_t>(A * 255));
+		}
+	};
+
+	struct Device
+	{
+		SDL_Renderer* Renderer;
+
+		struct ClipRect
+		{
+			int X, Y, Width, Height;
+		} Clip;
+
+		struct TriangleCacheItem
+		{
+			SDL_Texture* Texture = nullptr;
+			int Width = 0, Height = 0;
+
+			~TriangleCacheItem() { if (Texture) SDL_DestroyTexture(Texture); }
+		};
+
+		// You can tweak these to values that you find that work the best.
+		static constexpr std::size_t UniformColorTriangleCacheSize = 512;
+		static constexpr std::size_t GenericTriangleCacheSize = 64;
+
+		// Uniform color is identified by its color and the coordinates of the edges.
+		using UniformColorTriangleKey = std::tuple<uint32_t, int, int, int, int, int, int>;
+		// The generic triangle cache unfortunately has to be basically a full representation of the triangle.
+		// This includes the (offset) vertex positions, texture coordinates and vertex colors.
+		using GenericTriangleVertexKey = std::tuple<int, int, double, double, uint32_t>;
+		using GenericTriangleKey = std::tuple<GenericTriangleVertexKey, GenericTriangleVertexKey, GenericTriangleVertexKey>;
+
+		LRUCache<UniformColorTriangleKey, std::unique_ptr<TriangleCacheItem>, UniformColorTriangleCacheSize> UniformColorTriangleCache;
+		LRUCache<GenericTriangleKey, std::unique_ptr<TriangleCacheItem>, GenericTriangleCacheSize> GenericTriangleCache;
+
+		Device(SDL_Renderer* renderer) : Renderer(renderer) { }
+
+		void SetClipRect(const ClipRect& rect)
+		{
+			Clip = rect;
+			const SDL_Rect clip = { rect.X, rect.Y, rect.Width, rect.Height };
+			SDL_RenderSetClipRect(Renderer, &clip);
+		}
+
+		void EnableClip() { SetClipRect(Clip); }
+		void DisableClip() { SDL_RenderSetClipRect(Renderer, nullptr); }
+
+		void SetAt(int x, int y, const Color& color)
+		{
+			color.UseAsDrawColor(Renderer);
+			SDL_RenderDrawPoint(Renderer, x, y);
+		}
+
+		SDL_Texture* MakeTexture(int width, int height)
+		{
+			SDL_Texture* texture = SDL_CreateTexture(Renderer, SDL_PIXELFORMAT_RGBA32, SDL_TEXTUREACCESS_TARGET, width, height);
+			SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+			return texture;
+		}
+
+		void UseAsRenderTarget(SDL_Texture* texture)
+		{
+			SDL_SetRenderTarget(Renderer, texture);
+			if (texture)
+			{
+				SDL_SetRenderDrawColor(Renderer, 0, 0, 0, 0);
+				SDL_RenderClear(Renderer);
+			}
+		}
+	};
+
+	struct Texture
+	{
+		SDL_Surface* Surface;
+		SDL_Texture* Source;
+
+		~Texture()
+		{
+			SDL_FreeSurface(Surface);
+			SDL_DestroyTexture(Source);
+		}
+
+		Color Sample(float u, float v) const
+		{
+			const int x = static_cast<int>(std::round(u * (Surface->w - 1) + 0.5f));
+			const int y = static_cast<int>(std::round(v * (Surface->h - 1) + 0.5f));
+
+			const int location = y * Surface->w + x;
+			assert(location < Surface->w * Surface->h);
+
+			return Color(static_cast<uint32_t*>(Surface->pixels)[location]);
+		}
+	};
+
+	template <typename T> class InterpolatedFactorEquation
+	{
+	public:
+		InterpolatedFactorEquation(const T& value0, const T& value1, const T& value2, const ImVec2& v0, const ImVec2& v1, const ImVec2& v2)
+			: Value0(value0), Value1(value1), Value2(value2), V0(v0), V1(v1), V2(v2),
+			Divisor((V1.y - V2.y) * (V0.x - V2.x) + (V2.x - V1.x) * (V0.y - V2.y)) { }
+
+		T Evaluate(float x, float y) const
+		{
+			const float w1 = ((V1.y - V2.y) * (x - V2.x) + (V2.x - V1.x) * (y - V2.y)) / Divisor;
+			const float w2 = ((V2.y - V0.y) * (x - V2.x) + (V0.x - V2.x) * (y - V2.y)) / Divisor;
+			const float w3 = 1.0f - w1 - w2;
+
+			return static_cast<T>((Value0 * w1) + (Value1 * w2) + (Value2 * w3));
+		}
+	private:
+		const T Value0;
+		const T Value1;
+		const T Value2;
+
+		const ImVec2& V0;
+		const ImVec2& V1;
+		const ImVec2& V2;
+
+		const float Divisor;
+	};
+
+	struct Rect
+	{
+		float MinX, MinY, MaxX, MaxY;
+		float MinU, MinV, MaxU, MaxV;
+
+		bool IsOnExtreme(const ImVec2& point) const
+		{
+			return (point.x == MinX || point.x == MaxX) && (point.y == MinY || point.y == MaxY);
+		}
+
+		bool UsesOnlyColor() const
+		{
+			const ImVec2& whitePixel = ImGui::GetIO().Fonts->TexUvWhitePixel;
+
+			return MinU == MaxU && MinU == whitePixel.x && MinV == MaxV && MaxV == whitePixel.y;
+		}
+
+		static Rect CalculateBoundingBox(const ImDrawVert& v0, const ImDrawVert& v1, const ImDrawVert& v2)
+		{
+			return Rect{
+				std::min({ v0.pos.x, v1.pos.x, v2.pos.x }),
+				std::min({ v0.pos.y, v1.pos.y, v2.pos.y }),
+				std::max({ v0.pos.x, v1.pos.x, v2.pos.x }),
+				std::max({ v0.pos.y, v1.pos.y, v2.pos.y }),
+				std::min({ v0.uv.x, v1.uv.x, v2.uv.x }),
+				std::min({ v0.uv.y, v1.uv.y, v2.uv.y }),
+				std::max({ v0.uv.x, v1.uv.x, v2.uv.x }),
+				std::max({ v0.uv.y, v1.uv.y, v2.uv.y })
+			};
+		}
+	};
+
+	struct FixedPointTriangleRenderInfo
+	{
+		int X1, X2, X3, Y1, Y2, Y3;
+		int MinX, MaxX, MinY, MaxY;
+
+		static FixedPointTriangleRenderInfo CalculateFixedPointTriangleInfo(const ImVec2& v1, const ImVec2& v2, const ImVec2& v3)
+		{
+			static constexpr float scale = 16.0f;
+
+			const int x1 = static_cast<int>(std::round(v1.x * scale));
+			const int x2 = static_cast<int>(std::round(v2.x * scale));
+			const int x3 = static_cast<int>(std::round(v3.x * scale));
+
+			const int y1 = static_cast<int>(std::round(v1.y * scale));
+			const int y2 = static_cast<int>(std::round(v2.y * scale));
+			const int y3 = static_cast<int>(std::round(v3.y * scale));
+
+			int minX = (std::min({ x1, x2, x3 }) + 0xF) >> 4;
+			int maxX = (std::max({ x1, x2, x3 }) + 0xF) >> 4;
+			int minY = (std::min({ y1, y2, y3 }) + 0xF) >> 4;
+			int maxY = (std::max({ y1, y2, y3 }) + 0xF) >> 4;
+
+			return FixedPointTriangleRenderInfo{ x1, x2, x3, y1, y2, y3, minX, maxX, minY, maxY };
+		}
+	};
+
+	void DrawTriangleWithColorFunction(const FixedPointTriangleRenderInfo& renderInfo, const std::function<Color(float x, float y)>& colorFunction, Device::TriangleCacheItem* cacheItem)
+	{
+		// Implementation source: https://web.archive.org/web/20171128164608/http://forum.devmaster.net/t/advanced-rasterization/6145.
+		// This is a fixed point implementation that rounds to top-left.
+
+		const int deltaX12 = renderInfo.X1 - renderInfo.X2;
+		const int deltaX23 = renderInfo.X2 - renderInfo.X3;
+		const int deltaX31 = renderInfo.X3 - renderInfo.X1;
+
+		const int deltaY12 = renderInfo.Y1 - renderInfo.Y2;
+		const int deltaY23 = renderInfo.Y2 - renderInfo.Y3;
+		const int deltaY31 = renderInfo.Y3 - renderInfo.Y1;
+
+		const int fixedDeltaX12 = deltaX12 << 4;
+		const int fixedDeltaX23 = deltaX23 << 4;
+		const int fixedDeltaX31 = deltaX31 << 4;
+
+		const int fixedDeltaY12 = deltaY12 << 4;
+		const int fixedDeltaY23 = deltaY23 << 4;
+		const int fixedDeltaY31 = deltaY31 << 4;
+
+		const int width = renderInfo.MaxX - renderInfo.MinX;
+		const int height = renderInfo.MaxY - renderInfo.MinY;
+		if (width == 0 || height == 0) return;
+
+		int c1 = deltaY12 * renderInfo.X1 - deltaX12 * renderInfo.Y1;
+		int c2 = deltaY23 * renderInfo.X2 - deltaX23 * renderInfo.Y2;
+		int c3 = deltaY31 * renderInfo.X3 - deltaX31 * renderInfo.Y3;
+
+		if (deltaY12 < 0 || (deltaY12 == 0 && deltaX12 > 0)) c1++;
+		if (deltaY23 < 0 || (deltaY23 == 0 && deltaX23 > 0)) c2++;
+		if (deltaY31 < 0 || (deltaY31 == 0 && deltaX31 > 0)) c3++;
+
+		int edgeStart1 = c1 + deltaX12 * (renderInfo.MinY << 4) - deltaY12 * (renderInfo.MinX << 4);
+		int edgeStart2 = c2 + deltaX23 * (renderInfo.MinY << 4) - deltaY23 * (renderInfo.MinX << 4);
+		int edgeStart3 = c3 + deltaX31 * (renderInfo.MinY << 4) - deltaY31 * (renderInfo.MinX << 4);
+
+		SDL_Texture* cache = CurrentDevice->MakeTexture(width, height);
+		CurrentDevice->DisableClip();
+		CurrentDevice->UseAsRenderTarget(cache);
+
+		for (int y = renderInfo.MinY; y < renderInfo.MaxY; y++)
+		{
+			int edge1 = edgeStart1;
+			int edge2 = edgeStart2;
+			int edge3 = edgeStart3;
+
+			for (int x = renderInfo.MinX; x < renderInfo.MaxX; x++)
+			{
+				if (edge1 > 0 && edge2 > 0 && edge3 > 0)
+				{
+					CurrentDevice->SetAt(x - renderInfo.MinX, y - renderInfo.MinY, colorFunction(x + 0.5f, y + 0.5f));
+				}
+
+				edge1 -= fixedDeltaY12;
+				edge2 -= fixedDeltaY23;
+				edge3 -= fixedDeltaY31;
+			}
+
+			edgeStart1 += fixedDeltaX12;
+			edgeStart2 += fixedDeltaX23;
+			edgeStart3 += fixedDeltaX31;
+		}
+
+		CurrentDevice->UseAsRenderTarget(nullptr);
+		CurrentDevice->EnableClip();
+
+		cacheItem->Texture = cache;
+		cacheItem->Width = width;
+		cacheItem->Height = height;
+	}
+
+	void DrawCachedTriangle(const Device::TriangleCacheItem& triangle, const FixedPointTriangleRenderInfo& renderInfo)
+	{
+		const SDL_Rect destination = { renderInfo.MinX, renderInfo.MinY, triangle.Width, triangle.Height };
+		SDL_RenderCopy(CurrentDevice->Renderer, triangle.Texture, nullptr, &destination);
+	}
+
+	void DrawTriangle(const ImDrawVert& v1, const ImDrawVert& v2, const ImDrawVert& v3, const Texture* texture)
+	{
+		// The naming inconsistency in the parameters is intentional. The fixed point algorithm wants the vertices in a counter clockwise order.
+		const auto& renderInfo = FixedPointTriangleRenderInfo::CalculateFixedPointTriangleInfo(v3.pos, v2.pos, v1.pos);
+
+		// First we check if there is a cached version of this triangle already waiting for us. If so, we can just do a super fast texture copy.
+
+		const auto key = std::make_tuple(
+			std::make_tuple(static_cast<int>(std::round(v1.pos.x)) - renderInfo.MinX, static_cast<int>(std::round(v1.pos.y)) - renderInfo.MinY, v1.uv.x, v1.uv.y, v1.col),
+			std::make_tuple(static_cast<int>(std::round(v2.pos.x)) - renderInfo.MinX, static_cast<int>(std::round(v2.pos.y)) - renderInfo.MinY, v2.uv.x, v2.uv.y, v2.col),
+			std::make_tuple(static_cast<int>(std::round(v3.pos.x)) - renderInfo.MinX, static_cast<int>(std::round(v3.pos.y)) - renderInfo.MinY, v3.uv.x, v3.uv.y, v3.col));
+
+		if (CurrentDevice->GenericTriangleCache.Contains(key))
+		{
+			const auto& cached = CurrentDevice->GenericTriangleCache.At(key);
+			DrawCachedTriangle(*cached, renderInfo);
+
+			return;
+		}
+
+		const InterpolatedFactorEquation<float> textureU(v1.uv.x, v2.uv.x, v3.uv.x, v1.pos, v2.pos, v3.pos);
+		const InterpolatedFactorEquation<float> textureV(v1.uv.y, v2.uv.y, v3.uv.y, v1.pos, v2.pos, v3.pos);
+
+		const InterpolatedFactorEquation<Color> shadeColor(Color(v1.col), Color(v2.col), Color(v3.col), v1.pos, v2.pos, v3.pos);
+
+		auto cached = std::make_unique<Device::TriangleCacheItem>();
+		DrawTriangleWithColorFunction(renderInfo, [&](float x, float y) {
+			const float u = textureU.Evaluate(x, y);
+			const float v = textureV.Evaluate(x, y);
+			const Color sampled = texture->Sample(u, v);
+			const Color shade = shadeColor.Evaluate(x, y);
+
+			return sampled * shade;
+		}, cached.get());
+
+		if (!cached->Texture) return;
+
+		const SDL_Rect destination = { renderInfo.MinX, renderInfo.MinY, cached->Width, cached->Height };
+		SDL_RenderCopy(CurrentDevice->Renderer, cached->Texture, nullptr, &destination);
+
+		CurrentDevice->GenericTriangleCache.Insert(key, std::move(cached));
+	}
+
+	void DrawUniformColorTriangle(const ImDrawVert& v1, const ImDrawVert& v2, const ImDrawVert& v3)
+	{
+		const Color color(v1.col);
+
+		// The naming inconsistency in the parameters is intentional. The fixed point algorithm wants the vertices in a counter clockwise order.
+		const auto& renderInfo = FixedPointTriangleRenderInfo::CalculateFixedPointTriangleInfo(v3.pos, v2.pos, v1.pos);
+
+		const auto key =std::make_tuple(v1.col,
+			static_cast<int>(std::round(v1.pos.x)) - renderInfo.MinX, static_cast<int>(std::round(v1.pos.y)) - renderInfo.MinY,
+			static_cast<int>(std::round(v2.pos.x)) - renderInfo.MinX, static_cast<int>(std::round(v2.pos.y)) - renderInfo.MinY,
+			static_cast<int>(std::round(v3.pos.x)) - renderInfo.MinX, static_cast<int>(std::round(v3.pos.y)) - renderInfo.MinY);
+		if (CurrentDevice->UniformColorTriangleCache.Contains(key))
+		{
+			const auto& cached = CurrentDevice->UniformColorTriangleCache.At(key);
+			DrawCachedTriangle(*cached, renderInfo);
+
+			return;
+		}
+
+		auto cached = std::make_unique<Device::TriangleCacheItem>();
+		DrawTriangleWithColorFunction(renderInfo, [&color](float, float) { return color; }, cached.get());
+
+		if (!cached->Texture) return;
+
+		const SDL_Rect destination = { renderInfo.MinX, renderInfo.MinY, cached->Width, cached->Height };
+		SDL_RenderCopy(CurrentDevice->Renderer, cached->Texture, nullptr, &destination);
+
+		CurrentDevice->UniformColorTriangleCache.Insert(key, std::move(cached));
+	}
+
+	void DrawRectangle(const Rect& bounding, SDL_Texture* texture, int textureWidth, int textureHeight, const Color& color, bool doHorizontalFlip, bool doVerticalFlip)
+	{
+		// We are safe to assume uniform color here, because the caller checks it and and uses the triangle renderer to render those.
+
+		const SDL_Rect destination = {
+			static_cast<int>(bounding.MinX),
+			static_cast<int>(bounding.MinY),
+			static_cast<int>(bounding.MaxX - bounding.MinX),
+			static_cast<int>(bounding.MaxY - bounding.MinY)
+		};
+
+		// If the area isn't textured, we can just draw a rectangle with the correct color.
+		if (bounding.UsesOnlyColor())
+		{
+			color.UseAsDrawColor(CurrentDevice->Renderer);
+			SDL_RenderFillRect(CurrentDevice->Renderer, &destination);
+		}
+		else
+		{
+			// We can now just calculate the correct source rectangle and draw it.
+
+			const SDL_Rect source = {
+				static_cast<int>(bounding.MinU * textureWidth),
+				static_cast<int>(bounding.MinV * textureHeight),
+				static_cast<int>((bounding.MaxU - bounding.MinU) * textureWidth),
+				static_cast<int>((bounding.MaxV - bounding.MinV) * textureHeight)
+			};
+
+			const SDL_RendererFlip flip = static_cast<SDL_RendererFlip>((doHorizontalFlip ? SDL_FLIP_HORIZONTAL : 0) | (doVerticalFlip ? SDL_FLIP_VERTICAL : 0));
+
+			SDL_SetTextureColorMod(texture, static_cast<uint8_t>(color.R * 255), static_cast<uint8_t>(color.G * 255), static_cast<uint8_t>(color.B * 255));
+			SDL_RenderCopyEx(CurrentDevice->Renderer, texture, &source, &destination, 0.0, nullptr, flip);
+		}
+	}
+
+	void DrawRectangle(const Rect& bounding, const Texture* texture, const Color& color, bool doHorizontalFlip, bool doVerticalFlip)
+	{
+		DrawRectangle(bounding, texture->Source, texture->Surface->w, texture->Surface->h, color, doHorizontalFlip, doVerticalFlip);
+	}
+
+	void DrawRectangle(const Rect& bounding, SDL_Texture* texture, const Color& color, bool doHorizontalFlip, bool doVerticalFlip)
+	{
+		int width, height;
+		SDL_QueryTexture(texture, nullptr, nullptr, &width, &height);
+		DrawRectangle(bounding, texture, width, height, color, doHorizontalFlip, doVerticalFlip);
+	}
+}
+
+namespace ImGuiSDL
+{
+	void Initialize(SDL_Renderer* renderer, int windowWidth, int windowHeight)
+	{
+		ImGuiIO& io = ImGui::GetIO();
+		io.DisplaySize.x = static_cast<float>(windowWidth);
+		io.DisplaySize.y = static_cast<float>(windowHeight);
+
+		ImGui::GetStyle().WindowRounding = 0.0f;
+		ImGui::GetStyle().AntiAliasedFill = false;
+		ImGui::GetStyle().AntiAliasedLines = false;
+
+		// Loads the font texture.
+		unsigned char* pixels;
+		int width, height;
+		io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
+		static constexpr uint32_t rmask = 0x000000ff, gmask = 0x0000ff00, bmask = 0x00ff0000, amask = 0xff000000;
+		SDL_Surface* surface = SDL_CreateRGBSurfaceFrom(pixels, width, height, 32, 4 * width, rmask, gmask, bmask, amask);
+
+		Texture* texture = new Texture();
+		texture->Surface = surface;
+		texture->Source = SDL_CreateTextureFromSurface(renderer, surface);
+		io.Fonts->TexID = (void*)texture;
+
+		CurrentDevice = new Device(renderer);
+	}
+
+	void Deinitialize()
+	{
+		// Frees up the memory of the font texture.
+		ImGuiIO& io = ImGui::GetIO();
+		Texture* texture = static_cast<Texture*>(io.Fonts->TexID);
+		delete texture;
+
+		delete CurrentDevice;
+	}
+
+	void Render(ImDrawData* drawData)
+	{
+		SDL_BlendMode blendMode;
+		SDL_GetRenderDrawBlendMode(CurrentDevice->Renderer, &blendMode);
+		SDL_SetRenderDrawBlendMode(CurrentDevice->Renderer, SDL_BLENDMODE_BLEND);
+
+		Uint8 initialR, initialG, initialB, initialA;
+		SDL_GetRenderDrawColor(CurrentDevice->Renderer, &initialR, &initialG, &initialB, &initialA);
+
+		SDL_bool initialClipEnabled = SDL_RenderIsClipEnabled(CurrentDevice->Renderer);
+		SDL_Rect initialClipRect;
+		SDL_RenderGetClipRect(CurrentDevice->Renderer, &initialClipRect);
+
+		SDL_Texture* initialRenderTarget = SDL_GetRenderTarget(CurrentDevice->Renderer);
+
+		ImGuiIO& io = ImGui::GetIO();
+
+		for (int n = 0; n < drawData->CmdListsCount; n++)
+		{
+			auto commandList = drawData->CmdLists[n];
+			auto vertexBuffer = commandList->VtxBuffer;
+			auto indexBuffer = commandList->IdxBuffer.Data;
+
+			for (int cmd_i = 0; cmd_i < commandList->CmdBuffer.Size; cmd_i++)
+			{
+				const ImDrawCmd* drawCommand = &commandList->CmdBuffer[cmd_i];
+
+				const Device::ClipRect clipRect = {
+					static_cast<int>(drawCommand->ClipRect.x),
+					static_cast<int>(drawCommand->ClipRect.y),
+					static_cast<int>(drawCommand->ClipRect.z - drawCommand->ClipRect.x),
+					static_cast<int>(drawCommand->ClipRect.w - drawCommand->ClipRect.y)
+				};
+				CurrentDevice->SetClipRect(clipRect);
+
+				if (drawCommand->UserCallback)
+				{
+					drawCommand->UserCallback(commandList, drawCommand);
+				}
+				else
+				{
+					const bool isWrappedTexture = drawCommand->TextureId == io.Fonts->TexID;
+
+					// Loops over triangles.
+					for (unsigned int i = 0; i + 3 <= drawCommand->ElemCount; i += 3)
+					{
+						const ImDrawVert& v0 = vertexBuffer[indexBuffer[i + 0]];
+						const ImDrawVert& v1 = vertexBuffer[indexBuffer[i + 1]];
+						const ImDrawVert& v2 = vertexBuffer[indexBuffer[i + 2]];
+
+						const Rect& bounding = Rect::CalculateBoundingBox(v0, v1, v2);
+
+						const bool isTriangleUniformColor = v0.col == v1.col && v1.col == v2.col;
+						const bool doesTriangleUseOnlyColor = bounding.UsesOnlyColor();
+
+						// Actually, since we render a whole bunch of rectangles, we try to first detect those, and render them more efficiently.
+						// How are rectangles detected? It's actually pretty simple: If all 6 vertices lie on the extremes of the bounding box,
+						// it's a rectangle.
+						if (i + 6 <= drawCommand->ElemCount)
+						{
+							const ImDrawVert& v3 = vertexBuffer[indexBuffer[i + 3]];
+							const ImDrawVert& v4 = vertexBuffer[indexBuffer[i + 4]];
+							const ImDrawVert& v5 = vertexBuffer[indexBuffer[i + 5]];
+
+							const bool isUniformColor = isTriangleUniformColor && v2.col == v3.col && v3.col == v4.col && v4.col == v5.col;
+
+							if (isUniformColor
+							&& bounding.IsOnExtreme(v0.pos)
+							&& bounding.IsOnExtreme(v1.pos)
+							&& bounding.IsOnExtreme(v2.pos)
+							&& bounding.IsOnExtreme(v3.pos)
+							&& bounding.IsOnExtreme(v4.pos)
+							&& bounding.IsOnExtreme(v5.pos))
+							{
+								// ImGui gives the triangles in a nice order: the first vertex happens to be the topleft corner of our rectangle.
+								// We need to check for the orientation of the texture, as I believe in theory ImGui could feed us a flipped texture,
+								// so that the larger texture coordinates are at topleft instead of bottomright.
+								// We don't consider equal texture coordinates to require a flip, as then the rectangle is mostlikely simply a colored rectangle.
+								const bool doHorizontalFlip = v2.uv.x < v0.uv.x;
+								const bool doVerticalFlip = v2.uv.x < v0.uv.x;
+
+								if (isWrappedTexture)
+								{
+									DrawRectangle(bounding, static_cast<const Texture*>(drawCommand->TextureId), Color(v0.col), doHorizontalFlip, doVerticalFlip);
+								}
+								else
+								{
+									DrawRectangle(bounding, static_cast<SDL_Texture*>(drawCommand->TextureId), Color(v0.col), doHorizontalFlip, doVerticalFlip);
+								}
+
+								i += 3;  // Additional increment to account for the extra 3 vertices we consumed.
+								continue;
+							}
+						}
+
+						if (isTriangleUniformColor && doesTriangleUseOnlyColor)
+						{
+							DrawUniformColorTriangle(v0, v1, v2);
+						}
+						else
+						{
+							// Currently we assume that any non rectangular texture samples the font texture. Dunno if that's what actually happens, but it seems to work.
+							assert(isWrappedTexture);
+							DrawTriangle(v0, v1, v2, static_cast<const Texture*>(drawCommand->TextureId));
+						}
+					}
+				}
+
+				indexBuffer += drawCommand->ElemCount;
+			}
+		}
+
+		CurrentDevice->DisableClip();
+
+		SDL_SetRenderTarget(CurrentDevice->Renderer, initialRenderTarget);
+
+		SDL_RenderSetClipRect(CurrentDevice->Renderer, initialClipEnabled ? &initialClipRect : nullptr);
+
+		SDL_SetRenderDrawColor(CurrentDevice->Renderer,
+			initialR, initialG, initialB, initialA);
+
+		SDL_SetRenderDrawBlendMode(CurrentDevice->Renderer, blendMode);
+	}
+}

readme.md

@@ -0,0 +1,29 @@
+# Bytepusher++
+
+This is an implementation of the [Bytepusher](https://esolangs.org/wiki/BytePusher) fantasy console in C++ and SDL2, complete with a humble debug interface written in ImGui inspired by [Lauchmelder](https://github.com/Lauchmelder23)'s [GameBoy emulator](https://github.com/Lauchmelder23/yabgbe).
+
+![A screenshot of Bytepusher++ running the nyan.bp program](screenshot.png)
+
+I only tested this on a Mac, but considering all dependencies are platform-agnostic there shouldn't be any issues running this on Windows or Linux.
+
+I tried to document best to my abilities how each component works in its respective header file, so I won't write more about how the Bytepusher works here. The 16 controller keys are mapped to 1234QWERASDFZXCV -- you can test them out with the "Keyboard Test.bytepusher" ROM.
+
+You can take snapshots of the RAM with the "Debug -> Snapshot RAM" button. They will be saved to the "snapshots" directory in the project and will be named with the format `<date of VM bootup>: <number of snapshot>.bytepusher`.
+
+## Building and running
+You can build the project using [Click](https://github.com/c1m5j/click), a one-command C/C++ build tool made by me. Once you're in the project directory just run `click`. The binary will be outputted to the "build" directory (unless you specify a different one in click.toml).
+
+Run the binary without any console arguments, because the ROMs are loaded in the interface using a file dialog (ImGuiFileDialog by aiekick).
+
+There are some ROMs in the "roms" directory which I got from the Esolangs page and [JonathanDC64's implementation](https://github.com/JonathanDC64/BytePusher) (because not all links on the Esolangs page worked), you can use them or choose your own. Those which are in "roms" have been all tested and each works correctly.
+
+## Acknowledgments
+Built with
+* [SDL2](https://www.libsdl.org/download-2.0.php), 
+* [ImGui](https://github.com/ocornut/imgui),
+* [imgui_sdl](https://github.com/Tyyppi77/imgui_sdl),
+* and [ImGuiFileDialog](https://github.com/aiekick/ImGuiFileDialog) (had to tweak some code to make the Cancel button work).
+
+I wasn't sure how to implement the audio (this is my first "real" project with SDL), so I looked into David Jolly (majestic53)'s [bpvm](https://github.com/majestic53/bpvm), an awesome and professional implementation of the Bytepusher. As a result of that some audio-related code may look similar, but I never explicitly copied any. A great thanks to David for bpvm!
+
+Credit also goes to Lauchmelder for helping me with some SDL (and other) bugs I would've never found myself.

snapshots/readme.md

@@ -0,0 +1 @@
+RAM snapshots taken with the "Debug -> Snapshot RAM" button will be stored in this directory.

src/audio.cpp

@@ -0,0 +1,40 @@
+#include <iostream>
+#include "memory.hpp"
+#include "audio.hpp"
+#include "bus.hpp"
+
+Audio::Audio(Bus* bus): bus(bus), spec({}), device(0)
+{   
+    SDL_AudioSpec spec = {};
+    spec.freq = 15360;
+    spec.format = AUDIO_U8;
+    spec.channels = 1;
+    spec.samples = 256;
+
+    this->device = SDL_OpenAudioDevice(nullptr, 0, &spec, &this->spec, 0);
+    if (!this->device) {
+        std::cerr << "I had trouble creating the audio device!\nSDL error: " << SDL_GetError() << std::endl;
+        exit(1);
+    }
+    SDL_PauseAudioDevice(this->device, 0);
+}
+
+Audio::~Audio()
+{
+    if (this->device) {
+        SDL_PauseAudioDevice(this->device, 1);
+        SDL_CloseAudioDevice(this->device);
+        this->device = 0;
+    }
+    this->spec = {};
+    this->bus = nullptr;
+}
+
+void Audio::Play()
+{
+    uint32_t location = (uint32_t)this->bus->memory->mem[6] << 16 | this->bus->memory->mem[7] << 8;
+    
+    if (SDL_QueueAudio(this->device, this->bus->memory->mem + location, 256)) {
+        std::cerr << "I had trouble playing audio!\nSDL error: " << SDL_GetError() << std::endl;
+    }
+}

src/bus.cpp

@@ -0,0 +1,13 @@
+#include "bus.hpp"
+
+Bus::Bus(): memory(nullptr), cpu(nullptr), display(nullptr), audio(nullptr), input(nullptr)
+{}
+
+Bus::~Bus()
+{
+    this->memory = nullptr;
+    this->cpu = nullptr;
+    this->display = nullptr;
+    this->audio = nullptr;
+    this->input = nullptr;
+}

src/cpu.cpp

@@ -0,0 +1,49 @@
+#include "cpu.hpp"
+#include "bus.hpp"
+#include "memory.hpp"
+
+// i'm sorry but there's no way i'm typing this every time i want to access memory
+// (which is a lot of times in this file)
+#define MEMORY this->bus->memory->mem
+
+CPU::CPU(Bus* bus): bus(bus)
+{
+    this->Reset();
+}
+
+CPU::~CPU()
+{
+    this->bus = nullptr;
+}
+
+void CPU::Step()
+{
+    uint32_t destination = (uint32_t)this->pc[3] << 16 | (uint32_t)this->pc[4] << 8 | this->pc[5];
+    uint32_t source =      (uint32_t)this->pc[0] << 16 | (uint32_t)this->pc[1] << 8 | this->pc[2];
+    uint32_t jump =        (uint32_t)this->pc[6] << 16 | (uint32_t)this->pc[7] << 8 | this->pc[8];
+
+    MEMORY[destination] = MEMORY[source];
+    this->pc = MEMORY + jump;
+}
+
+void CPU::Reset()
+{
+    this->pc = MEMORY + ((uint32_t)MEMORY[2]<<16 | (uint32_t)MEMORY[3]<<8 | MEMORY[4]);
+}
+
+void CPU::setKeyBit(uint8_t index)
+{
+    uint32_t* keyboard = (uint32_t*)MEMORY;
+    if (index < 8) *keyboard |= 1 << (index + 8);
+    else *keyboard |= 1 << (index - 8);
+}
+
+void CPU::clearKeyBit(uint8_t index)
+{
+    uint32_t* keyboard = (uint32_t*)MEMORY;
+    if (index < 8) *keyboard &= ~(1 << (index + 8));
+    else *keyboard &= ~(1 << (index - 8));
+}
+
+#undef MEMORY
+// goodbye

src/display.cpp

@@ -0,0 +1,55 @@
+#include <iostream>
+#include "memory.hpp"
+#include "display.hpp"
+#include "bus.hpp"
+
+Display::Display(Bus* bus, SDL_Renderer* ren): bus(bus)
+{
+    this->Reset();
+    this->displayTexture = SDL_CreateTexture(ren, SDL_PIXELFORMAT_ABGR8888, SDL_TEXTUREACCESS_STREAMING, width, height);
+	if (!displayTexture) {
+        std::cerr << "Texture creation error: " << SDL_GetError() << std::endl;
+		exit(1);
+	}
+	this->PrepareColorPalette();
+}
+
+void Display::Reset()
+{
+	for (auto& el: this->display) el = {0, 0, 0, 255};
+}
+
+void Display::PrepareColorPalette()
+{
+	size_t i = 0;
+
+	for (size_t r = 0; r < 256; r += 0x33) {
+		for (size_t g = 0; g < 256; g += 0x33) {
+			for (size_t b = 0; b < 256; b += 0x33) {
+				this->colorPalette[i].r = r;
+				this->colorPalette[i].g = g;
+				this->colorPalette[i].b = b;
+				
+				i++;
+			}
+		}
+	}
+}
+
+void Display::UpdateTexture()
+{
+	uint32_t location = (uint32_t)this->bus->memory->mem[5];
+
+	for (size_t y = 0; y < 256; y++) {
+		for (size_t x = 0; x < 256; x++) {
+			this->display[(y * 256) + x] = this->colorPalette[this->bus->memory->mem[location << 16 | y << 8 | x ]];
+		}
+	}
+
+	SDL_UpdateTexture(this->displayTexture, NULL, display, width * 4);
+}
+
+Display::~Display()
+{
+    SDL_DestroyTexture(this->displayTexture);
+}

src/input.cpp

@@ -0,0 +1,74 @@
+#include "input.hpp"
+#include "memory.hpp"
+#include "bus.hpp"
+
+Input::Input(Bus* bus): bus(bus) {}
+
+Input::~Input()
+{
+    this->bus = nullptr;
+}
+
+void Input::HandleKeyDown(SDL_Keycode keycode)
+{
+    switch (keycode)
+    {
+    case SDLK_1: this->SetKeyBit(1); break;
+	case SDLK_2: this->SetKeyBit(2); break;
+	case SDLK_3: this->SetKeyBit(3); break;
+    case SDLK_4: this->SetKeyBit(12); break;
+    case SDLK_q: this->SetKeyBit(4); break;
+    case SDLK_w: this->SetKeyBit(5); break;
+    case SDLK_e: this->SetKeyBit(6); break;
+    case SDLK_r: this->SetKeyBit(13); break;
+    case SDLK_a: this->SetKeyBit(7); break;
+    case SDLK_s: this->SetKeyBit(8); break;
+    case SDLK_d: this->SetKeyBit(9); break;
+    case SDLK_f: this->SetKeyBit(14); break;
+    case SDLK_z: this->SetKeyBit(10); break;
+    case SDLK_x: this->SetKeyBit(0); break;
+    case SDLK_c: this->SetKeyBit(11); break;
+    case SDLK_v: this->SetKeyBit(15); break;
+    
+    default: break;
+    }
+}
+
+void Input::HandleKeyUp(SDL_Keycode keycode)
+{
+    switch (keycode)
+    {
+    case SDLK_1: this->UnsetKeyBit(1); break;
+    case SDLK_2: this->UnsetKeyBit(2); break;
+    case SDLK_3: this->UnsetKeyBit(3); break;
+    case SDLK_4: this->UnsetKeyBit(12); break;
+    case SDLK_q: this->UnsetKeyBit(4); break;
+    case SDLK_w: this->UnsetKeyBit(5); break;
+    case SDLK_e: this->UnsetKeyBit(6); break;
+    case SDLK_r: this->UnsetKeyBit(13); break;
+    case SDLK_a: this->UnsetKeyBit(7); break;
+    case SDLK_s: this->UnsetKeyBit(8); break;
+    case SDLK_d: this->UnsetKeyBit(9); break;
+    case SDLK_f: this->UnsetKeyBit(14); break;
+    case SDLK_z: this->UnsetKeyBit(10); break;
+    case SDLK_x: this->UnsetKeyBit(0); break;
+    case SDLK_c: this->UnsetKeyBit(11); break;
+    case SDLK_v: this->UnsetKeyBit(15); break;
+    
+    default: break;
+    }
+}
+
+void Input::SetKeyBit(uint8_t bit)
+{
+    uint32_t* keyboard = (uint32_t*)this->bus->memory->mem;
+    if (bit < 8) *keyboard |= (1 << (bit + 8));
+    else *keyboard |= (1 << (bit - 8));
+}
+
+void Input::UnsetKeyBit(uint8_t bit)
+{
+    uint32_t* keyboard = (uint32_t*)this->bus->memory->mem;
+    if (bit < 8) *keyboard &= ~(1 << (bit + 8));
+    else *keyboard &= ~(1 << (bit - 8));
+}

src/main.cpp

@@ -0,0 +1,247 @@
+#include <iostream>
+#include <filesystem>
+#include <bitset>
+#include <SDL2/SDL.h>
+#include <imgui.h>
+#include <ImGuiFileDialog.h>
+#include <imgui_sdl.h>
+#include <ctime>
+
+#include "bus.hpp"
+#include "cpu.hpp"
+#include "display.hpp"
+#include "audio.hpp"
+#include "memory.hpp"
+#include "input.hpp"
+
+#define MILLISECONDS std::milli::den
+#define FRAMERATE 60.0f
+#define FRAMELENGTH (MILLISECONDS / FRAMERATE)
+
+int main(int argc, char const *argv[])
+{
+	// SDL initialisation
+    SDL_Init(SDL_INIT_EVERYTHING);
+
+	SDL_Window* window = SDL_CreateWindow("Bytepusher++", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1000, 700, SDL_WINDOW_RESIZABLE);
+	SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
+
+	// VM initialisation
+	Bus* bus = new Bus();
+
+	Memory* memory = new Memory(bus);
+	bus->memory = memory;
+
+    CPU* cpu = new CPU(bus);
+	bus->cpu = cpu;
+
+	Display* display = new Display(bus, renderer);
+	bus->display = display;
+
+	Audio* audio = new Audio(bus);
+	bus->audio = audio;
+
+	Input* input = new Input(bus);
+	bus->input = input;
+
+	ImGui::CreateContext();
+	ImGuiSDL::Initialize(renderer, 900, 700);
+    ImGui::StyleColorsDark();
+
+	// Clears screen
+	SDL_Texture* clear = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA32, SDL_TEXTUREACCESS_TARGET, 100, 100);
+	{
+		SDL_SetRenderTarget(renderer, clear);
+		SDL_SetRenderDrawColor(renderer, 255, 0, 255, 255);
+		SDL_RenderClear(renderer);
+		SDL_SetRenderTarget(renderer, nullptr);
+	}
+
+	std::time_t res = std::time(nullptr);
+	std::string date = std::ctime(&res);
+	date = date.substr(0, date.length() - 1);
+	int snapshotIncrement = 1;
+
+	bool run = true;
+	bool paused = false;
+
+	bool showBytepusher = true;
+	bool showDebug = true;
+
+	while (run)
+	{
+		size_t begin = SDL_GetTicks();
+
+		ImGuiIO& io = ImGui::GetIO();
+
+		int wheel = 0;
+
+		SDL_Event e;
+		while (SDL_PollEvent(&e))
+		{
+			if (e.type == SDL_QUIT) run = false;
+
+			else if (e.type == SDL_KEYDOWN) {
+				if (!paused && memory->ROMLoaded)
+				input->HandleKeyDown(e.key.keysym.sym);
+			} else if (e.type == SDL_KEYUP) {
+				input->HandleKeyUp(e.key.keysym.sym);
+			} else if (e.type == SDL_WINDOWEVENT) {
+				if (e.window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
+					io.DisplaySize.x = static_cast<float>(e.window.data1);
+					io.DisplaySize.y = static_cast<float>(e.window.data2);
+				}
+			} else if (e.type == SDL_MOUSEWHEEL) {
+				wheel = e.wheel.y;
+			}
+		}
+
+		int mouseX, mouseY;
+		const int buttons = SDL_GetMouseState(&mouseX, &mouseY);
+
+		// Setup low-level inputs (e.g. on Win32, GetKeyboardState(), or write to those fields from your Windows message loop handlers, etc.)
+		
+		io.DeltaTime = 1.0f / 60.0f;
+		io.MousePos = ImVec2(static_cast<float>(mouseX), static_cast<float>(mouseY));
+		io.MouseDown[0] = buttons & SDL_BUTTON(SDL_BUTTON_LEFT);
+		io.MouseDown[1] = buttons & SDL_BUTTON(SDL_BUTTON_RIGHT);
+		io.MouseWheel = static_cast<float>(wheel);
+
+		// Bytepusher code
+		if (!paused && memory->ROMLoaded) {
+			cpu->Reset();
+			size_t i = 65536;
+			do {
+				cpu->Step();
+			} while (i--);
+			audio->Play();
+			display->UpdateTexture();
+		}
+
+		// ImGui code
+
+		ImGui::NewFrame();
+		// window minimizers
+
+		if (ImGui::BeginMainMenuBar()) {
+			if (ImGui::BeginMenu("File")) {
+				if (ImGui::MenuItem("Open")) {
+					ImGuiFileDialog::Instance()->OpenDialog("ChooseFileDlgKey", "Choose BytePusher ROM", ".bytepusher,.bp", "", 1);
+				}
+				if (ImGui::MenuItem("Close ROM")) {
+					memory->Reset();
+					display->Reset();
+					display->UpdateTexture();
+				}
+				if (ImGui::MenuItem("Quit")) {
+					run = false;
+				}
+				ImGui::EndMenu();
+			}
+			if (ImGui::BeginMenu("Debug")) {
+				ImGui::Checkbox("Show debug window", &showDebug);
+				ImGui::Separator();
+				if (ImGui::MenuItem(paused? "Resume emulation###pausebtn" : "Pause emulation###pausebtn")) {
+					paused = !paused;
+				}
+				if (ImGui::MenuItem("Snapshot RAM")) {
+					// candidate for ugliest piece of code in history?
+					std::string filepath = std::filesystem::path(argv[0])
+					.parent_path()
+					.parent_path()
+					.string() 
+					+ "/snapshots/" 
+					+ date 
+					+ ": " 
+					+ std::to_string(snapshotIncrement) 
+					+ ".bytepusher";
+
+					if (!memory->SnapshotRAM(filepath)) {
+						if (ImGui::BeginPopupModal("RAM snapshotting error")) {
+							ImGui::TextColored(ImVec4(1.0f, 0.0f, 0.0f, 1.0f), "%s", memory->snapshotError.c_str());
+							ImGui::EndPopup();
+						}
+					}
+					snapshotIncrement++;
+				}
+				ImGui::EndMenu();
+			}
+			ImGui::EndMainMenuBar();
+		}
+		if (ImGuiFileDialog::Instance()->Display("ChooseFileDlgKey")) {
+			if (ImGuiFileDialog::Instance()->IsOk()) {
+				std::string filePathName = ImGuiFileDialog::Instance()->GetFilePathName();
+				ImGuiFileDialog::Instance()->Close();
+				if (!memory->LoadROM(filePathName)) {
+					if (ImGui::BeginPopupModal("ROM loading error")) {
+						ImGui::TextColored(ImVec4(1.0f, 0.0f, 0.0f, 1.0f), "%s", memory->ROMLoadError.c_str());
+						ImGui::EndPopup();
+					}
+				}
+			}
+		}
+		
+		if (showDebug) {
+			ImGui::Begin("Debug", &showDebug, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize);
+			ImGui::Text("-- ROM info --");
+			if (ImGui::BeginTable("ROM info", 2)) {
+				ImGui::TableNextColumn(); ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f), "Has loaded ROM");
+				ImGui::TableNextColumn(); ImGui::Text(memory->ROMLoaded? "Yes" : "No");
+				ImGui::TableNextColumn(); ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f), "ROM name");
+				ImGui::TableNextColumn(); ImGui::Text("%s", std::filesystem::path(memory->ROMFilepath).filename().c_str());
+				ImGui::TableNextColumn(); ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f), "ROM size");
+				ImGui::TableNextColumn(); ImGui::Text("%zu B", memory->ROMSize);
+				ImGui::TableNextColumn(); ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f), "Is paused");
+				ImGui::TableNextColumn(); ImGui::Text(paused? "Yes" : "No");
+				ImGui::EndTable();
+			}
+			ImGui::Separator();
+			ImGui::Text("-- Emulation info --");
+			if (ImGui::BeginTable("Emulation info", 2)) {
+				ImGui::TableNextColumn(); ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f), "Keyboard state");
+				ImGui::TableNextColumn(); ImGui::Text("%s", std::bitset<16>((uint32_t)memory->mem[0] << 8 | memory->mem[1]).to_string().c_str());
+				ImGui::TableNextColumn(); ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f), "GFX block location");
+				ImGui::TableNextColumn(); ImGui::Text("0x%02x", memory->mem[5]);
+				ImGui::TableNextColumn(); ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f), "Sound block location");
+				ImGui::TableNextColumn(); ImGui::Text("0x%06x", (uint32_t)memory->mem[6] << 16 | memory->mem[7] << 8);
+				ImGui::TableNextColumn(); ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.0f), "Memory errors");
+				ImGui::TableNextColumn(); ImGui::Text("%s\n%s", memory->ROMLoadError.c_str(), memory->snapshotError.c_str());
+				ImGui::EndTable();
+			}
+			ImGui::End();
+		}
+
+		ImGui::Begin(paused? "[PAUSED] Bytepusher###bptitle" : "Bytepusher###bptitle", &showBytepusher, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize);
+		ImGui::Image(display->displayTexture, ImVec2(512, 512));
+		ImGui::End();
+
+		SDL_SetRenderDrawColor(renderer, 114, 144, 154, 255);
+		SDL_RenderClear(renderer);
+
+		ImGui::Render();
+		ImGuiSDL::Render(ImGui::GetDrawData());
+
+		SDL_RenderPresent(renderer);
+
+		size_t length = SDL_GetTicks() - begin;
+		if (length < FRAMELENGTH) {
+			SDL_Delay(FRAMELENGTH - length);
+		}
+	}
+
+	ImGuiSDL::Deinitialize();
+
+	SDL_DestroyTexture(clear);
+	SDL_DestroyRenderer(renderer);
+	SDL_DestroyWindow(window);
+
+    delete cpu;
+	delete memory;
+	delete display;
+	delete audio;
+
+	delete bus;
+	ImGui::DestroyContext();
+	
+	return EXIT_SUCCESS;
+}

src/memory.cpp

@@ -0,0 +1,68 @@
+#include <iostream>
+#include <filesystem>
+#include <fstream>
+#include <ctime>
+#include "memory.hpp"
+#include "bus.hpp"
+
+Memory::Memory(Bus* bus): bus(bus)
+{
+    this->Reset();
+}
+
+Memory::~Memory()
+{
+    this->bus = nullptr;
+}
+
+void Memory::Reset()
+{
+    this->ROMLoaded = false;
+    this->ROMFilepath = "";
+    this->ROMSize = 0;
+    this->ROMLoadError = "";
+    this->snapshotError = "";
+    this->snapshotLast = "";
+    for (auto& el: this->mem) el = 0;
+}
+
+bool Memory::LoadROM(std::string filepath)
+{
+    std::fstream stream(filepath, std::ios::in|std::ios::binary);
+    if (stream) {
+        size_t filesize = std::filesystem::file_size(filepath);
+        if (filesize > MEMORY_SIZE) {
+            std::cerr << "Error: chosen ROM is larger than RAM" << std::endl;
+            this->ROMLoadError = "Error: chosen ROM is larger than RAM";
+            return 0;
+        }
+        stream.read((char*)this->mem, filesize);
+        this->ROMLoaded = true;
+        this->ROMFilepath = filepath;
+        this->ROMSize = filesize;
+        this->ROMLoadError = "";
+        stream.close();
+        return 1;
+    } else {
+        std::cerr << "Error: ROM could not be found or opened" << std::endl;
+        this->ROMLoadError = "Error: ROM could not be found or opened";
+        return 0;
+    }
+}
+
+bool Memory::SnapshotRAM(std::string filepath)
+{
+    std::fstream stream(filepath, std::ios::out|std::ios::binary);
+    if (stream) {
+        stream.write((char*)this->mem, MEMORY_SIZE);
+        this->snapshotError = "";
+        std::time_t res = std::time(nullptr);
+        this->snapshotLast = std::ctime(&res);
+        stream.close();
+        return 1;
+    } else {
+        std::cerr << "Error: could not write RAM contents to filepath " << filepath << std::endl;
+        this->snapshotError = "Error: could not write RAM contents to filepath " + filepath;
+        return 0;
+    }
+}