File melonds_compute-shader-renderer_brokenHEAD.patch of Package melonds

Overview Repositories Revisions Requests Users Attributes Meta

File melonds_compute-shader-renderer_brokenHEAD.patch of Package melonds (Revision 7ca5d881ec794a7407960d48f0a38550)

Currently displaying revision 7ca5d881ec794a7407960d48f0a38550 , Show latest

From f4e5edc7273c728ce7bdc3fec315ed49fd3a217a Mon Sep 17 00:00:00 2001
From: v-fox <virtuousfox@gmail.com>
Date: Tue, 29 Aug 2023 14:20:01 +0500
Subject: [PATCH] compute shader renderer

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 210e280..9a19392 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -33,6 +33,8 @@ add_library(core STATIC
     GPU2D_Soft.cpp
     GPU3D.cpp
     GPU3D_Soft.cpp
+    GPU3D_Texcache.cpp
+    GPU3D_Texcache.h
     melonDLDI.h
     NDS.cpp
     NDSCart.cpp
@@ -64,6 +66,9 @@ if (ENABLE_OGLRENDERER)
         GPU_OpenGL.cpp
         GPU_OpenGL_shaders.h
         GPU3D_OpenGL.cpp
+        GPU3D_Compute.cpp
+        GPU3D_TexcacheOpenGL.cpp
+        GPU3D_TexcacheOpenGL.h
         GPU3D_OpenGL_shaders.h
         OpenGLSupport.cpp)
 
diff --git a/src/DMA.cpp b/src/DMA.cpp
index d296511..7d54b41 100644
--- a/src/DMA.cpp
+++ b/src/DMA.cpp
@@ -21,6 +21,7 @@
 #include "DSi.h"
 #include "DMA.h"
 #include "GPU.h"
+#include "GPU3D.h"
 #include "DMA_Timings.h"
 #include "Platform.h"
 
diff --git a/src/DSi_NDMA.cpp b/src/DSi_NDMA.cpp
index dba920c..4db18f3 100644
--- a/src/DSi_NDMA.cpp
+++ b/src/DSi_NDMA.cpp
@@ -22,6 +22,7 @@
 #include "DSi_NDMA.h"
 #include "GPU.h"
 #include "DSi_AES.h"
+#include "GPU3D.h"
 
 using Platform::Log;
 using Platform::LogLevel;
diff --git a/src/GPU.cpp b/src/GPU.cpp
index f51748b..af691a9 100644
--- a/src/GPU.cpp
+++ b/src/GPU.cpp
@@ -25,6 +25,7 @@
 #endif
 
 #include "GPU2D_Soft.h"
+#include "GPU3D.h"
 
 using Platform::Log;
 using Platform::LogLevel;
@@ -386,7 +387,7 @@ void AssignFramebuffers()
 void InitRenderer(int renderer)
 {
 #ifdef OGLRENDERER_ENABLED
-    if (renderer == 1)
+    if (renderer != renderer3D_Software)
     {
         CurGLCompositor = std::make_unique<GLCompositor>();
         // Create opengl rendrerer
@@ -397,7 +398,10 @@ void InitRenderer(int renderer)
             GPU3D::CurrentRenderer = std::make_unique<GPU3D::SoftRenderer>();
             GPU3D::CurrentRenderer->Init();
         }
-        GPU3D::CurrentRenderer = std::make_unique<GPU3D::GLRenderer>();
+        if (renderer == renderer3D_OpenGL)
+            GPU3D::CurrentRenderer = std::make_unique<GPU3D::GLRenderer>();
+        else
+            GPU3D::CurrentRenderer = std::make_unique<GPU3D::ComputeRenderer>();
         if (!GPU3D::CurrentRenderer->Init())
         {
             // Fallback on software renderer
diff --git a/src/GPU.h b/src/GPU.h
index 9686704..ee75fc1 100644
--- a/src/GPU.h
+++ b/src/GPU.h
@@ -160,6 +160,7 @@ struct RenderSettings
 
     int GL_ScaleFactor;
     bool GL_BetterPolygons;
+    bool GL_HiresCoordinates;
 };
 
 
@@ -170,6 +171,16 @@ void Stop();
 
 void DoSavestate(Savestate* file);
 
+enum
+{
+    renderer3D_Software = 0,
+#ifdef OGLRENDERER_ENABLED
+    renderer3D_OpenGL,
+    renderer3D_OpenGLCompute,
+#endif
+    renderer3D_Max,
+};
+
 void InitRenderer(int renderer);
 void DeInitRenderer();
 void ResetRenderer();
@@ -617,6 +628,4 @@ void SetDispStat(u32 cpu, u16 val);
 void SetVCount(u16 val);
 }
 
-#include "GPU3D.h"
-
 #endif
diff --git a/src/GPU2D.cpp b/src/GPU2D.cpp
index d5df992..fe01ebb 100644
--- a/src/GPU2D.cpp
+++ b/src/GPU2D.cpp
@@ -20,6 +20,7 @@
 #include <string.h>
 #include "NDS.h"
 #include "GPU.h"
+#include "GPU3D.h"
 
 using Platform::Log;
 using Platform::LogLevel;
diff --git a/src/GPU2D_Soft.cpp b/src/GPU2D_Soft.cpp
index 070079a..3704de9 100644
--- a/src/GPU2D_Soft.cpp
+++ b/src/GPU2D_Soft.cpp
@@ -18,6 +18,7 @@
 
 #include "GPU2D_Soft.h"
 #include "GPU.h"
+#include "GPU3D.h"
 
 namespace GPU2D
 {
@@ -367,7 +368,7 @@ void SoftRenderer::VBlankEnd(Unit* unitA, Unit* unitB)
     {
         if ((unitA->CaptureCnt & (1<<31)) && (((unitA->CaptureCnt >> 29) & 0x3) != 1))
         {
-            reinterpret_cast<GPU3D::GLRenderer*>(GPU3D::CurrentRenderer.get())->PrepareCaptureFrame();
+            GPU3D::CurrentRenderer.get()->PrepareCaptureFrame();
         }
     }
 #endif
diff --git a/src/GPU3D.cpp b/src/GPU3D.cpp
index dcd5bd7..106165f 100644
--- a/src/GPU3D.cpp
+++ b/src/GPU3D.cpp
@@ -23,6 +23,7 @@
 #include "GPU.h"
 #include "FIFO.h"
 #include "Platform.h"
+#include "GPU3D.h"
 
 using Platform::Log;
 using Platform::LogLevel;
diff --git a/src/GPU3D.h b/src/GPU3D.h
index 4a7bfdc..f229e66 100644
--- a/src/GPU3D.h
+++ b/src/GPU3D.h
@@ -159,6 +159,9 @@ public:
     virtual void RenderFrame() = 0;
     virtual void RestartFrame() {};
     virtual u32* GetLine(int line) = 0;
+
+    virtual void SetupAccelFrame() {}
+    virtual void PrepareCaptureFrame() {}
 };
 
 extern int Renderer;
@@ -170,6 +173,7 @@ extern std::unique_ptr<Renderer3D> CurrentRenderer;
 
 #ifdef OGLRENDERER_ENABLED
 #include "GPU3D_OpenGL.h"
+#include "GPU3D_Compute.h"
 #endif
 
 #endif
diff --git a/src/GPU3D_Compute.cpp b/src/GPU3D_Compute.cpp
new file mode 100644
index 0000000..d497277
--- /dev/null
+++ b/src/GPU3D_Compute.cpp
@@ -0,0 +1,1040 @@
+/*
+    Copyright 2016-2022 melonDS team
+
+    This file is part of melonDS.
+
+    melonDS is free software: you can redistribute it and/or modify it under
+    the terms of the GNU General Public License as published by the Free
+    Software Foundation, either version 3 of the License, or (at your option)
+    any later version.
+
+    melonDS is distributed in the hope that it will be useful, but WITHOUT ANY
+    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+    FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with melonDS. If not, see http://www.gnu.org/licenses/.
+*/
+
+#include "GPU3D_Compute.h"
+
+#include <assert.h>
+
+#include "OpenGLSupport.h"
+
+#include "GPU3D_Compute_shaders.h"
+
+namespace GPU3D
+{
+
+ComputeRenderer::ComputeRenderer()
+    : Renderer3D(true), Texcache(TexcacheOpenGLLoader())
+{}
+
+ComputeRenderer::~ComputeRenderer()
+{}
+
+
+
+bool ComputeRenderer::CompileShader(GLuint& shader, const std::string& source, const std::initializer_list<const char*>& defines)
+{
+    std::string shaderName;
+    std::string shaderSource;
+    shaderSource += "#version 430 core\n";
+    for (const char* define : defines)
+    {
+        shaderSource += "#define ";
+        shaderSource += define;
+        shaderSource += '\n';
+        shaderName += define;
+        shaderName += ',';
+    }
+    shaderSource += "#define ScreenWidth ";
+    shaderSource += std::to_string(ScreenWidth);
+    shaderSource += "\n#define ScreenHeight ";
+    shaderSource += std::to_string(ScreenHeight);
+    shaderSource += "\n#define MaxWorkTiles ";
+    shaderSource += std::to_string(MaxWorkTiles);
+
+    shaderSource += ComputeRendererShaders::Common;
+    shaderSource += source;
+
+    return OpenGL::CompileComputeProgram(shader, shaderSource.c_str(), shaderName.c_str());
+}
+
+void blah(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam)
+{
+    printf("%s\n", message);
+}
+
+bool ComputeRenderer::Init()
+{
+    //glDebugMessageCallback(blah, NULL);
+    //glEnable(GL_DEBUG_OUTPUT);
+    glGenBuffers(1, &YSpanSetupMemory);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, YSpanSetupMemory);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(SpanSetupY)*MaxYSpanSetups, nullptr, GL_DYNAMIC_DRAW);
+    
+    glGenBuffers(1, &RenderPolygonMemory);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, RenderPolygonMemory);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(RenderPolygon)*2048, nullptr, GL_DYNAMIC_DRAW);
+
+    glGenBuffers(1, &XSpanSetupMemory);
+    glGenBuffers(1, &BinResultMemory);
+    glGenBuffers(1, &FinalTileMemory);
+    glGenBuffers(1, &YSpanIndicesTextureMemory);
+    glGenBuffers(tilememoryLayer_Num, TileMemory);
+    glGenBuffers(1, &WorkDescMemory);
+
+    glGenTextures(1, &YSpanIndicesTexture);
+    glGenTextures(1, &LowResFramebuffer);
+    glBindTexture(GL_TEXTURE_2D, LowResFramebuffer);
+    glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8UI, 256, 192);
+
+    glGenBuffers(1, &MetaUniformMemory);
+    glBindBuffer(GL_UNIFORM_BUFFER, MetaUniformMemory);
+    glBufferData(GL_UNIFORM_BUFFER, sizeof(MetaUniform), nullptr, GL_DYNAMIC_DRAW);
+
+    glGenSamplers(9, Samplers);
+    for (u32 j = 0; j < 3; j++)
+    {
+        for (u32 i = 0; i < 3; i++)
+        {
+            const GLenum translateWrapMode[3] = {GL_CLAMP_TO_EDGE, GL_REPEAT, GL_MIRRORED_REPEAT};
+            glSamplerParameteri(Samplers[i+j*3], GL_TEXTURE_WRAP_S, translateWrapMode[i]);
+            glSamplerParameteri(Samplers[i+j*3], GL_TEXTURE_WRAP_T, translateWrapMode[j]);
+            glSamplerParameteri(Samplers[i+j*3], GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+            glSamplerParameterf(Samplers[i+j*3], GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        }
+    }
+
+    glGenBuffers(1, &PixelBuffer);
+    glBindBuffer(GL_PIXEL_PACK_BUFFER, PixelBuffer);
+    glBufferData(GL_PIXEL_PACK_BUFFER, 256*192*4, NULL, GL_DYNAMIC_READ);
+
+    return true;
+}
+
+void ComputeRenderer::DeInit()
+{
+    Texcache.Reset();
+
+    glDeleteBuffers(1, &YSpanSetupMemory);
+    glDeleteBuffers(1, &RenderPolygonMemory);
+    glDeleteBuffers(1, &XSpanSetupMemory);
+    glDeleteBuffers(1, &BinResultMemory);
+    glDeleteBuffers(tilememoryLayer_Num, TileMemory);
+    glDeleteBuffers(1, &WorkDescMemory);
+    glDeleteBuffers(1, &FinalTileMemory);
+    glDeleteBuffers(1, &YSpanIndicesTextureMemory);
+    glDeleteTextures(1, &YSpanIndicesTexture);
+    glDeleteTextures(1, &Framebuffer);
+    glDeleteBuffers(1, &MetaUniformMemory);
+
+    glDeleteSamplers(9, Samplers);
+    glDeleteBuffers(1, &PixelBuffer);
+}
+
+void ComputeRenderer::DeleteShaders()
+{
+    std::initializer_list<GLuint> allPrograms =
+    {
+        ShaderInterpXSpans[0],
+        ShaderInterpXSpans[1],
+        ShaderBinCombined,
+        ShaderDepthBlend[0],
+        ShaderDepthBlend[1],
+        ShaderRasteriseNoTexture[0],
+        ShaderRasteriseNoTexture[1],
+        ShaderRasteriseNoTextureToon[0],
+        ShaderRasteriseNoTextureToon[1],
+        ShaderRasteriseNoTextureHighlight[0],
+        ShaderRasteriseNoTextureHighlight[1],
+        ShaderRasteriseUseTextureDecal[0],
+        ShaderRasteriseUseTextureDecal[1],
+        ShaderRasteriseUseTextureModulate[0],
+        ShaderRasteriseUseTextureModulate[1],
+        ShaderRasteriseUseTextureToon[0],
+        ShaderRasteriseUseTextureToon[1],
+        ShaderRasteriseUseTextureHighlight[0],
+        ShaderRasteriseUseTextureHighlight[1],
+        ShaderRasteriseShadowMask[0],
+        ShaderRasteriseShadowMask[1],
+        ShaderClearCoarseBinMask,
+        ShaderClearIndirectWorkCount,
+        ShaderCalculateWorkListOffset,
+        ShaderSortWork,
+        ShaderFinalPass[0],
+        ShaderFinalPass[1],
+        ShaderFinalPass[2],
+        ShaderFinalPass[3],
+        ShaderFinalPass[4],
+        ShaderFinalPass[5],
+        ShaderFinalPass[6],
+        ShaderFinalPass[7],
+    };
+    for (GLuint program : allPrograms)
+        glDeleteProgram(program);
+}
+
+void ComputeRenderer::Reset()
+{
+    Texcache.Reset();
+}
+
+void ComputeRenderer::SetRenderSettings(GPU::RenderSettings& settings)
+{
+    if (ScaleFactor != -1)
+    {
+        DeleteShaders();
+    }
+
+    ScaleFactor = settings.GL_ScaleFactor;
+    ScreenWidth = 256 * ScaleFactor;
+    ScreenHeight = 192 * ScaleFactor;
+
+    TilesPerLine = ScreenWidth/TileSize;
+    TileLines = ScreenHeight/TileSize;
+
+    HiresCoordinates = settings.GL_HiresCoordinates;
+
+    MaxWorkTiles = TilesPerLine*TileLines*8;
+
+    for (int i = 0; i < tilememoryLayer_Num; i++)
+    {
+        glBindBuffer(GL_SHADER_STORAGE_BUFFER, TileMemory[i]);
+        glBufferData(GL_SHADER_STORAGE_BUFFER, 4*TileSize*TileSize*MaxWorkTiles, nullptr, GL_DYNAMIC_DRAW);
+    }
+
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, FinalTileMemory);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, 4*3*2*ScreenWidth*ScreenHeight, nullptr, GL_DYNAMIC_DRAW);
+
+    int binResultSize = sizeof(BinResultHeader)
+        + TilesPerLine*TileLines*CoarseBinStride*4 // BinnedMaskCoarse
+        + TilesPerLine*TileLines*BinStride*4 // BinnedMask
+        + TilesPerLine*TileLines*BinStride*4; // WorkOffsets
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, BinResultMemory);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, binResultSize, nullptr, GL_DYNAMIC_DRAW);
+
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, WorkDescMemory);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, MaxWorkTiles*2*4*2, nullptr, GL_DYNAMIC_DRAW);
+
+    if (Framebuffer != 0)
+        glDeleteTextures(1, &Framebuffer);
+    glGenTextures(1, &Framebuffer);
+    glBindTexture(GL_TEXTURE_2D, Framebuffer);
+    glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, ScreenWidth, ScreenHeight);
+
+    // eh those are pretty bad guesses
+    // though real hw shouldn't be eable to render all 2048 polygons on every line either
+    int maxYSpanIndices = 64*2048 * ScaleFactor;
+    YSpanIndices.resize(maxYSpanIndices);
+
+    glBindBuffer(GL_TEXTURE_BUFFER, YSpanIndicesTextureMemory);
+    glBufferData(GL_TEXTURE_BUFFER, maxYSpanIndices*2*4, nullptr, GL_DYNAMIC_DRAW);
+
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, XSpanSetupMemory);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(SpanSetupX)*maxYSpanIndices, nullptr, GL_DYNAMIC_DRAW);
+
+    glBindTexture(GL_TEXTURE_BUFFER, YSpanIndicesTexture);
+    glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA16UI, YSpanIndicesTextureMemory);
+
+    CompileShader(ShaderInterpXSpans[0], ComputeRendererShaders::InterpSpans, {"InterpSpans", "ZBuffer"});
+    CompileShader(ShaderInterpXSpans[1], ComputeRendererShaders::InterpSpans, {"InterpSpans", "WBuffer"});
+    CompileShader(ShaderBinCombined, ComputeRendererShaders::BinCombined, {"BinCombined"});
+    CompileShader(ShaderDepthBlend[0], ComputeRendererShaders::DepthBlend, {"DepthBlend", "ZBuffer"});
+    CompileShader(ShaderDepthBlend[1], ComputeRendererShaders::DepthBlend, {"DepthBlend", "WBuffer"});
+    CompileShader(ShaderRasteriseNoTexture[0], ComputeRendererShaders::Rasterise, {"Rasterise", "ZBuffer", "NoTexture"});
+    CompileShader(ShaderRasteriseNoTexture[1], ComputeRendererShaders::Rasterise, {"Rasterise", "WBuffer", "NoTexture"});
+    CompileShader(ShaderRasteriseNoTextureToon[0], ComputeRendererShaders::Rasterise, {"Rasterise", "ZBuffer", "NoTexture", "Toon"});
+    CompileShader(ShaderRasteriseNoTextureToon[1], ComputeRendererShaders::Rasterise, {"Rasterise", "WBuffer", "NoTexture", "Toon"});
+    CompileShader(ShaderRasteriseNoTextureHighlight[0], ComputeRendererShaders::Rasterise, {"Rasterise", "ZBuffer", "NoTexture", "Highlight"});
+    CompileShader(ShaderRasteriseNoTextureHighlight[1], ComputeRendererShaders::Rasterise, {"Rasterise", "WBuffer", "NoTexture", "Highlight"});
+    CompileShader(ShaderRasteriseUseTextureDecal[0], ComputeRendererShaders::Rasterise, {"Rasterise", "ZBuffer", "UseTexture", "Decal"});
+    CompileShader(ShaderRasteriseUseTextureDecal[1], ComputeRendererShaders::Rasterise, {"Rasterise", "WBuffer", "UseTexture", "Decal"});
+    CompileShader(ShaderRasteriseUseTextureModulate[0], ComputeRendererShaders::Rasterise, {"Rasterise", "ZBuffer", "UseTexture", "Modulate"});
+    CompileShader(ShaderRasteriseUseTextureModulate[1], ComputeRendererShaders::Rasterise, {"Rasterise", "WBuffer", "UseTexture", "Modulate"});
+    CompileShader(ShaderRasteriseUseTextureToon[0], ComputeRendererShaders::Rasterise, {"Rasterise", "ZBuffer", "UseTexture", "Toon"});
+    CompileShader(ShaderRasteriseUseTextureToon[1], ComputeRendererShaders::Rasterise, {"Rasterise", "WBuffer", "UseTexture", "Toon"});
+    CompileShader(ShaderRasteriseUseTextureHighlight[0], ComputeRendererShaders::Rasterise, {"Rasterise", "ZBuffer", "UseTexture", "Highlight"});
+    CompileShader(ShaderRasteriseUseTextureHighlight[1], ComputeRendererShaders::Rasterise, {"Rasterise", "WBuffer", "UseTexture", "Highlight"});
+    CompileShader(ShaderRasteriseShadowMask[0], ComputeRendererShaders::Rasterise, {"Rasterise", "ZBuffer", "ShadowMask"});
+    CompileShader(ShaderRasteriseShadowMask[1], ComputeRendererShaders::Rasterise, {"Rasterise", "WBuffer", "ShadowMask"});
+    CompileShader(ShaderClearCoarseBinMask, ComputeRendererShaders::ClearCoarseBinMask, {"ClearCoarseBinMask"});
+    CompileShader(ShaderClearIndirectWorkCount, ComputeRendererShaders::ClearIndirectWorkCount, {"ClearIndirectWorkCount"});
+    CompileShader(ShaderCalculateWorkListOffset, ComputeRendererShaders::CalcOffsets, {"CalculateWorkOffsets"});
+    CompileShader(ShaderSortWork, ComputeRendererShaders::SortWork, {"SortWork"});
+    CompileShader(ShaderFinalPass[0], ComputeRendererShaders::FinalPass, {"FinalPass"});
+    CompileShader(ShaderFinalPass[1], ComputeRendererShaders::FinalPass, {"FinalPass", "EdgeMarking"});
+    CompileShader(ShaderFinalPass[2], ComputeRendererShaders::FinalPass, {"FinalPass", "Fog"});
+    CompileShader(ShaderFinalPass[3], ComputeRendererShaders::FinalPass, {"FinalPass", "EdgeMarking", "Fog"});
+    CompileShader(ShaderFinalPass[4], ComputeRendererShaders::FinalPass, {"FinalPass", "AntiAliasing"});
+    CompileShader(ShaderFinalPass[5], ComputeRendererShaders::FinalPass, {"FinalPass", "AntiAliasing", "EdgeMarking"});
+    CompileShader(ShaderFinalPass[6], ComputeRendererShaders::FinalPass, {"FinalPass", "AntiAliasing", "Fog"});
+    CompileShader(ShaderFinalPass[7], ComputeRendererShaders::FinalPass, {"FinalPass", "AntiAliasing", "EdgeMarking", "Fog"});
+}
+
+void ComputeRenderer::VCount144()
+{
+
+}
+
+void ComputeRenderer::SetupAttrs(SpanSetupY* span, Polygon* poly, int from, int to)
+{
+    span->Z0 = poly->FinalZ[from];
+    span->W0 = poly->FinalW[from];
+    span->Z1 = poly->FinalZ[to];
+    span->W1 = poly->FinalW[to];
+    span->ColorR0 = poly->Vertices[from]->FinalColor[0];
+    span->ColorG0 = poly->Vertices[from]->FinalColor[1];
+    span->ColorB0 = poly->Vertices[from]->FinalColor[2];
+    span->ColorR1 = poly->Vertices[to]->FinalColor[0];
+    span->ColorG1 = poly->Vertices[to]->FinalColor[1];
+    span->ColorB1 = poly->Vertices[to]->FinalColor[2];
+    span->TexcoordU0 = poly->Vertices[from]->TexCoords[0];
+    span->TexcoordV0 = poly->Vertices[from]->TexCoords[1];
+    span->TexcoordU1 = poly->Vertices[to]->TexCoords[0];
+    span->TexcoordV1 = poly->Vertices[to]->TexCoords[1];
+}
+
+void ComputeRenderer::SetupYSpanDummy(RenderPolygon* rp, SpanSetupY* span, Polygon* poly, int vertex, int side, s32 positions[10][2])
+{
+    s32 x0 = positions[vertex][0];
+    if (side)
+    {
+        span->DxInitial = -0x40000;
+        x0--;
+    }
+    else
+    {
+        span->DxInitial = 0;
+    }
+
+    span->X0 = span->X1 = x0;
+    span->XMin = x0;
+    span->XMax = x0;
+    span->Y0 = span->Y1 = positions[vertex][1];
+
+    if (span->XMin < rp->XMin)
+    {
+        rp->XMin = span->XMin;
+        rp->XMinY = span->Y0;
+    }
+    if (span->XMax > rp->XMax)
+    {
+        rp->XMax = span->XMax;
+        rp->XMaxY = span->Y0;
+    }
+
+    span->Increment = 0;
+
+    span->I0 = span->I1 = span->IRecip = 0;
+    span->Linear = true;
+
+    span->XCovIncr = 0;
+
+    span->IsDummy = true;
+
+    SetupAttrs(span, poly, vertex, vertex);
+}
+
+void ComputeRenderer::SetupYSpan(RenderPolygon* rp, SpanSetupY* span, Polygon* poly, int from, int to, int side, s32 positions[10][2])
+{
+    span->X0 = positions[from][0];
+    span->X1 = positions[to][0];
+    span->Y0 = positions[from][1];
+    span->Y1 = positions[to][1];
+
+    SetupAttrs(span, poly, from, to);
+
+    s32 minXY, maxXY;
+    bool negative = false;
+    if (span->X1 > span->X0)
+    {
+        span->XMin = span->X0;
+        span->XMax = span->X1-1;
+
+        minXY = span->Y0;
+        maxXY = span->Y1;
+    }
+    else if (span->X1 < span->X0)
+    {
+        span->XMin = span->X1;
+        span->XMax = span->X0-1;
+        negative = true;
+
+        minXY = span->Y1;
+        maxXY = span->Y0;
+    }
+    else
+    {
+        span->XMin = span->X0;
+        if (side) span->XMin--;
+        span->XMax = span->XMin;
+
+        // doesn't matter for completely vertical slope
+        minXY = span->Y0;
+        maxXY = span->Y0;
+    }
+
+    if (span->XMin < rp->XMin)
+    {
+        rp->XMin = span->XMin;
+        rp->XMinY = minXY;
+    }
+    if (span->XMax > rp->XMax)
+    {
+        rp->XMax = span->XMax;
+        rp->XMaxY = maxXY;
+    }
+
+    span->IsDummy = false;
+
+    s32 xlen = span->XMax+1 - span->XMin;
+    s32 ylen = span->Y1 - span->Y0;
+
+    // slope increment has a 18-bit fractional part
+    // note: for some reason, x/y isn't calculated directly,
+    // instead, 1/y is calculated and then multiplied by x
+    // TODO: this is still not perfect (see for example x=169 y=33)
+    if (ylen == 0)
+    {
+        span->Increment = 0;
+    }
+    else if (ylen == xlen)
+    {
+        span->Increment = 0x40000;
+    }
+    else
+    {
+        s32 yrecip = (1<<18) / ylen;
+        span->Increment = (span->X1-span->X0) * yrecip;
+        if (span->Increment < 0) span->Increment = -span->Increment;
+    }
+
+    bool xMajor = (span->Increment > 0x40000);
+
+    if (side)
+    {
+        // right
+
+        if (xMajor)
+            span->DxInitial = negative ? (0x20000 + 0x40000) : (span->Increment - 0x20000);
+        else if (span->Increment != 0)
+            span->DxInitial = negative ? 0x40000 : 0;
+        else
+            span->DxInitial = -0x40000;
+    }
+    else
+    {
+        // left
+
+        if (xMajor)
+            span->DxInitial = negative ? ((span->Increment - 0x20000) + 0x40000) : 0x20000;
+        else if (span->Increment != 0)
+            span->DxInitial = negative ? 0x40000 : 0;
+        else
+            span->DxInitial = 0;
+    }
+
+    if (xMajor)
+    {
+        if (side)
+        {
+            span->I0 = span->X0 - 1;
+            span->I1 = span->X1 - 1;
+        }
+        else
+        {
+            span->I0 = span->X0;
+            span->I1 = span->X1;
+        }
+
+        // used for calculating AA coverage
+        span->XCovIncr = (ylen << 10) / xlen;
+    }
+    else
+    {
+        span->I0 = span->Y0;
+        span->I1 = span->Y1;
+    }
+
+    if (span->I0 != span->I1)
+        span->IRecip = (1<<30) / (span->I1 - span->I0);
+    else
+        span->IRecip = 0;
+
+    span->Linear = (span->W0 == span->W1) && !(span->W0 & 0x7E) && !(span->W1 & 0x7E);
+
+    if ((span->W0 & 0x1) && !(span->W1 & 0x1))
+    {
+        span->W0n = (span->W0 - 1) >> 1;
+        span->W0d = (span->W0 + 1) >> 1;
+        span->W1d = span->W1 >> 1;
+    }
+    else
+    {
+        span->W0n = span->W0 >> 1;
+        span->W0d = span->W0 >> 1;
+        span->W1d = span->W1 >> 1;
+    }
+}
+
+struct Variant
+{
+    GLuint Texture, Sampler;
+    u16 Width, Height;
+    u8 BlendMode;
+
+    bool operator==(const Variant& other)
+    {
+        return Texture == other.Texture && Sampler == other.Sampler && BlendMode == other.BlendMode;
+    }
+};
+
+/*
+    Antialiasing
+    W-Buffer
+    With Texture
+    0
+    1, 3
+    2
+    without Texture
+    2
+    0, 1, 3
+
+    => 20 Shader + 1x Shadow Mask
+*/
+
+void ComputeRenderer::RenderFrame()
+{
+    //printf("render frame\n");
+
+    if (!Texcache.Update() && RenderFrameIdentical)
+    {
+        return;
+    }
+
+    int numYSpans = 0;
+    int numSetupIndices = 0;
+
+    /*
+        Some games really like to spam small textures, often
+        to store the data like PPU tiles. E.g. Shantae
+        or some Mega Man game. Fortunately they are usually kind
+        enough to not vary the texture size all too often (usually
+        they just use 8x8 or 16x for everything).
+
+        This is the reason we have this whole mess where textures of
+        the same size are put into array textures. This allows
+        to increase the batch size.
+        Less variance between each Variant hah!
+    */
+    u32 numVariants = 0, prevVariant, prevTexLayer;
+    Variant variants[MaxVariants];
+
+    bool enableTextureMaps = RenderDispCnt & (1<<0);
+
+    for (int i = 0; i < RenderNumPolygons; i++)
+    {
+        Polygon* polygon = RenderPolygonRAM[i];
+
+        u32 nverts = polygon->NumVertices;
+        u32 vtop = polygon->VTop, vbot = polygon->VBottom;
+
+        u32 curVL = vtop, curVR = vtop;
+        u32 nextVL, nextVR;
+
+        RenderPolygons[i].FirstXSpan = numSetupIndices;
+        RenderPolygons[i].Attr = polygon->Attr;
+
+        bool foundVariant = false;
+        if (i > 0)
+        {
+            // if the whole texture attribute matches
+            // the texture layer will also match
+            Polygon* prevPolygon = RenderPolygonRAM[i - 1];
+            foundVariant = prevPolygon->TexParam == polygon->TexParam
+                && prevPolygon->TexPalette == polygon->TexPalette
+                && (prevPolygon->Attr & 0x30) == (polygon->Attr & 0x30)
+                && prevPolygon->IsShadowMask == polygon->IsShadowMask;
+        }
+
+        if (!foundVariant)
+        {
+            Variant variant;
+            variant.BlendMode = polygon->IsShadowMask ? 4 : ((polygon->Attr >> 4) & 0x3);
+            variant.Texture = 0;
+            variant.Sampler = 0;
+            u32* textureLastVariant = nullptr;
+            // we always need to look up the texture to get the layer of the array texture
+            if (enableTextureMaps && (polygon->TexParam >> 26) & 0x7)
+            {
+                Texcache.GetTexture(polygon->TexParam, polygon->TexPalette, variant.Texture, prevTexLayer, textureLastVariant);
+                bool wrapS = (polygon->TexParam >> 16) & 1;
+                bool wrapT = (polygon->TexParam >> 17) & 1;
+                bool mirrorS = (polygon->TexParam >> 18) & 1;
+                bool mirrorT = (polygon->TexParam >> 19) & 1;
+                variant.Sampler = Samplers[(wrapS ? (mirrorS ? 2 : 1) : 0) + (wrapT ? (mirrorT ? 2 : 1) : 0) * 3];
+
+                if (*textureLastVariant < numVariants && variants[*textureLastVariant] == variant)
+                {
+                    foundVariant = true;
+                    prevVariant = *textureLastVariant;
+                }
+            }
+
+            if (!foundVariant)
+            {
+                for (int j = numVariants - 1; j >= 0; j--)
+                {
+                    if (variants[j] == variant)
+                    {
+                        foundVariant = true;
+                        prevVariant = j;
+                        goto foundVariant;
+                    }
+                }
+
+                prevVariant = numVariants;
+                variants[numVariants] = variant;
+                variants[numVariants].Width = TextureWidth(polygon->TexParam);
+                variants[numVariants].Height = TextureHeight(polygon->TexParam);
+                numVariants++;
+                assert(numVariants <= MaxVariants);
+            foundVariant:;
+
+                if (textureLastVariant)
+                    *textureLastVariant = prevVariant;
+            }
+        }
+        RenderPolygons[i].Variant = prevVariant;
+        RenderPolygons[i].TextureLayer = (float)prevTexLayer;
+
+        if (polygon->FacingView)
+        {
+            nextVL = curVL + 1;
+            if (nextVL >= nverts) nextVL = 0;
+            nextVR = curVR - 1;
+            if ((s32)nextVR < 0) nextVR = nverts - 1;
+        }
+        else
+        {
+            nextVL = curVL - 1;
+            if ((s32)nextVL < 0) nextVL = nverts - 1;
+            nextVR = curVR + 1;
+            if (nextVR >= nverts) nextVR = 0;
+        }
+
+        s32 scaledPositions[10][2];
+        s32 ytop = ScreenHeight, ybot = 0;
+        for (int i = 0; i < polygon->NumVertices; i++)
+        {
+            if (HiresCoordinates)
+            {
+                scaledPositions[i][0] = (polygon->Vertices[i]->HiresPosition[0] * ScaleFactor) >> 4;
+                scaledPositions[i][1] = (polygon->Vertices[i]->HiresPosition[1] * ScaleFactor) >> 4;
+            }
+            else
+            {
+                scaledPositions[i][0] = polygon->Vertices[i]->FinalPosition[0] * ScaleFactor;
+                scaledPositions[i][1] = polygon->Vertices[i]->FinalPosition[1] * ScaleFactor;
+            }
+            ytop = std::min(scaledPositions[i][1], ytop);
+            ybot = std::max(scaledPositions[i][1], ybot);
+        }
+        RenderPolygons[i].YTop = ytop;
+        RenderPolygons[i].YBot = ybot;
+        RenderPolygons[i].XMin = ScreenWidth;
+        RenderPolygons[i].XMax = 0;
+
+        if (ybot == ytop)
+        {
+            vtop = 0; vbot = 0;
+
+            RenderPolygons[i].YBot++;
+
+            int j = 1;
+            if (scaledPositions[j][0] < scaledPositions[vtop][0]) vtop = j;
+            if (scaledPositions[j][0] > scaledPositions[vbot][0]) vbot = j;
+
+            j = nverts - 1;
+            if (scaledPositions[j][0] < scaledPositions[vtop][0]) vtop = j;
+            if (scaledPositions[j][0] > scaledPositions[vbot][0]) vbot = j;
+
+            assert(numYSpans < MaxYSpanSetups);
+            u32 curSpanL = numYSpans;
+            SetupYSpanDummy(&RenderPolygons[i], &YSpanSetups[numYSpans++], polygon, vtop, 0, scaledPositions);
+            assert(numYSpans < MaxYSpanSetups);
+            u32 curSpanR = numYSpans;
+            SetupYSpanDummy(&RenderPolygons[i], &YSpanSetups[numYSpans++], polygon, vbot, 1, scaledPositions);
+
+            YSpanIndices[numSetupIndices].PolyIdx = i;
+            YSpanIndices[numSetupIndices].SpanIdxL = curSpanL;
+            YSpanIndices[numSetupIndices].SpanIdxR = curSpanR;
+            YSpanIndices[numSetupIndices].Y = ytop;
+            numSetupIndices++;
+        }
+        else
+        {
+            u32 curSpanL = numYSpans;
+            assert(numYSpans < MaxYSpanSetups);
+            SetupYSpan(&RenderPolygons[i], &YSpanSetups[numYSpans++], polygon, curVL, nextVL, 0, scaledPositions);
+            u32 curSpanR = numYSpans;
+            assert(numYSpans < MaxYSpanSetups);
+            SetupYSpan(&RenderPolygons[i], &YSpanSetups[numYSpans++], polygon, curVR, nextVR, 1, scaledPositions);
+
+            for (u32 y = ytop; y < ybot; y++)
+            {
+                if (y >= scaledPositions[nextVL][1] && curVL != polygon->VBottom)
+                {
+                    while (y >= scaledPositions[nextVL][1] && curVL != polygon->VBottom)
+                    {
+                        curVL = nextVL;
+                        if (polygon->FacingView)
+                        {
+                            nextVL = curVL + 1;
+                            if (nextVL >= nverts)
+                                nextVL = 0;
+                        }
+                        else
+                        {
+                            nextVL = curVL - 1;
+                            if ((s32)nextVL < 0)
+                                nextVL = nverts - 1;
+                        }
+                    }
+
+
+                    assert(numYSpans < MaxYSpanSetups);
+                    curSpanL = numYSpans;
+                    SetupYSpan(&RenderPolygons[i], &YSpanSetups[numYSpans++], polygon, curVL, nextVL, 0, scaledPositions);
+                }
+                if (y >= scaledPositions[nextVR][1] && curVR != polygon->VBottom)
+                {
+                    while (y >= scaledPositions[nextVR][1] && curVR != polygon->VBottom)
+                    {
+                        curVR = nextVR;
+                        if (polygon->FacingView)
+                        {
+                            nextVR = curVR - 1;
+                            if ((s32)nextVR < 0)
+                                nextVR = nverts - 1;
+                        }
+                        else
+                        {
+                            nextVR = curVR + 1;
+                            if (nextVR >= nverts)
+                                nextVR = 0;
+                        }
+                    }
+
+                    assert(numYSpans < MaxYSpanSetups);
+                    curSpanR = numYSpans;
+                    SetupYSpan(&RenderPolygons[i] ,&YSpanSetups[numYSpans++], polygon, curVR, nextVR, 1, scaledPositions);
+                }
+
+                YSpanIndices[numSetupIndices].PolyIdx = i;
+                YSpanIndices[numSetupIndices].SpanIdxL = curSpanL;
+                YSpanIndices[numSetupIndices].SpanIdxR = curSpanR;
+                YSpanIndices[numSetupIndices].Y = y;
+                numSetupIndices++;
+            }
+        }
+
+        //printf("polygon min max %d %d | %d %d\n", RenderPolygons[i].XMin, RenderPolygons[i].XMinY, RenderPolygons[i].XMax, RenderPolygons[i].XMaxY);
+    }
+
+    /*for (u32 i = 0; i < RenderNumPolygons; i++)
+    {
+        if (RenderPolygons[i].Variant >= numVariants)
+        {
+            printf("blarb2 %d %d %d\n", RenderPolygons[i].Variant, i, RenderNumPolygons);
+        }
+        //assert(RenderPolygons[i].Variant < numVariants);
+    }*/
+
+    if (numYSpans > 0)
+    {
+        glBindBuffer(GL_SHADER_STORAGE_BUFFER, YSpanSetupMemory);
+        glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(SpanSetupY)*numYSpans, YSpanSetups);
+
+        glBindBuffer(GL_TEXTURE_BUFFER, YSpanIndicesTextureMemory);
+        glBufferSubData(GL_TEXTURE_BUFFER, 0, numSetupIndices*4*2, YSpanIndices.data());
+
+        glBindBuffer(GL_SHADER_STORAGE_BUFFER, RenderPolygonMemory);
+        glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, RenderNumPolygons*sizeof(RenderPolygon), RenderPolygons);
+        // we haven't accessed image data yet, so we don't need to invalidate anything
+    }
+
+    //printf("found via %d %d %d of %d\n", foundviatexcache, foundviaprev, numslow, RenderNumPolygons);
+
+    // bind everything
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, RenderPolygonMemory);
+
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, XSpanSetupMemory);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, YSpanSetupMemory);
+
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 5, FinalTileMemory);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 6, BinResultMemory);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 7, WorkDescMemory);
+
+    MetaUniform meta;
+    meta.DispCnt = RenderDispCnt;
+    meta.NumPolygons = RenderNumPolygons;
+    meta.NumVariants = numVariants;
+    meta.AlphaRef = RenderAlphaRef;
+    {
+        u32 r = (RenderClearAttr1 << 1) & 0x3E; if (r) r++;
+        u32 g = (RenderClearAttr1 >> 4) & 0x3E; if (g) g++;
+        u32 b = (RenderClearAttr1 >> 9) & 0x3E; if (b) b++;
+        u32 a = (RenderClearAttr1 >> 16) & 0x1F;
+        meta.ClearColor = r | (g << 8) | (b << 16) | (a << 24);
+        meta.ClearDepth = ((RenderClearAttr2 & 0x7FFF) * 0x200) + 0x1FF;
+        meta.ClearAttr = RenderClearAttr1 & 0x3F008000;
+    }
+    for (u32 i = 0; i < 32; i++)
+    {
+        u32 color = RenderToonTable[i];
+        u32 r = (color << 1) & 0x3E;
+        u32 g = (color >> 4) & 0x3E;
+        u32 b = (color >> 9) & 0x3E;
+        if (r) r++;
+        if (g) g++;
+        if (b) b++;
+
+        meta.ToonTable[i*4+0] = r | (g << 8) | (b << 16);
+    }
+    for (u32 i = 0; i < 34; i++)
+    {
+        meta.ToonTable[i*4+1] = RenderFogDensityTable[i];
+    }
+    for (u32 i = 0; i < 8; i++)
+    {
+        u32 color = RenderEdgeTable[i];
+        u32 r = (color << 1) & 0x3E;
+        u32 g = (color >> 4) & 0x3E;
+        u32 b = (color >> 9) & 0x3E;
+        if (r) r++;
+        if (g) g++;
+        if (b) b++;
+
+        meta.ToonTable[i*4+2] = r | (g << 8) | (b << 16);
+    }
+    meta.FogOffset = RenderFogOffset;
+    meta.FogShift = RenderFogShift;
+    {
+        u32 fogR = (RenderFogColor << 1) & 0x3E; if (fogR) fogR++;
+        u32 fogG = (RenderFogColor >> 4) & 0x3E; if (fogG) fogG++;
+        u32 fogB = (RenderFogColor >> 9) & 0x3E; if (fogB) fogB++;
+        u32 fogA = (RenderFogColor >> 16) & 0x1F;
+        meta.FogColor = fogR | (fogG << 8) | (fogB << 16) | (fogA << 24);
+    }
+
+    glBindBuffer(GL_UNIFORM_BUFFER, MetaUniformMemory);
+    glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(MetaUniform), &meta);
+    glBindBufferBase(GL_UNIFORM_BUFFER, 0, MetaUniformMemory);
+
+    glUseProgram(ShaderClearCoarseBinMask);
+    glDispatchCompute(TilesPerLine*TileLines/32, 1, 1);
+
+    bool wbuffer = false;
+    if (numYSpans > 0)
+    {
+        wbuffer = RenderPolygonRAM[0]->WBuffer;
+
+        glUseProgram(ShaderClearIndirectWorkCount);
+        glDispatchCompute((numVariants+31)/32, 1, 1);
+
+        // calculate x-spans
+        glBindImageTexture(0, YSpanIndicesTexture, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA16UI);
+        glUseProgram(ShaderInterpXSpans[wbuffer]);
+        glDispatchCompute((numSetupIndices + 31) / 32, 1, 1);
+        glMemoryBarrier(GL_SHADER_STORAGE_BUFFER);
+
+        // bin polygons
+        glUseProgram(ShaderBinCombined);
+        glDispatchCompute(((RenderNumPolygons + 31) / 32), ScreenWidth/CoarseTileW, ScreenHeight/CoarseTileH);
+        glMemoryBarrier(GL_SHADER_STORAGE_BUFFER);
+
+        // calculate list offsets
+        glUseProgram(ShaderCalculateWorkListOffset);
+        glDispatchCompute((numVariants + 31) / 32, 1, 1);
+        glMemoryBarrier(GL_SHADER_STORAGE_BUFFER);
+
+        // sort shader work
+        glUseProgram(ShaderSortWork);
+        glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, BinResultMemory);
+        glDispatchComputeIndirect(offsetof(BinResultHeader, SortWorkWorkCount));
+        glMemoryBarrier(GL_SHADER_STORAGE_BUFFER);
+
+        glActiveTexture(GL_TEXTURE0);
+
+        for (int i = 0; i < tilememoryLayer_Num; i++)
+            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2+i, TileMemory[i]);
+
+        // rasterise
+        {
+            bool highLightMode = RenderDispCnt & (1<<1);
+
+            GLuint shadersNoTexture[] =
+            {
+                ShaderRasteriseNoTexture[wbuffer],
+                ShaderRasteriseNoTexture[wbuffer],
+                highLightMode
+                    ? ShaderRasteriseNoTextureHighlight[wbuffer]
+                    : ShaderRasteriseNoTextureToon[wbuffer],
+                ShaderRasteriseNoTexture[wbuffer],
+                ShaderRasteriseShadowMask[wbuffer]
+            };
+            GLuint shadersUseTexture[] =
+            {
+                ShaderRasteriseUseTextureModulate[wbuffer],
+                ShaderRasteriseUseTextureDecal[wbuffer],
+                highLightMode
+                    ? ShaderRasteriseUseTextureHighlight[wbuffer]
+                    : ShaderRasteriseUseTextureToon[wbuffer],
+                ShaderRasteriseUseTextureDecal[wbuffer],
+                ShaderRasteriseShadowMask[wbuffer]
+            };
+
+            GLuint prevShader = 0;
+            s32 prevTexture = 0, prevSampler = 0;
+            for (int i = 0; i < numVariants; i++)
+            {
+                GLuint shader = 0;
+                if (variants[i].Texture == 0)
+                {
+                    shader = shadersNoTexture[variants[i].BlendMode];
+                }
+                else
+                {
+                    shader = shadersUseTexture[variants[i].BlendMode];
+                    if (variants[i].Texture != prevTexture)
+                    {
+                        glBindTexture(GL_TEXTURE_2D_ARRAY, variants[i].Texture);
+                        prevTexture = variants[i].Texture;
+                    }
+                    if (variants[i].Sampler != prevSampler)
+                    {
+                        glBindSampler(0, variants[i].Sampler);
+                        prevSampler = variants[i].Sampler;
+                    }
+                }
+                assert(shader != 0);
+                if (shader != prevShader)
+                {
+                    glUseProgram(shader);
+                    prevShader = shader;
+                }
+
+                glUniform1ui(UniformIdxCurVariant, i);
+                glUniform2f(UniformIdxTextureSize, 1.f / variants[i].Width, 1.f / variants[i].Height);
+                glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, BinResultMemory);
+                glDispatchComputeIndirect(offsetof(BinResultHeader, VariantWorkCount) + i*4*4);
+            }
+        }
+    }
+    glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
+
+    // compose final image
+    glUseProgram(ShaderDepthBlend[wbuffer]);
+    glDispatchCompute(ScreenWidth/TileSize, ScreenHeight/TileSize, 1);
+    glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
+
+    glBindImageTexture(0, Framebuffer, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8);
+    glBindImageTexture(1, LowResFramebuffer, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8UI);
+    u32 finalPassShader = 0;
+    if (RenderDispCnt & (1<<4))
+        finalPassShader |= 0x4;
+    if (RenderDispCnt & (1<<7))
+        finalPassShader |= 0x2;
+    if (RenderDispCnt & (1<<5))
+        finalPassShader |= 0x1;
+    
+    glUseProgram(ShaderFinalPass[finalPassShader]);
+    glDispatchCompute(ScreenWidth/32, ScreenHeight, 1);
+    glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
+
+    glBindSampler(0, 0);
+
+    /*u64 starttime = armGetSystemTick();
+    EmuQueue.waitIdle();
+    printf("total time %f\n", armTicksToNs(armGetSystemTick()-starttime)*0.000001f);*/
+
+    /*for (u32 i = 0; i < RenderNumPolygons; i++)
+    {
+        if (RenderPolygons[i].Variant >= numVariants)
+        {
+            printf("blarb %d %d %d\n", RenderPolygons[i].Variant, i, RenderNumPolygons);
+        }
+        //assert(RenderPolygons[i].Variant < numVariants);
+    }*/
+
+    /*for (int i = 0; i < binresult->SortWorkWorkCount[0]*32; i++)
+    {
+        printf("sorted %x %x\n", binresult->SortedWork[i*2+0], binresult->SortedWork[i*2+1]);
+    }*/
+/*    if (polygonvisible != -1)
+    {
+        SpanSetupX* xspans = Gfx::DataHeap->CpuAddr<SpanSetupX>(XSpanSetupMemory);
+        printf("span result\n");
+        Polygon* poly = RenderPolygonRAM[polygonvisible];
+        u32 xspanoffset = RenderPolygons[polygonvisible].FirstXSpan;
+        for (u32 i = 0; i < (poly->YBottom - poly->YTop); i++)
+        {
+            printf("%d: %d - %d | %d %d | %d %d\n", i + poly->YTop, xspans[xspanoffset + i].X0, xspans[xspanoffset + i].X1, xspans[xspanoffset + i].__pad0, xspans[xspanoffset + i].__pad1, RenderPolygons[polygonvisible].YTop, RenderPolygons[polygonvisible].YBot);
+        }
+    }*/
+/*
+    printf("xspans: %d\n", numSetupIndices);
+    SpanSetupX* xspans = Gfx::DataHeap->CpuAddr<SpanSetupX>(XSpanSetupMemory[curSlice]);
+    for (int i = 0; i < numSetupIndices; i++)
+    {
+        printf("poly %d %d %d | line %d | %d to %d\n", YSpanIndices[i].PolyIdx, YSpanIndices[i].SpanIdxL, YSpanIndices[i].SpanIdxR, YSpanIndices[i].Y, xspans[i].X0, xspans[i].X1);
+    }
+    printf("bin result\n");
+    BinResult* binresult = Gfx::DataHeap->CpuAddr<BinResult>(BinResultMemory);
+    for (u32 y = 0; y < 192/8; y++)
+    {
+        for (u32 x = 0; x < 256/8; x++)
+        {
+            printf("%08x ", binresult->BinnedMaskCoarse[(x + y * (256/8)) * 2]);
+        }
+        printf("\n");
+    }*/
+}
+
+void ComputeRenderer::RestartFrame()
+{
+
+}
+
+u32* ComputeRenderer::GetLine(int line)
+{
+    int stride = 256;
+
+    if (line == 0)
+    {
+        glBindBuffer(GL_PIXEL_PACK_BUFFER, PixelBuffer);
+        u8* data = (u8*)glMapBuffer(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY);
+        if (data) memcpy(&FramebufferCPU[0], data, 4*stride*192);
+        glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
+    }
+
+    return &FramebufferCPU[stride * line];
+}
+
+void ComputeRenderer::SetupAccelFrame()
+{
+    glBindTexture(GL_TEXTURE_2D, Framebuffer);
+}
+
+void ComputeRenderer::PrepareCaptureFrame()
+{
+    glBindBuffer(GL_PIXEL_PACK_BUFFER, PixelBuffer);
+    glBindTexture(GL_TEXTURE_2D, LowResFramebuffer);
+    glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, nullptr);
+}
+
+}
\ No newline at end of file
diff --git a/src/GPU3D_Compute.h b/src/GPU3D_Compute.h
new file mode 100644
index 0000000..73f840b
--- /dev/null
+++ b/src/GPU3D_Compute.h
@@ -0,0 +1,225 @@
+/*
+    Copyright 2016-2022 melonDS team
+
+    This file is part of melonDS.
+
+    melonDS is free software: you can redistribute it and/or modify it under
+    the terms of the GNU General Public License as published by the Free
+    Software Foundation, either version 3 of the License, or (at your option)
+    any later version.
+
+    melonDS is distributed in the hope that it will be useful, but WITHOUT ANY
+    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+    FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with melonDS. If not, see http://www.gnu.org/licenses/.
+*/
+
+#ifndef GPU3D_COMPUTE
+#define GPU3D_COMPUTE
+
+#include "GPU3D.h"
+
+#include "OpenGLSupport.h"
+
+#include "GPU3D_TexcacheOpenGL.h"
+
+#include "NonStupidBitfield.h"
+
+namespace GPU3D
+{
+
+class ComputeRenderer : public Renderer3D
+{
+public:
+    ComputeRenderer();
+    ~ComputeRenderer() override;
+
+    bool Init() override;
+    void DeInit() override;
+    void Reset() override;
+
+    void SetRenderSettings(GPU::RenderSettings& settings) override;
+
+    void VCount144() override;
+
+    void RenderFrame() override;
+    void RestartFrame() override;
+    u32* GetLine(int line) override;
+
+    void SetupAccelFrame() override;
+    void PrepareCaptureFrame() override;
+private:
+    GLuint ShaderInterpXSpans[2];
+    GLuint ShaderBinCombined;
+    GLuint ShaderDepthBlend[2];
+    GLuint ShaderRasteriseNoTexture[2];
+    GLuint ShaderRasteriseNoTextureToon[2];
+    GLuint ShaderRasteriseNoTextureHighlight[2];
+    GLuint ShaderRasteriseUseTextureDecal[2];
+    GLuint ShaderRasteriseUseTextureModulate[2];
+    GLuint ShaderRasteriseUseTextureToon[2];
+    GLuint ShaderRasteriseUseTextureHighlight[2];
+    GLuint ShaderRasteriseShadowMask[2];
+    GLuint ShaderClearCoarseBinMask;
+    GLuint ShaderClearIndirectWorkCount;
+    GLuint ShaderCalculateWorkListOffset;
+    GLuint ShaderSortWork;
+    GLuint ShaderFinalPass[8];
+
+    GLuint YSpanIndicesTextureMemory;
+    GLuint YSpanIndicesTexture;
+    GLuint YSpanSetupMemory;
+    GLuint XSpanSetupMemory;
+    GLuint BinResultMemory;
+    GLuint RenderPolygonMemory;
+    GLuint WorkDescMemory;
+
+    enum
+    {
+        tilememoryLayer_Color,
+        tilememoryLayer_Depth,
+        tilememoryLayer_Attr,
+        tilememoryLayer_Num,
+    };
+
+    GLuint TileMemory[tilememoryLayer_Num];
+    GLuint FinalTileMemory;
+
+    u32 DummyLine[256] = {};
+
+    struct SpanSetupY
+    {
+        // Attributes
+        s32 Z0, Z1, W0, W1;
+        s32 ColorR0, ColorG0, ColorB0;
+        s32 ColorR1, ColorG1, ColorB1;
+        s32 TexcoordU0, TexcoordV0;
+        s32 TexcoordU1, TexcoordV1;
+
+        // Interpolator
+        s32 I0, I1;
+        s32 Linear;
+        s32 IRecip;
+        s32 W0n, W0d, W1d;
+
+        // Slope
+        s32 Increment;
+
+        s32 X0, X1, Y0, Y1;
+        s32 XMin, XMax;
+        s32 DxInitial;
+
+        s32 XCovIncr;
+        u32 IsDummy;
+    };
+    struct SpanSetupX
+    {
+        s32 X0, X1;
+
+        s32 EdgeLenL, EdgeLenR, EdgeCovL, EdgeCovR;
+
+        s32 XRecip;
+
+        u32 Flags;
+
+        s32 Z0, Z1, W0, W1;
+        s32 ColorR0, ColorG0, ColorB0;
+        s32 ColorR1, ColorG1, ColorB1;
+        s32 TexcoordU0, TexcoordV0;
+        s32 TexcoordU1, TexcoordV1;
+
+        s32 CovLInitial, CovRInitial;
+    };
+    struct SetupIndices
+    {
+        u16 PolyIdx, SpanIdxL, SpanIdxR, Y;
+    };
+    struct RenderPolygon
+    {
+        u32 FirstXSpan;
+        s32 YTop, YBot;
+
+        s32 XMin, XMax;
+        s32 XMinY, XMaxY;
+
+        u32 Variant;
+        u32 Attr;
+
+        float TextureLayer;
+    };
+
+    static constexpr int TileSize = 8;
+    static constexpr int CoarseTileCountX = 8;
+    static constexpr int CoarseTileCountY = 4;
+    static constexpr int CoarseTileW = CoarseTileCountX * TileSize;
+    static constexpr int CoarseTileH = CoarseTileCountY * TileSize;
+
+    static constexpr int BinStride = 2048/32;
+    static constexpr int CoarseBinStride = BinStride/32;
+
+    static constexpr int MaxVariants = 256;
+
+    static constexpr int UniformIdxCurVariant = 0;
+    static constexpr int UniformIdxTextureSize = 1;
+
+    static constexpr int MaxFullscreenLayers = 16;
+
+    struct BinResultHeader
+    {
+        u32 VariantWorkCount[MaxVariants*4];
+        u32 SortedWorkOffset[MaxVariants];
+
+        u32 SortWorkWorkCount[4];
+    };
+
+    static const int MaxYSpanSetups = 6144*2;
+    std::vector<SetupIndices> YSpanIndices;
+    SpanSetupY YSpanSetups[MaxYSpanSetups];
+    RenderPolygon RenderPolygons[2048];
+
+    TexcacheOpenGL Texcache;
+
+    struct MetaUniform
+    {
+        u32 NumPolygons;
+        u32 NumVariants;
+
+        u32 AlphaRef;
+        u32 DispCnt;
+
+        u32 ToonTable[4*34];
+
+        u32 ClearColor, ClearDepth, ClearAttr;
+
+        u32 FogOffset, FogShift, FogColor;
+    };
+    GLuint MetaUniformMemory;
+
+    GLuint Samplers[9];
+
+    GLuint Framebuffer = 0;
+    GLuint LowResFramebuffer;
+    GLuint PixelBuffer;
+
+    u32 FramebufferCPU[256*192];
+
+    int ScreenWidth, ScreenHeight;
+    int TilesPerLine, TileLines;
+    int ScaleFactor = -1;
+    int MaxWorkTiles;
+    bool HiresCoordinates;
+
+    void DeleteShaders();
+
+    void SetupAttrs(SpanSetupY* span, Polygon* poly, int from, int to);
+    void SetupYSpan(RenderPolygon* rp, SpanSetupY* span, Polygon* poly, int from, int to, int side, s32 positions[10][2]);
+    void SetupYSpanDummy(RenderPolygon* rp, SpanSetupY* span, Polygon* poly, int vertex, int side, s32 positions[10][2]);
+
+    bool CompileShader(GLuint& shader, const std::string& source, const std::initializer_list<const char*>& defines);
+};
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/GPU3D_Compute_shaders.h b/src/GPU3D_Compute_shaders.h
new file mode 100644
index 0000000..39858a4
--- /dev/null
+++ b/src/GPU3D_Compute_shaders.h
@@ -0,0 +1,1665 @@
+/*
+    Copyright 2016-2022 melonDS team
+
+    This file is part of melonDS.
+
+    melonDS is free software: you can redistribute it and/or modify it under
+    the terms of the GNU General Public License as published by the Free
+    Software Foundation, either version 3 of the License, or (at your option)
+    any later version.
+
+    melonDS is distributed in the hope that it will be useful, but WITHOUT ANY
+    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+    FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with melonDS. If not, see http://www.gnu.org/licenses/.
+*/
+
+#ifndef GPU3D_COMPUTE_SHADERS
+#define GPU3D_COMPUTE_SHADERS
+
+#include <string>
+
+namespace GPU3D
+{
+
+namespace ComputeRendererShaders
+{
+
+// defines:
+// InterpSpans
+// BinCombined
+// Rasterise
+// DepthBlend
+// ClearCoarseBinMask
+// ClearIndirectWorkCount
+// CalculateWorkOffsets
+// SortWork
+// FinalPass
+
+// AntiAliasing
+// EdgeMarking
+// Fog
+
+// ZBuffer
+// WBuffer
+
+// for Rasterise
+// NoTexture
+// UseTexture
+// Decal
+// Modulate
+// Toon
+// Highlight
+// ShadowMask
+
+
+/*
+    Some notes on signed division:
+
+    we want to avoid it, so we can avoid higher precision numbers
+    in a few places.
+    
+    Fortunately all divisions *should* assuming I'm not mistaken
+    have the same sign on the divisor and the dividend.
+
+    Thus we apply:
+
+    assuming n < 0 <=> d < 0
+    n/d = abs(n)/abs(d)
+
+*/
+
+const std::string XSpanSetupBuffer{R"(
+
+const uint XSpanSetup_Linear = 1U << 0;
+const uint XSpanSetup_FillInside = 1U << 1;
+const uint XSpanSetup_FillLeft = 1U << 2;
+const uint XSpanSetup_FillRight = 1U << 3;
+
+struct XSpanSetup
+{
+    int X0, X1;
+
+    int InsideStart, InsideEnd, EdgeCovL, EdgeCovR;
+
+    int XRecip;
+
+    uint Flags;
+
+    int Z0, Z1, W0, W1;
+    int ColorR0, ColorG0, ColorB0;
+    int ColorR1, ColorG1, ColorB1;
+    int TexcoordU0, TexcoordV0;
+    int TexcoordU1, TexcoordV1;
+
+    int CovLInitial, CovRInitial;
+};
+
+#if defined(Rasterise)
+int CalcYFactorX(XSpanSetup span, int x)
+{
+    x -= span.X0;
+
+    if (span.X0 != span.X1)
+    {
+        uint numLo = uint(x) * uint(span.W0);
+        uint numHi = 0U;
+        numHi |= numLo >> (32U-YFactorShift);
+        numLo <<= YFactorShift;
+
+        uint den = uint(x) * uint(span.W0) + uint(span.X1 - span.X0 - x) * uint(span.W1);
+
+        if (den == 0)
+            return 0;
+        else
+            return int(Div64_32_32(numHi, numLo, den));
+    }
+    else
+    {
+        return 0;
+    }
+}
+#endif
+
+layout (std430, binding = 1) buffer XSpanSetupsBuffer
+{
+    XSpanSetup XSpanSetups[];
+};
+
+)"};
+
+const std::string YSpanSetupBuffer{R"(
+
+struct YSpanSetup
+{
+    // Attributes
+    int Z0, Z1, W0, W1;
+    int ColorR0, ColorG0, ColorB0;
+    int ColorR1, ColorG1, ColorB1;
+    int TexcoordU0, TexcoordV0;
+    int TexcoordU1, TexcoordV1;
+
+    // Interpolator
+    int I0, I1;
+    bool Linear;
+    int IRecip;
+    int W0n, W0d, W1d;
+
+    // Slope
+    int Increment;
+
+    int X0, X1, Y0, Y1;
+    int XMin, XMax;
+    int DxInitial;
+
+    int XCovIncr;
+
+    bool IsDummy;
+};
+
+#if defined(InterpSpans)
+int CalcYFactorY(YSpanSetup span, int i)
+{
+    /*
+        maybe it would be better to do use a 32x32=64 multiplication?
+    */
+    uint numLo = uint(abs(i)) * uint(span.W0n);
+    uint numHi = 0U;
+    numHi |= numLo >> (32U-YFactorShift);
+    numLo <<= YFactorShift;
+
+    uint den = uint(abs(i)) * uint(span.W0d) + uint(abs(span.I1 - span.I0 - i)) * span.W1d;
+
+    if (den == 0)
+    {
+        return 0;
+    }
+    else
+    {
+        return int(Div64_32_32(numHi, numLo, den));
+    }
+}
+
+int CalculateDx(int y, YSpanSetup span)
+{
+    return span.DxInitial + (y - span.Y0) * span.Increment;
+}
+
+int CalculateX(int dx, YSpanSetup span)
+{
+    int x = span.X0;
+    if (span.X1 < span.X0)
+        x -= dx >> 18;
+    else
+        x += dx >> 18;
+    return clamp(x, span.XMin, span.XMax);
+}
+
+void EdgeParams_XMajor(bool side, int dx, YSpanSetup span, out int edgelen, out int edgecov)
+{
+    bool negative = span.X1 < span.X0;
+    int len;
+    if (side != negative)
+        len = (dx >> 18) - ((dx-span.Increment) >> 18);
+    else
+        len = ((dx+span.Increment) >> 18) - (dx >> 18);
+    edgelen = len;
+
+    int xlen = span.XMax + 1 - span.XMin;
+    int startx = dx >> 18;
+    if (negative) startx = xlen - startx;
+    if (side) startx = startx - len + 1;
+
+    uint r;
+    int startcov = int(Div(uint(((startx << 10) + 0x1FF) * (span.Y1 - span.Y0)), uint(xlen), r));
+    edgecov = (1<<31) | ((startcov & 0x3FF) << 12) | (span.XCovIncr & 0x3FF);
+}
+
+void EdgeParams_YMajor(bool side, int dx, YSpanSetup span, out int edgelen, out int edgecov)
+{
+    bool negative = span.X1 < span.X0;
+    edgelen = 1;
+    
+    if (span.Increment == 0)
+    {
+        edgecov = 31;
+    }
+    else
+    {
+        int cov = ((dx >> 9) + (span.Increment >> 10)) >> 4;
+        if ((cov >> 5) != (dx >> 18)) cov = 31;
+        cov &= 0x1F;
+        if (side == negative) cov = 0x1F - cov;
+
+        edgecov = cov;
+    }
+}
+#endif
+
+layout (std430, binding = 2) buffer YSpanSetupsBuffer
+{
+    YSpanSetup YSpanSetups[];
+};
+
+)"};
+
+const std::string PolygonBuffer{R"(
+struct Polygon
+{
+    int FirstXSpan;
+    int YTop, YBot;
+
+    int XMin, XMax;
+    int XMinY, XMaxY;
+
+    int Variant;
+
+    uint Attr;
+
+    float TextureLayer;
+};
+
+layout (std430, binding = 0) readonly buffer PolygonBuffer
+{
+    Polygon Polygons[];
+};
+)"};
+
+const std::string BinningBuffer{R"(
+
+layout (std430, binding = 6) buffer BinResultBuffer
+{
+    uvec4 VariantWorkCount[MaxVariants];
+    uint SortedWorkOffset[MaxVariants];
+
+    uvec4 SortWorkWorkCount;
+
+    uint BinningMaskAndOffset[];
+    //uint BinnedMaskCoarse[TilesPerLine*TileLines*CoarseBinStride];
+    //uint BinnedMask[TilesPerLine*TileLines*BinStride];
+    //uint WorkOffsets[TilesPerLine*TileLines*BinStride];
+};
+
+const int BinningCoarseMaskStart = 0;
+const int BinningMaskStart = BinningCoarseMaskStart+TilesPerLine*TileLines*CoarseBinStride;
+const int BinningWorkOffsetsStart = BinningMaskStart+TilesPerLine*TileLines*BinStride;
+
+)"};
+
+/*
+    structure of each WorkDesc item:
+        x:
+            bits 0-10: polygon idx
+            bits 11-31: tile idx (before sorting within variant after sorting within all tiles)
+        y:
+            bits 0-15: X position on screen
+            bits 15-31: Y position on screen
+*/
+const std::string WorkDescBuffer{R"(
+layout (std430, binding = 7) buffer WorkDescBuffer
+{
+    //uvec2 UnsortedWorkDescs[MaxWorkTiles];
+    //uvec2 SortedWorkDescs[MaxWorkTiles];
+    uvec2 WorkDescs[];
+};
+
+const uint WorkDescsUnsortedStart = 0;
+const uint WorkDescsSortedStart = WorkDescsUnsortedStart+MaxWorkTiles;
+
+)"};
+
+const std::string Tilebuffers{R"(
+layout (std430, binding = 2) buffer ColorTileBuffer
+{
+    uint ColorTiles[];
+};
+layout (std430, binding = 3) buffer DepthTileBuffer
+{
+    uint DepthTiles[];
+};
+layout (std430, binding = 4) buffer AttrTileBuffer
+{
+    uint AttrTiles[];
+};
+
+)"};
+
+const std::string ResultBuffer{R"(
+layout (std430, binding = 5) buffer ResultBuffer
+{
+    uint ResultValue[];
+};
+
+const uint ResultColorStart = 0;
+const uint ResultDepthStart = ResultColorStart+ScreenWidth*ScreenHeight*2;
+const uint ResultAttrStart = ResultDepthStart+ScreenWidth*ScreenHeight*2;
+)"};
+
+const char* Common = R"(
+
+#define TileSize 8
+const int CoarseTileCountX = 8;
+const int CoarseTileCountY = 4;
+const int CoarseTileW = (CoarseTileCountX * TileSize);
+const int CoarseTileH = (CoarseTileCountY * TileSize);
+
+const int FramebufferStride = ScreenWidth*ScreenHeight;
+const int TilesPerLine = ScreenWidth/TileSize;
+const int TileLines = ScreenHeight/TileSize;
+
+const int BinStride = 2048/32;
+const int CoarseBinStride = BinStride/32;
+
+const int MaxVariants = 256;
+
+layout (std140, binding = 0) uniform MetaUniform
+{
+    uint NumPolygons;
+    uint NumVariants;
+
+    int AlphaRef;
+
+    uint DispCnt;
+
+    // r = Toon
+    // g = Fog Density
+    // b = Edge Color
+    uvec4 ToonTable[34];
+
+    uint ClearColor, ClearDepth, ClearAttr;
+
+    uint FogOffset, FogShift, FogColor;
+};
+
+#ifdef InterpSpans
+const int YFactorShift = 9;
+#else
+const int YFactorShift = 8;
+#endif
+
+#if defined(InterpSpans) || defined(Rasterise)
+uint Umulh(uint a, uint b)
+{
+    uint lo, hi;
+    umulExtended(a, b, hi, lo);
+    return hi;
+}
+
+const uint startTable[256] = uint[256](
+    254, 252, 250, 248, 246, 244, 242, 240, 238, 236, 234, 233, 231, 229, 227, 225, 224, 222, 220, 218, 217, 215, 213, 212, 210, 208, 207, 205, 203, 202, 200, 199, 197, 195, 194, 192, 191, 189, 188, 186, 185, 183, 182, 180, 179, 178, 176, 175, 173, 172, 170, 169, 168, 166, 165, 164, 162, 161, 160, 158, 
+157, 156, 154, 153, 152, 151, 149, 148, 147, 146, 144, 143, 142, 141, 139, 138, 137, 136, 135, 134, 132, 131, 130, 129, 128, 127, 126, 125, 123, 122, 121, 120, 119, 118, 117, 116, 115, 114, 113, 112, 111, 110, 109, 108, 107, 106, 105, 104, 103, 102, 101, 100, 99, 98, 97, 96, 95, 94, 93, 92, 91, 90, 89, 88, 88, 87, 86, 85, 84, 83, 82, 81, 80, 80, 79, 78, 77, 76, 75, 74, 74, 73, 72, 71, 70, 70, 69, 68, 67, 66, 66, 65, 64, 63, 62, 62, 61, 60, 59, 59, 58, 57, 56, 56, 55, 54, 53, 53, 52, 51, 50, 50, 49, 48, 48, 47, 46, 46, 45, 44, 43, 43, 42, 41, 41, 40, 39, 39, 38, 37, 37, 36, 35, 35, 34, 33, 33, 32, 32, 31, 30, 30, 29, 28, 28, 27, 27, 26, 25, 25, 24, 24, 23, 22, 22, 21, 21, 20, 19, 19, 18, 18, 17, 17, 16, 15, 15, 14, 14, 13, 13, 12, 12, 11, 10, 10, 9, 9, 8, 8, 7, 7, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0
+);
+
+uint Div(uint x, uint y, out uint r)
+{
+    // https://www.microsoft.com/en-us/research/publication/software-integer-division/
+    uint k = 31 - findMSB(y);
+    uint ty = (y << k) >> (32 - 9);
+    uint t = startTable[ty - 256] + 256;
+    uint z = (t << (32 - 9)) >> (32 - k - 1);
+    uint my = 0 - y;
+
+    z += Umulh(z, my * z);
+    z += Umulh(z, my * z);
+
+    uint q = Umulh(x, z);
+    r = x - y * q;
+    if(r >= y)
+    {
+        r = r - y;
+        q = q + 1;
+        if(r >= y)
+        {
+            r = r - y;
+            q = q + 1;
+        }
+    }
+
+    return q;
+}
+
+uint Div64_32_32(uint numHi, uint numLo, uint den)
+{
+    // based on https://github.com/ridiculousfish/libdivide/blob/3bd34388573681ce563348cdf04fe15d24770d04/libdivide.h#L469
+    // modified to work with half the size 64/32=32 instead of 128/64=64
+    // for further details see https://ridiculousfish.com/blog/posts/labor-of-division-episode-iv.html
+
+    // We work in base 2**16.
+    // A uint32 holds a single digit (in the lower 16 bit). A uint32 holds two digits.
+    // Our numerator is conceptually [num3, num2, num1, num0].
+    // Our denominator is [den1, den0].
+    const uint b = (1U << 16);
+
+    // Determine the normalization factor. We multiply den by this, so that its leading digit is at
+    // least half b. In binary this means just shifting left by the number of leading zeros, so that
+    // there's a 1 in the MSB.
+    // We also shift numer by the same amount. This cannot overflow because numHi < den.
+    // The expression (-shift & 63) is the same as (64 - shift), except it avoids the UB of shifting
+    // by 64. (it's also UB in GLSL!!!!)
+    uint shift = 31 - findMSB(den);
+    den <<= shift;
+    numHi <<= shift;
+    numHi |= (numLo >> (-shift & 31U)) & uint(-int(shift) >> 31);
+    numLo <<= shift;
+
+    // Extract the low digits of the numerator and both digits of the denominator.
+    uint num1 = (numLo >> 16);
+    uint num0 = (numLo & 0xFFFFU);
+    uint den1 = (den >> 16);
+    uint den0 = (den & 0xFFFFU);
+
+    // We wish to compute q1 = [n3 n2 n1] / [d1 d0].
+    // Estimate q1 as [n3 n2] / [d1], and then correct it.
+    // Note while qhat may be 2 digits, q1 is always 1 digit.
+
+    uint rhat;
+    uint qhat = Div(numHi, den1, rhat);
+    uint c1 = qhat * den0;
+    uint c2 = rhat * b + num1;
+    if (c1 > c2) qhat -= (c1 - c2 > den) ? 2 : 1;
+    uint q1 = qhat & 0xFFFFU;
+
+    // Compute the true (partial) remainder.
+    uint rem = numHi * b + num1 - q1 * den;
+
+    // We wish to compute q0 = [rem1 rem0 n0] / [d1 d0].
+    // Estimate q0 as [rem1 rem0] / [d1] and correct it.
+    qhat = Div(rem, den1, rhat);
+    c1 = qhat * den0;
+    c2 = rhat * b + num0;
+    if (c1 > c2) qhat -= (c1 - c2 > den) ? 2 : 1;
+
+    return bitfieldInsert(qhat, q1, 16, 16);
+}
+
+int InterpolateAttrPersp(int y0, int y1, int ifactor)
+{
+    if (y0 == y1)
+        return y0;
+
+    if (y0 < y1)
+        return y0 + (((y1-y0) * ifactor) >> YFactorShift);
+    else
+        return y1 + (((y0-y1) * ((1<<YFactorShift)-ifactor)) >> YFactorShift);
+}
+
+int InterpolateAttrLinear(int y0, int y1, int i, int irecip, int idiff)
+{
+    if (y0 == y1)
+        return y0;
+
+#ifndef Rasterise
+    irecip = abs(irecip);
+#endif
+
+    uint mulLo, mulHi, carry;
+    if (y0 < y1)
+    {
+#ifndef Rasterise
+        uint offset = uint(abs(i));
+#else
+        uint offset = uint(i);
+#endif
+        umulExtended(uint(y1-y0)*offset, uint(irecip), mulHi, mulLo);
+        mulLo = uaddCarry(mulLo, 3U<<24, carry);
+        mulHi += carry;
+        return y0 + int((mulLo >> 30) | (mulHi << (32 - 30)));
+        //return y0 + int(((int64_t(y1-y0) * int64_t(offset) * int64_t(irecip)) + int64_t(3<<24)) >> 30);
+    }
+    else
+    {
+#ifndef Rasterise
+        uint offset = uint(abs(idiff-i));
+#else
+        uint offset = uint(idiff-i);
+#endif
+        umulExtended(uint(y0-y1)*offset, uint(irecip), mulHi, mulLo);
+        mulLo = uaddCarry(mulLo, 3<<24, carry);
+        mulHi += carry;
+        return y1 + int((mulLo >> 30) | (mulHi << (32 - 30)));
+        //return y1 + int(((int64_t(y0-y1) * int64_t(offset) * int64_t(irecip)) + int64_t(3<<24)) >> 30);
+    }
+}
+
+uint InterpolateZZBuffer(int z0, int z1, int i, int irecip, int idiff)
+{
+    if (z0 == z1)
+        return z0;
+
+    uint base, disp, factor;
+    if (z0 < z1)
+    {
+        base = uint(z0);
+        disp = uint(z1 - z0);
+        factor = uint(abs(i));
+    }
+    else
+    {
+        base = uint(z1);
+        disp = uint(z0 - z1),
+        factor = uint(abs(idiff - i));
+    }
+
+#ifdef InterpSpans
+    int shiftl = 0;
+    const int shiftr = 22;
+    if (disp > 0x3FF)
+    {
+        shiftl = findMSB(disp) - 9;
+        disp >>= shiftl;
+    }
+#else
+    disp >>= 9;
+    const int shiftl = 0;
+    const int shiftr = 13;
+#endif
+    uint mulLo, mulHi;
+
+    umulExtended(disp * factor, abs(irecip) >> 8, mulHi, mulLo);
+
+    return base + (((mulLo >> shiftr) | (mulHi << (32 - shiftr))) << shiftl);
+/*
+    int base, disp, factor;
+    if (z0 < z1)
+    {
+        base = z0;
+        disp = z1 - z0;
+        factor = i;
+    }
+    else
+    {
+        base = z1;
+        disp = z0 - z1,
+        factor = idiff - i;
+    }
+
+#ifdef InterpSpans
+    {
+        int shift = 0;
+        while (disp > 0x3FF)
+        {
+            disp >>= 1;
+            shift++;
+        }
+
+        return base + int(((int64_t(disp) * int64_t(factor) * (int64_t(irecip) >> 8)) >> 22) << shift);
+    }
+#else
+    {
+        disp >>= 9;
+        return base + int((int64_t(disp) * int64_t(factor) * (int64_t(irecip) >> 8)) >> 13);
+    }
+#endif*/
+}
+
+uint InterpolateZWBuffer(int z0, int z1, int ifactor)
+{
+    if (z0 == z1)
+        return z0;
+
+#ifdef Rasterise
+    // since the precision along x spans is only 8 bit the result will always fit in 32-bit
+    if (z0 < z1)
+    {
+        return uint(z0) + (((z1-z0) * ifactor) >> YFactorShift);
+    }
+    else
+    {
+        return uint(z1) + (((z0-z1) * ((1<<YFactorShift)-ifactor)) >> YFactorShift);
+    }
+#else
+    uint mulLo, mulHi;
+    if (z0 < z1)
+    {
+        umulExtended(z1-z0, ifactor, mulHi, mulLo);
+        // 64-bit shift
+        return uint(z0) + ((mulLo >> YFactorShift) | (mulHi << (32-YFactorShift)));
+    }
+    else
+    {
+        umulExtended(z0-z1, (1<<YFactorShift)-ifactor, mulHi, mulLo);
+        return uint(z1) + ((mulLo >> YFactorShift) | (mulHi << (32-YFactorShift)));
+    }
+#endif
+    /*if (z0 < z1)
+    {
+        return uint(z0) + uint((int64_t(z1-z0) * int64_t(ifactor)) >> YFactorShift);
+    }
+    else
+    {
+        return uint(z1) + uint((int64_t(z0-z1) * int64_t((1<<YFactorShift)-ifactor)) >> YFactorShift);
+    }*/
+}
+#endif
+
+)";
+
+const std::string InterpSpans = 
+    PolygonBuffer +
+    XSpanSetupBuffer +
+    YSpanSetupBuffer + R"(
+layout (local_size_x = 32) in;
+
+layout (binding = 0, rgba16ui) uniform readonly uimageBuffer SetupIndices;
+
+void main()
+{
+    uvec4 setup = imageLoad(SetupIndices, int(gl_GlobalInvocationID.x));
+
+    YSpanSetup spanL = YSpanSetups[setup.y];
+    YSpanSetup spanR = YSpanSetups[setup.z];
+    
+    XSpanSetup xspan;
+    xspan.Flags = 0U;
+
+    int y = int(setup.w);
+
+    int dxl = CalculateDx(y, spanL);
+    int dxr = CalculateDx(y, spanR);
+
+    int xl = CalculateX(dxl, spanL);
+    int xr = CalculateX(dxr, spanR);
+
+    Polygon polygon = Polygons[setup.x];
+
+    int edgeLenL, edgeLenR;
+
+    if (xl > xr)
+    {
+        YSpanSetup tmpSpan = spanL;
+        spanL = spanR;
+        spanR = tmpSpan;
+
+        int tmp = xl;
+        xl = xr;
+        xr = tmp;
+    
+        EdgeParams_YMajor(false, dxr, spanL, edgeLenL, xspan.EdgeCovL);
+        EdgeParams_YMajor(true, dxl, spanR, edgeLenR, xspan.EdgeCovR);
+    }
+    else
+    {
+        // edges are the right way
+        if (spanL.Increment > 0x40000)
+            EdgeParams_XMajor(false, dxl, spanL, edgeLenL, xspan.EdgeCovL);
+        else
+            EdgeParams_YMajor(false, dxl, spanL, edgeLenL, xspan.EdgeCovL);
+        if (spanR.Increment > 0x40000)
+            EdgeParams_XMajor(true, dxr, spanR, edgeLenR, xspan.EdgeCovR);
+        else
+            EdgeParams_YMajor(true, dxr, spanR, edgeLenR, xspan.EdgeCovR);
+    }
+
+    xspan.CovLInitial = (xspan.EdgeCovL >> 12) & 0x3FF;
+    if (xspan.CovLInitial == 0x3FF)
+        xspan.CovLInitial = 0;
+    xspan.CovRInitial = (xspan.EdgeCovR >> 12) & 0x3FF;
+    if (xspan.CovRInitial == 0x3FF)
+        xspan.CovRInitial = 0;
+
+    xspan.X0 = xl;
+    xspan.X1 = xr + 1;
+
+    uint polyalpha = ((polygon.Attr >> 16) & 0x1FU);
+    bool isWireframe = polyalpha == 0U;
+
+    if (!isWireframe || (y == polygon.YTop || y == polygon.YBot - 1))
+        xspan.Flags |= XSpanSetup_FillInside;
+
+    xspan.InsideStart = xspan.X0 + edgeLenL;
+    if (xspan.InsideStart > xspan.X1)
+        xspan.InsideStart = xspan.X1;
+    xspan.InsideEnd = xspan.X1 - edgeLenR;
+    if (xspan.InsideEnd > xspan.X1)
+        xspan.InsideEnd = xspan.X1;
+
+    bool isShadowMask = ((polygon.Attr & 0x3F000030U) == 0x00000030U);
+    bool fillAllEdges = polyalpha < 31 || (DispCnt & (3U<<4)) != 0U;
+
+    if (fillAllEdges || spanL.X1 < spanL.X0 || spanL.Increment <= 0x40000)
+        xspan.Flags |= XSpanSetup_FillLeft;
+    if (fillAllEdges || (spanR.X1 >= spanR.X0 && spanR.Increment > 0x40000) || spanR.Increment == 0)
+        xspan.Flags |= XSpanSetup_FillRight;
+
+    if (spanL.I0 == spanL.I1)
+    {
+        xspan.TexcoordU0 = spanL.TexcoordU0;
+        xspan.TexcoordV0 = spanL.TexcoordV0;
+        xspan.ColorR0 = spanL.ColorR0;
+        xspan.ColorG0 = spanL.ColorG0;
+        xspan.ColorB0 = spanL.ColorB0;
+        xspan.Z0 = spanL.Z0;
+        xspan.W0 = spanL.W0;
+    }
+    else
+    {
+        int i = (spanL.Increment > 0x40000 ? xl : y) - spanL.I0;
+        int ifactor = CalcYFactorY(spanL, i);
+        int idiff = spanL.I1 - spanL.I0;
+
+#ifdef ZBuffer
+        xspan.Z0 = int(InterpolateZZBuffer(spanL.Z0, spanL.Z1, i, spanL.IRecip, idiff));
+#endif
+#ifdef WBuffer
+        xspan.Z0 = int(InterpolateZWBuffer(spanL.Z0, spanL.Z1, ifactor));
+#endif
+
+        if (!spanL.Linear)
+        {
+            xspan.TexcoordU0 = InterpolateAttrPersp(spanL.TexcoordU0, spanL.TexcoordU1, ifactor);
+            xspan.TexcoordV0 = InterpolateAttrPersp(spanL.TexcoordV0, spanL.TexcoordV1, ifactor);
+
+            xspan.ColorR0 = InterpolateAttrPersp(spanL.ColorR0, spanL.ColorR1, ifactor);
+            xspan.ColorG0 = InterpolateAttrPersp(spanL.ColorG0, spanL.ColorG1, ifactor);
+            xspan.ColorB0 = InterpolateAttrPersp(spanL.ColorB0, spanL.ColorB1, ifactor);
+
+            xspan.W0 = InterpolateAttrPersp(spanL.W0, spanL.W1, ifactor);
+        }
+        else
+        {
+            xspan.TexcoordU0 = InterpolateAttrLinear(spanL.TexcoordU0, spanL.TexcoordU1, i, spanL.IRecip, idiff);
+            xspan.TexcoordV0 = InterpolateAttrLinear(spanL.TexcoordV0, spanL.TexcoordV1, i, spanL.IRecip, idiff);
+
+            xspan.ColorR0 = InterpolateAttrLinear(spanL.ColorR0, spanL.ColorR1, i, spanL.IRecip, idiff);
+            xspan.ColorG0 = InterpolateAttrLinear(spanL.ColorG0, spanL.ColorG1, i, spanL.IRecip, idiff);
+            xspan.ColorB0 = InterpolateAttrLinear(spanL.ColorB0, spanL.ColorB1, i, spanL.IRecip, idiff);
+
+            xspan.W0 = spanL.W0; // linear mode is only taken if W0 == W1
+        }
+    }
+
+    if (spanR.I0 == spanR.I1)
+    {
+        xspan.TexcoordU1 = spanR.TexcoordU0;
+        xspan.TexcoordV1 = spanR.TexcoordV0;
+        xspan.ColorR1 = spanR.ColorR0;
+        xspan.ColorG1 = spanR.ColorG0;
+        xspan.ColorB1 = spanR.ColorB0;
+        xspan.Z1 = spanR.Z0;
+        xspan.W1 = spanR.W0;
+    }
+    else
+    {
+        int i = (spanR.Increment > 0x40000 ? xr : y) - spanR.I0;
+        int ifactor = CalcYFactorY(spanR, i);
+        int idiff = spanR.I1 - spanR.I0;
+
+    #ifdef ZBuffer
+            xspan.Z1 = int(InterpolateZZBuffer(spanR.Z0, spanR.Z1, i, spanR.IRecip, idiff));
+    #endif
+    #ifdef WBuffer
+            xspan.Z1 = int(InterpolateZWBuffer(spanR.Z0, spanR.Z1, ifactor));
+    #endif
+
+        if (!spanR.Linear)
+        {
+            xspan.TexcoordU1 = InterpolateAttrPersp(spanR.TexcoordU0, spanR.TexcoordU1, ifactor);
+            xspan.TexcoordV1 = InterpolateAttrPersp(spanR.TexcoordV0, spanR.TexcoordV1, ifactor);
+
+            xspan.ColorR1 = InterpolateAttrPersp(spanR.ColorR0, spanR.ColorR1, ifactor);
+            xspan.ColorG1 = InterpolateAttrPersp(spanR.ColorG0, spanR.ColorG1, ifactor);
+            xspan.ColorB1 = InterpolateAttrPersp(spanR.ColorB0, spanR.ColorB1, ifactor);
+
+            xspan.W1 = int(InterpolateAttrPersp(spanR.W0, spanR.W1, ifactor));
+        }
+        else
+        {
+            xspan.TexcoordU1 = InterpolateAttrLinear(spanR.TexcoordU0, spanR.TexcoordU1, i, spanR.IRecip, idiff);
+            xspan.TexcoordV1 = InterpolateAttrLinear(spanR.TexcoordV0, spanR.TexcoordV1, i, spanR.IRecip, idiff);
+
+            xspan.ColorR1 = InterpolateAttrLinear(spanR.ColorR0, spanR.ColorR1, i, spanR.IRecip, idiff);
+            xspan.ColorG1 = InterpolateAttrLinear(spanR.ColorG0, spanR.ColorG1, i, spanR.IRecip, idiff);
+            xspan.ColorB1 = InterpolateAttrLinear(spanR.ColorB0, spanR.ColorB1, i, spanR.IRecip, idiff);
+
+            xspan.W1 = spanR.W0;
+        }
+    }
+
+    if (xspan.W0 == xspan.W1 && ((xspan.W0 | xspan.W1) & 0x7F) == 0)
+    {
+        xspan.Flags |= XSpanSetup_Linear;
+// a bit hacky, but when wbuffering we only need to calculate xrecip for linear spans
+#ifdef ZBuffer
+    }
+    {
+#endif
+        uint r;
+        xspan.XRecip = int(Div(1U<<30, uint(xspan.X1 - xspan.X0), r));
+    }
+
+    XSpanSetups[gl_GlobalInvocationID.x] = xspan;
+}
+
+)";
+
+const std::string ClearIndirectWorkCount =
+    BinningBuffer + R"(
+
+layout (local_size_x = 32) in;
+
+void main()
+{
+    VariantWorkCount[gl_GlobalInvocationID.x] = uvec4(1, 1, 0, 0);
+}
+
+)";
+
+const std::string ClearCoarseBinMask =
+    BinningBuffer + R"(
+layout (local_size_x = 32) in;
+
+void main()
+{
+    BinningMaskAndOffset[BinningCoarseMaskStart + gl_GlobalInvocationID.x*CoarseBinStride+0] = 0;
+    BinningMaskAndOffset[BinningCoarseMaskStart + gl_GlobalInvocationID.x*CoarseBinStride+1] = 0;
+}
+
+)";
+
+const std::string BinCombined =
+    PolygonBuffer +
+    BinningBuffer +
+    XSpanSetupBuffer +
+    WorkDescBuffer + R"(
+
+layout (local_size_x = 32) in;
+
+bool BinPolygon(Polygon polygon, ivec2 topLeft, ivec2 botRight)
+{
+    if (polygon.YTop > botRight.y || polygon.YBot <= topLeft.y)
+        return false;
+
+    int polygonHeight = polygon.YBot - polygon.YTop;
+
+    /*
+        All (good) polygons are convex. So the following holds true:
+
+        Starting from the top most point where both edges originate
+        the X coordinate of the left edge will stay the same or falls until
+        the minimum X-axis coordinate is reached. Then it stays the same or
+        rises until the point it meets with the right edge.
+
+        The same applies to the right edge, except that it first may rise or stay equal and
+        after the maximum point may only fall or stay the same.
+
+        This means that for every tile which doesn't contain the point where the direction changes
+        we can just get the maximum point by sampling the top most and bottom most coordinate
+        within the tile.
+
+        For a tile which is that the height of the direction change
+
+        As a sidenote another consequence of this design decision is
+        that malformed polygons aren't binned properly.
+
+        As a note bottom Y is exclusive!
+    */
+    int polyInnerTopY = clamp(topLeft.y - polygon.YTop, 0, max(polygonHeight-1, 0));
+    int polyInnerBotY = clamp(botRight.y - polygon.YTop, 0, max(polygonHeight-1, 0));
+
+    XSpanSetup xspanTop = XSpanSetups[polygon.FirstXSpan + polyInnerTopY];
+    XSpanSetup xspanBot = XSpanSetups[polygon.FirstXSpan + polyInnerBotY];
+
+    int minXL;
+    if (polygon.XMinY >= topLeft.y && polygon.XMinY <= botRight.y)
+        minXL = polygon.XMin;
+    else
+        minXL = min(xspanTop.X0, xspanBot.X0);
+
+    if (minXL > botRight.x)
+        return false;
+
+    int maxXR;
+    if (polygon.XMaxY >= topLeft.y && polygon.XMaxY <= botRight.y)
+        maxXR = polygon.XMax;
+    else
+        maxXR = max(xspanTop.X1, xspanBot.X1) - 1;
+
+    if (maxXR < topLeft.x)
+        return false;
+
+    return true;
+}
+
+shared uint mergedMaskShared;
+
+void main()
+{
+    int groupIdx = int(gl_WorkGroupID.x);
+    ivec2 coarseTile = ivec2(gl_WorkGroupID.yz);
+
+#if 0
+    int localIdx = int(gl_SubGroupInvocationARB);
+#else
+    int localIdx = int(gl_LocalInvocationIndex);
+
+    if (localIdx == 0)
+        mergedMaskShared = 0U;
+    barrier();
+#endif
+
+    int polygonIdx = groupIdx * 32 + localIdx;
+
+    ivec2 coarseTopLeft = coarseTile * ivec2(CoarseTileW, CoarseTileH);
+    ivec2 coarseBotRight = coarseTopLeft + ivec2(CoarseTileW-1, CoarseTileH-1);
+
+    bool binned = false;
+    if (polygonIdx < NumPolygons)
+    {
+        binned = BinPolygon(Polygons[polygonIdx], coarseTopLeft, coarseBotRight);
+    }
+
+#if 0
+    uint mergedMask = unpackUint2x32(ballotARB(binned)).x;
+#else
+    if (binned)
+        atomicOr(mergedMaskShared, 1U << localIdx);
+    barrier();
+    uint mergedMask = mergedMaskShared;
+#endif
+
+    ivec2 fineTile = ivec2(localIdx & 0x7, localIdx >> 3);
+
+    ivec2 fineTileTopLeft = coarseTopLeft + fineTile * ivec2(TileSize, TileSize);
+    ivec2 fineTileBotRight = fineTileTopLeft + ivec2(TileSize-1, TileSize-1);
+
+    uint binnedMask = 0U;
+    while (mergedMask != 0U)
+    {
+        int bit = findLSB(mergedMask);
+        mergedMask &= ~(1U << bit);
+
+        int polygonIdx = groupIdx * 32 + bit;
+
+        if (BinPolygon(Polygons[polygonIdx], fineTileTopLeft, fineTileBotRight))
+            binnedMask |= 1U << bit;
+    }
+
+    int linearTile = fineTile.x + fineTile.y * TilesPerLine + coarseTile.x * CoarseTileCountX + coarseTile.y * TilesPerLine * CoarseTileCountY;
+
+    BinningMaskAndOffset[BinningMaskStart + linearTile * BinStride + groupIdx] = binnedMask;
+    int coarseMaskIdx = linearTile * CoarseBinStride + (groupIdx >> 5);
+    if (binnedMask != 0U)
+        atomicOr(BinningMaskAndOffset[BinningCoarseMaskStart + coarseMaskIdx], 1U << (groupIdx & 0x1F));
+
+    if (binnedMask != 0U)
+    {
+        uint workOffset = atomicAdd(VariantWorkCount[0].w, uint(bitCount(binnedMask)));
+        BinningMaskAndOffset[BinningWorkOffsetsStart + linearTile * BinStride + groupIdx] = workOffset;
+
+        uint tilePositionCombined = bitfieldInsert(fineTileTopLeft.x, fineTileTopLeft.y, 16, 16);
+
+        int idx = 0;
+        while (binnedMask != 0U)
+        {
+            int bit = findLSB(binnedMask);
+            binnedMask &= ~(1U << bit);
+
+            int polygonIdx = groupIdx * 32 + bit;
+            int variantIdx = Polygons[polygonIdx].Variant;
+
+            int inVariantOffset = int(atomicAdd(VariantWorkCount[variantIdx].z, 1));
+            WorkDescs[WorkDescsUnsortedStart + workOffset + idx] = uvec2(tilePositionCombined, bitfieldInsert(polygonIdx, inVariantOffset, 12, 20));
+
+            idx++;
+        }
+    }
+}
+
+)";
+
+const std::string CalcOffsets = 
+    BinningBuffer + R"(
+
+layout (local_size_x = 32) in;
+
+void main()
+{
+    if (gl_GlobalInvocationID.x < NumVariants)
+    {
+        if (gl_GlobalInvocationID.x == 0)
+        {
+            // a bit of a cheat putting this here, but this shader won't run that often
+            SortWorkWorkCount = uvec4((VariantWorkCount[0].w + 31) / 32, 1, 1, 0);
+        }
+        SortedWorkOffset[gl_GlobalInvocationID.x] = atomicAdd(VariantWorkCount[1].w, VariantWorkCount[gl_GlobalInvocationID.x].z);
+    }
+}
+
+
+)";
+
+const std::string SortWork =
+    PolygonBuffer +
+    BinningBuffer +
+    WorkDescBuffer + R"(
+
+layout (local_size_x = 32) in;
+
+void main()
+{
+    if (gl_GlobalInvocationID.x < VariantWorkCount[0].w)
+    {
+        uvec2 workDesc = WorkDescs[WorkDescsUnsortedStart + gl_GlobalInvocationID.x];
+        int inVariantOffset = int(bitfieldExtract(workDesc.y, 12, 20));
+        int polygonIdx = int(bitfieldExtract(workDesc.y, 0, 12));
+        int variantIdx = Polygons[polygonIdx].Variant;
+
+        int sortedIndex = int(SortedWorkOffset[variantIdx]) + inVariantOffset;
+        WorkDescs[WorkDescsSortedStart + sortedIndex] = uvec2(workDesc.x, bitfieldInsert(workDesc.y, gl_GlobalInvocationID.x, 12, 20));
+    }
+}
+
+)";
+
+const std::string Rasterise =
+    PolygonBuffer +
+    WorkDescBuffer +
+    XSpanSetupBuffer +
+    BinningBuffer +
+    Tilebuffers + R"(
+
+layout (local_size_x = TileSize, local_size_y = TileSize) in;
+
+layout (binding = 0) uniform usampler2DArray CurrentTexture;
+
+layout (location = 0) uniform uint CurVariant;
+layout (location = 1) uniform vec2 InvTextureSize;
+
+void main()
+{
+    uvec2 workDesc = WorkDescs[WorkDescsSortedStart + SortedWorkOffset[CurVariant] + gl_WorkGroupID.z];
+    Polygon polygon = Polygons[bitfieldExtract(workDesc.y, 0, 12)];
+    ivec2 position = ivec2(bitfieldExtract(workDesc.x, 0, 16), bitfieldExtract(workDesc.x, 16, 16)) + ivec2(gl_LocalInvocationID.xy);
+    int tileOffset = int(bitfieldExtract(workDesc.y, 12, 20)) * TileSize * TileSize + TileSize * int(gl_LocalInvocationID.y) + int(gl_LocalInvocationID.x);
+
+    uint color = 0U;
+    if (position.y >= polygon.YTop && position.y < polygon.YBot)
+    {
+        XSpanSetup xspan = XSpanSetups[polygon.FirstXSpan + (position.y - polygon.YTop)];
+
+        bool insideLeftEdge = position.x < xspan.InsideStart;
+        bool insideRightEdge = position.x >= xspan.InsideEnd;
+        bool insidePolygonInside = !insideLeftEdge && !insideRightEdge;
+
+        if (position.x >= xspan.X0 && position.x < xspan.X1
+            && ((insideLeftEdge && (xspan.Flags & XSpanSetup_FillLeft) != 0U)
+                || (insideRightEdge && (xspan.Flags & XSpanSetup_FillRight) != 0U)
+                || (insidePolygonInside && (xspan.Flags & XSpanSetup_FillInside) != 0U)))
+        {
+            uint attr = 0;
+            if (position.y == polygon.YTop)
+                attr |= 0x4U;
+            else if (position.y == polygon.YBot - 1)
+                attr |= 0x8U;
+
+            if (insideLeftEdge)
+            {
+                attr |= 0x1U;
+
+                int cov = xspan.EdgeCovL;
+                if (cov < 0)
+                {
+                    int xcov = xspan.CovLInitial + (xspan.EdgeCovL & 0x3FF) * (position.x - xspan.X0);
+                    cov = min(xcov >> 5, 31);
+                }
+
+                attr |= uint(cov) << 8;
+            }
+            else if (insideRightEdge)
+            {
+                attr |= 0x2U;
+
+                int cov = xspan.EdgeCovR;
+                if (cov < 0)
+                {
+                    int xcov = xspan.CovRInitial + (xspan.EdgeCovR & 0x3FF) * (position.x - xspan.InsideEnd);
+                    cov = max(0x1F - (xcov >> 5), 0);
+                }
+
+                attr |= uint(cov) << 8;
+            }
+
+            uint z;
+            int u, v, vr, vg, vb;
+
+            if (xspan.X0 == xspan.X1)
+            {
+                z = xspan.Z0;
+                u = xspan.TexcoordU0;
+                v = xspan.TexcoordV0;
+                vr = xspan.ColorR0;
+                vg = xspan.ColorG0;
+                vb = xspan.ColorB0;
+            }
+            else
+            {
+                int ifactor = CalcYFactorX(xspan, position.x);
+                int idiff = xspan.X1 - xspan.X0;
+                int i = position.x - xspan.X0;
+
+#ifdef ZBuffer
+                z = InterpolateZZBuffer(xspan.Z0, xspan.Z1, i, xspan.XRecip, idiff);
+#endif
+#ifdef WBuffer
+                z = InterpolateZWBuffer(xspan.Z0, xspan.Z1, ifactor);
+#endif
+                if ((xspan.Flags & XSpanSetup_Linear) == 0U)
+                {
+                    u = InterpolateAttrPersp(xspan.TexcoordU0, xspan.TexcoordU1, ifactor);
+                    v = InterpolateAttrPersp(xspan.TexcoordV0, xspan.TexcoordV1, ifactor);
+
+                    vr = InterpolateAttrPersp(xspan.ColorR0, xspan.ColorR1, ifactor);
+                    vg = InterpolateAttrPersp(xspan.ColorG0, xspan.ColorG1, ifactor);
+                    vb = InterpolateAttrPersp(xspan.ColorB0, xspan.ColorB1, ifactor);
+                }
+                else
+                {
+                    u = InterpolateAttrLinear(xspan.TexcoordU0, xspan.TexcoordU1, i, xspan.XRecip, idiff);
+                    v = InterpolateAttrLinear(xspan.TexcoordV0, xspan.TexcoordV1, i, xspan.XRecip, idiff);
+
+                    vr = InterpolateAttrLinear(xspan.ColorR0, xspan.ColorR1, i, xspan.XRecip, idiff);
+                    vg = InterpolateAttrLinear(xspan.ColorG0, xspan.ColorG1, i, xspan.XRecip, idiff);
+                    vb = InterpolateAttrLinear(xspan.ColorB0, xspan.ColorB1, i, xspan.XRecip, idiff);
+                }
+            }
+
+#ifndef ShadowMask
+            vr >>= 3;
+            vg >>= 3;
+            vb >>= 3;
+
+            uint r, g, b, a;
+            uint polyalpha = bitfieldExtract(polygon.Attr, 16, 5);
+
+#ifdef Toon
+            uint tooncolor = ToonTable[vr >> 1].r;
+            vr = int(bitfieldExtract(tooncolor, 0, 8));
+            vg = int(bitfieldExtract(tooncolor, 8, 8));
+            vb = int(bitfieldExtract(tooncolor, 16, 8));
+#endif
+#ifdef Highlight
+            vg = vr;
+            vb = vr;
+#endif
+
+#ifdef NoTexture
+            a = int(polyalpha);
+#endif
+            r = vr;
+            g = vg;
+            b = vb;
+
+#ifdef UseTexture
+            vec2 uvf = vec2(ivec2(u, v)) * vec2(1.0 / 16.0) * InvTextureSize;
+
+            uvec4 texcolor = texture(CurrentTexture, vec3(uvf, polygon.TextureLayer));
+#ifdef Decal
+            if (texcolor.a == 31)
+            {
+                r = int(texcolor.r);
+                g = int(texcolor.g);
+                b = int(texcolor.b);
+            }
+            else if (texcolor.a > 0)
+            {
+                r = int((texcolor.r * texcolor.a) + (vr * (31-texcolor.a))) >> 5;
+                g = int((texcolor.g * texcolor.a) + (vg * (31-texcolor.a))) >> 5;
+                b = int((texcolor.b * texcolor.a) + (vb * (31-texcolor.a))) >> 5;
+            }
+            a = int(polyalpha);
+#endif
+#if defined(Modulate) || defined(Toon) || defined(Highlight)
+            r = int((texcolor.r+1) * (vr+1) - 1) >> 6;
+            g = int((texcolor.g+1) * (vg+1) - 1) >> 6;
+            b = int((texcolor.b+1) * (vb+1) - 1) >> 6;
+            a = int((texcolor.a+1) * (polyalpha+1) - 1) >> 5;
+#endif
+#endif
+
+#ifdef Highlight
+            uint tooncolor = ToonTable[vr >> 1].r;
+
+            r = min(r + int(bitfieldExtract(tooncolor, 0, 8)), 63);
+            g = min(g + int(bitfieldExtract(tooncolor, 8, 8)), 63);
+            b = min(b + int(bitfieldExtract(tooncolor, 16, 8)), 63);
+#endif
+
+            if (polyalpha == 0)
+                a = 31;
+
+            if (a > AlphaRef)
+            {
+                color = r | (g << 8) | (b << 16) | (a << 24);
+
+                DepthTiles[tileOffset] = z;
+                AttrTiles[tileOffset] = attr;
+            }
+#else
+            color = 0xFFFFFFFF; // doesn't really matter as long as it's not 0
+            DepthTiles[tileOffset] = z;
+#endif
+        }
+    }
+
+    ColorTiles[tileOffset] = color;
+}
+
+)";
+
+const std::string DepthBlend =
+    PolygonBuffer +
+    Tilebuffers +
+    ResultBuffer +
+    BinningBuffer + R"(
+
+layout (local_size_x = TileSize, local_size_y = TileSize) in;
+
+void PlotTranslucent(inout uint color, inout uint depth, inout uint attr, bool isShadow, uint tileColor, uint srcA, uint tileDepth, uint srcAttr, bool writeDepth)
+{
+    uint blendAttr = (srcAttr & 0xE0F0U) | ((srcAttr >> 8) & 0xFF0000U) | (1U<<22) | (attr & 0xFF001F0FU);
+
+    if ((!isShadow || (attr & (1U<<22)) != 0U)
+        ? (attr & 0x007F0000U) != (blendAttr & 0x007F0000U)
+        : (attr & 0x3F000000U) != (srcAttr & 0x3F000000U))
+    {
+        // le blend
+        if (writeDepth)
+            depth = tileDepth;
+
+        if ((attr & (1U<<15)) == 0)
+            blendAttr &= ~(1U<<15);
+        attr = blendAttr;
+
+        uint srcRB = tileColor & 0x3F003FU;
+        uint srcG = tileColor & 0x003F00U;
+        uint dstRB = color & 0x3F003FU;
+        uint dstG = color & 0x003F00U;
+        uint dstA = color & 0x1F000000U;
+
+        uint alpha = (srcA >> 24) + 1;
+        if (dstA != 0)
+        {
+            srcRB = ((srcRB * alpha) + (dstRB * (32-alpha))) >> 5;
+            srcG = ((srcG * alpha) + (dstG * (32-alpha))) >> 5;
+        }
+
+        color = (srcRB & 0x3F003FU) | (srcG & 0x003F00U) | max(dstA, srcA);
+    }
+}
+
+void ProcessCoarseMask(int linearTile, uint coarseMask, uint coarseOffset,
+    inout uvec2 color, inout uvec2 depth, inout uvec2 attr, inout uint stencil,
+    inout bool prevIsShadowMask)
+{
+    int tileInnerOffset = int(gl_LocalInvocationID.x) + int(gl_LocalInvocationID.y) * TileSize;
+
+    while (coarseMask != 0U)
+    {
+        uint coarseBit = findLSB(coarseMask);
+        coarseMask &= ~(1U << coarseBit);
+
+        uint tileOffset = linearTile * BinStride + coarseBit + coarseOffset;
+
+        uint fineMask = BinningMaskAndOffset[BinningMaskStart + tileOffset];
+        uint workIdx = BinningMaskAndOffset[BinningWorkOffsetsStart + tileOffset];
+
+        while (fineMask != 0U)
+        {
+            uint fineIdx = findLSB(fineMask);
+            fineMask &= ~(1U << fineIdx);
+
+            uint pixelindex = tileInnerOffset + workIdx * TileSize * TileSize;
+            uint tileColor = ColorTiles[pixelindex];
+            workIdx++;
+
+            uint polygonIdx = fineIdx + (coarseBit + coarseOffset) * 32;
+
+            if (tileColor != 0U)
+            {
+                uint polygonAttr = Polygons[polygonIdx].Attr;
+
+                bool isShadowMask = ((polygonAttr & 0x3F000030U) == 0x00000030U);
+                bool prevIsShadowMaskOld = prevIsShadowMask;
+                prevIsShadowMask = isShadowMask;
+
+                bool equalDepthTest = (polygonAttr & (1U << 14)) != 0U;
+
+                uint tileDepth = DepthTiles[pixelindex];
+                uint tileAttr = AttrTiles[pixelindex];
+
+                uint dstattr = attr.x;
+
+                if (!isShadowMask)
+                {
+                    bool isShadow = (polygonAttr & 0x30U) == 0x30U;
+
+                    bool writeSecondLayer = false;
+
+                    if (isShadow)
+                    {
+                        if (stencil == 0U)
+                            continue;
+                        if ((stencil & 1U) == 0U)
+                            writeSecondLayer = true;
+                        if ((stencil & 2U) == 0U)
+                            dstattr &= ~0x3U;
+                    }
+
+                    uint dstDepth = writeSecondLayer ? depth.y : depth.x;
+                    if (!(equalDepthTest
+#ifdef WBuffer
+                        ? dstDepth - tileDepth + 0xFFU <= 0x1FE
+#endif
+#ifdef ZBuffer
+                        ? dstDepth - tileDepth + 0x200 <= 0x400
+#endif
+                        : tileDepth < dstDepth))
+                    {
+                        if ((dstattr & 0x3U) == 0U || writeSecondLayer)
+                            continue;
+
+                        writeSecondLayer = true;
+                        dstattr = attr.y;
+                        if (!(equalDepthTest
+#ifdef WBuffer
+                            ? depth.y - tileDepth + 0xFFU <= 0x1FE
+#endif
+#ifdef ZBuffer
+                            ? depth.y - tileDepth + 0x200 <= 0x400
+#endif
+                            : tileDepth < depth.y))
+                            continue;
+                    }
+
+                    uint srcAttr = (polygonAttr & 0x3F008000U);
+
+                    uint srcA = tileColor & 0x1F000000U;
+                    if (srcA == 0x1F000000U)
+                    {
+                        srcAttr |= tileAttr;
+
+                        if (!writeSecondLayer)
+                        {
+                            if ((srcAttr & 0x3U) != 0U)
+                            {
+                                color.y = color.x;
+                                depth.y = depth.x;
+                                attr.y = attr.x;
+                            }
+
+                            color.x = tileColor;
+                            depth.x = tileDepth;
+                            attr.x = srcAttr;
+                        }
+                        else
+                        {
+                            color.y = tileColor;
+                            depth.y = tileDepth;
+                            attr.y = srcAttr;
+                        }
+                    }
+                    else
+                    {
+                        bool writeDepth = (polygonAttr & (1U<<11)) != 0;
+
+                        if (!writeSecondLayer)
+                        {
+                            // blend into both layers
+                            PlotTranslucent(color.x, depth.x, attr.x, isShadow, tileColor, srcA, tileDepth, srcAttr, writeDepth);
+                        }
+                        if (writeSecondLayer || (dstattr & 0x3U) != 0U)
+                        {
+                            PlotTranslucent(color.y, depth.y, attr.y, isShadow, tileColor, srcA, tileDepth, srcAttr, writeDepth);
+                        }
+                    }
+                }
+                else
+                {
+                    if (!prevIsShadowMaskOld)
+                        stencil = 0;
+
+                    if (!(equalDepthTest
+#ifdef WBuffer
+                        ? depth.x - tileDepth + 0xFFU <= 0x1FE
+#endif
+#ifdef ZBuffer
+                        ? depth.x - tileDepth + 0x200 <= 0x400
+#endif
+                        : tileDepth < depth.x))
+                        stencil = 0x1U;
+
+                    if ((dstattr & 0x3U) != 0U)
+                    {
+                        if (!(equalDepthTest
+#ifdef WBuffer
+                            ? depth.y - tileDepth + 0xFFU <= 0x1FE
+#endif
+#ifdef ZBuffer
+                            ? depth.y - tileDepth + 0x200 <= 0x400
+#endif
+                            : tileDepth < depth.y))
+                            stencil |= 0x2U;
+                    }
+                }
+            }
+        }
+    }
+}
+
+void main()
+{
+    int linearTile = int(gl_WorkGroupID.x + (gl_WorkGroupID.y * TilesPerLine));
+
+    uint coarseMaskLo = BinningMaskAndOffset[BinningCoarseMaskStart + linearTile*CoarseBinStride + 0];
+    uint coarseMaskHi = BinningMaskAndOffset[BinningCoarseMaskStart + linearTile*CoarseBinStride + 1];
+
+    uvec2 color = uvec2(ClearColor, 0U);
+    uvec2 depth = uvec2(ClearDepth, 0U);
+    uvec2 attr = uvec2(ClearAttr, 0U);
+    uint stencil = 0U;
+    bool prevIsShadowMask = false;
+
+    ProcessCoarseMask(linearTile, coarseMaskLo, 0, color, depth, attr, stencil, prevIsShadowMask);
+    ProcessCoarseMask(linearTile, coarseMaskHi, BinStride/2, color, depth, attr, stencil, prevIsShadowMask);
+
+    int resultOffset = int(gl_GlobalInvocationID.x) + int(gl_GlobalInvocationID.y) * ScreenWidth;
+    ResultValue[ResultColorStart+resultOffset] = color.x;
+    ResultValue[ResultColorStart+resultOffset+FramebufferStride] = color.y;
+    ResultValue[ResultDepthStart+resultOffset] = depth.x;
+    ResultValue[ResultDepthStart+resultOffset+FramebufferStride] = depth.y;
+    ResultValue[ResultAttrStart+resultOffset] = attr.x;
+    ResultValue[ResultAttrStart+resultOffset+FramebufferStride] = attr.y;
+}
+
+)";
+
+const std::string FinalPass =
+    ResultBuffer + R"(
+
+layout (local_size_x = 32) in;
+
+layout (binding = 0, rgba8) writeonly uniform image2D FinalFB; 
+layout (binding = 1, rgba8ui) writeonly uniform uimage2D LowResFB; 
+
+uint BlendFog(uint color, uint depth)
+{
+    uint densityid = 0, densityfrac = 0;
+
+    if (depth >= FogOffset)
+    {
+        depth -= FogOffset;
+        depth = (depth >> 2) << FogShift;
+
+        densityid = depth >> 17;
+        if (densityid >= 32)
+        {
+            densityid = 32;
+            densityfrac = 0;
+        }
+        else
+        {
+            densityfrac = depth & 0x1FFFFU;
+        }
+    }
+
+    uint density =
+        ((ToonTable[densityid].g * (0x20000U-densityfrac)) +
+         (ToonTable[densityid+1].g * densityfrac)) >> 17;
+    density = min(density, 128U);
+
+    uint colorRB = color & 0x3F003FU;
+    uint colorGA = (color >> 8) & 0x3F003FU;
+
+    uint fogRB = FogColor & 0x3F003FU;
+    uint fogGA = (FogColor >> 8) & 0x1F003FU;
+
+    uint finalColorRB = ((fogRB * density) + (colorRB * (128-density))) >> 7;
+    uint finalColorGA = ((fogGA * density) + (colorGA * (128-density))) >> 7;
+
+    finalColorRB &= 0x3F003FU;
+    finalColorGA &= 0x1F003FU;
+
+    return (DispCnt & (1U<<6)) != 0
+        ? (bitfieldInsert(color, finalColorGA >> 16, 24, 8))
+        : (finalColorRB | (finalColorGA << 8));
+}
+
+void main()
+{
+    int srcX = int(gl_GlobalInvocationID.x);
+    int resultOffset = int(srcX) + int(gl_GlobalInvocationID.y) * ScreenWidth;
+
+    uvec2 color = uvec2(ResultValue[resultOffset+ResultColorStart], ResultValue[resultOffset+FramebufferStride+ResultColorStart]);
+    uvec2 depth = uvec2(ResultValue[resultOffset+ResultDepthStart], ResultValue[resultOffset+FramebufferStride+ResultDepthStart]);
+    uvec2 attr = uvec2(ResultValue[resultOffset+ResultAttrStart], ResultValue[resultOffset+FramebufferStride+ResultAttrStart]);
+
+#ifdef EdgeMarking
+    if ((attr.x & 0xFU) != 0U)
+    {
+        uvec4 otherAttr = uvec4(ClearAttr);
+        uvec4 otherDepth = uvec4(ClearDepth);
+
+        if (srcX > 0U)
+        {
+            otherAttr.x = ResultValue[resultOffset-1+ResultAttrStart];
+            otherDepth.x = ResultValue[resultOffset-1+ResultDepthStart];
+        }
+        if (srcX < ScreenWidth-1)
+        {
+            otherAttr.y = ResultValue[resultOffset+1+ResultAttrStart];
+            otherDepth.y = ResultValue[resultOffset+1+ResultDepthStart];
+        }
+        if (gl_GlobalInvocationID.y > 0U)
+        {
+            otherAttr.z = ResultValue[resultOffset-ScreenWidth+ResultAttrStart];
+            otherDepth.z = ResultValue[resultOffset-ScreenWidth+ResultDepthStart];
+        }
+        if (gl_GlobalInvocationID.y < ScreenHeight-1)
+        {
+            otherAttr.w = ResultValue[resultOffset+ScreenWidth+ResultAttrStart];
+            otherDepth.w = ResultValue[resultOffset+ScreenWidth+ResultDepthStart];
+        }
+
+        uint polyId = bitfieldExtract(attr.x, 24, 6);
+        uvec4 otherPolyId = bitfieldExtract(otherAttr, 24, 6);
+
+        bvec4 polyIdMismatch = notEqual(uvec4(polyId), otherPolyId);
+        bvec4 nearer = lessThan(uvec4(depth.x), otherDepth);
+
+        if ((polyIdMismatch.x && nearer.x)
+            || (polyIdMismatch.y && nearer.y)
+            || (polyIdMismatch.z && nearer.z)
+            || (polyIdMismatch.w && nearer.w))
+        {
+            color.x = ToonTable[polyId >> 3].b | (color.x & 0xFF000000U);
+            attr.x = (attr.x & 0xFFFFE0FFU) | 0x00001000U;
+        }
+    }
+#endif
+
+#ifdef Fog
+    if ((attr.x & (1U<<15)) != 0U)
+    {
+        color.x = BlendFog(color.x, depth.x);
+    }
+
+    if ((attr.x & 0xFU) != 0 && (attr.y & (1U<<15)) != 0U)
+    {
+        color.y = BlendFog(color.y, depth.y);
+    }
+#endif
+
+#ifdef AntiAliasing
+    // resolve anti-aliasing
+    if ((attr.x & 0x3U) != 0)
+    {
+        uint coverage = (attr.x >> 8) & 0x1FU;
+
+        if (coverage != 0)
+        {
+            uint topRB = color.x & 0x3F003FU;
+            uint topG = color.x & 0x003F00U;
+            uint topA = bitfieldExtract(color.x, 24, 5);
+
+            uint botRB = color.y & 0x3F003FU;
+            uint botG = color.y & 0x003F00U;
+            uint botA = bitfieldExtract(color.y, 24, 5);
+
+            coverage++;
+
+            if (botA > 0)
+            {
+                topRB = ((topRB * coverage) + (botRB * (32-coverage))) >> 5;
+                topG = ((topG * coverage) + (botG * (32-coverage))) >> 5;
+
+                topRB &= 0x3F003FU;
+                topG &= 0x003F00U;
+            }
+
+            topA = ((topA * coverage) + (botA * (32-coverage))) >> 5;
+
+            color.x = topRB | topG | (topA << 24);
+        }
+        else
+        {
+            color.x = color.y;
+        }
+    }
+#endif
+
+//    if (bitfieldExtract(color.x, 24, 8) != 0U)
+//        color.x |= 0x40000000U;
+//    else
+//        color.x = 0U;
+
+    //if ((gl_GlobalInvocationID.y % 8) == 7 || (gl_GlobalInvocationID.y % 8) == 7)
+    //    color.x = 0x1F00001FU | 0x40000000U;
+
+    vec4 result = vec4(bitfieldExtract(color.x, 16, 8), bitfieldExtract(color.x, 8, 8), color.x & 0x3FU, bitfieldExtract(color.x, 24, 8));
+    result /= vec4(63.0, 63.0, 63.0, 31.0);
+    imageStore(FinalFB, ivec2(gl_GlobalInvocationID.xy), result);
+
+    // It's a division by constant, so using the builtin division is fine
+    const int scale = ScreenWidth/256;
+    ivec2 lowresCoordinate = ivec2(gl_GlobalInvocationID.xy) / scale;
+    ivec2 lowresCoordinateRest = ivec2(gl_GlobalInvocationID.xy) % scale;
+    if (lowresCoordinateRest == ivec2(0, 0))
+    {
+        uvec4 color8;
+        color8.x = bitfieldExtract(color.x, 0, 8);
+        color8.y = bitfieldExtract(color.x, 8, 8);
+        color8.z = bitfieldExtract(color.x, 16, 8);
+        color8.w = bitfieldExtract(color.x, 24, 8);
+        imageStore(LowResFB, lowresCoordinate, color8);
+    }
+}
+
+)";
+
+}
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/GPU3D_OpenGL.cpp b/src/GPU3D_OpenGL.cpp
index ebabd51..c67d0f1 100644
--- a/src/GPU3D_OpenGL.cpp
+++ b/src/GPU3D_OpenGL.cpp
@@ -27,46 +27,32 @@
 namespace GPU3D
 {
 
-bool GLRenderer::BuildRenderShader(u32 flags, const char* vs, const char* fs)
+bool GLRenderer::BuildRenderShader(u32 flags, const std::string& vs, const std::string& fs)
 {
     char shadername[32];
     sprintf(shadername, "RenderShader%02X", flags);
 
     int headerlen = strlen(kShaderHeader);
 
-    int vslen = strlen(vs);
-    int vsclen = strlen(kRenderVSCommon);
-    char* vsbuf = new char[headerlen + vsclen + vslen + 1];
-    strcpy(&vsbuf[0], kShaderHeader);
-    strcpy(&vsbuf[headerlen], kRenderVSCommon);
-    strcpy(&vsbuf[headerlen + vsclen], vs);
+    std::string vsbuf;
+    vsbuf += kShaderHeader;
+    vsbuf += kRenderVSCommon;
+    vsbuf += vs;
 
-    int fslen = strlen(fs);
-    int fsclen = strlen(kRenderFSCommon);
-    char* fsbuf = new char[headerlen + fsclen + fslen + 1];
-    strcpy(&fsbuf[0], kShaderHeader);
-    strcpy(&fsbuf[headerlen], kRenderFSCommon);
-    strcpy(&fsbuf[headerlen + fsclen], fs);
+    std::string fsbuf;
+    fsbuf += kShaderHeader;
+    fsbuf += kRenderFSCommon;
+    fsbuf += fs;
 
-    bool ret = OpenGL::BuildShaderProgram(vsbuf, fsbuf, RenderShader[flags], shadername);
-
-    delete[] vsbuf;
-    delete[] fsbuf;
+    GLuint prog;
+    bool ret = OpenGL::CompileVertexFragmentProgram(prog,
+        vsbuf, fsbuf,
+        shadername,
+        {{"vPosition", 0}, {"vColor", 1}, {"vTexcoord", 2}, {"vPolygonAttr", 3}},
+        {{"oColor", 0}, {"oAttr", 1}});
 
     if (!ret) return false;
 
-    GLuint prog = RenderShader[flags][2];
-
-    glBindAttribLocation(prog, 0, "vPosition");
-    glBindAttribLocation(prog, 1, "vColor");
-    glBindAttribLocation(prog, 2, "vTexcoord");
-    glBindAttribLocation(prog, 3, "vPolygonAttr");
-    glBindFragDataLocation(prog, 0, "oColor");
-    glBindFragDataLocation(prog, 1, "oAttr");
-
-    if (!OpenGL::LinkShaderProgram(RenderShader[flags]))
-        return false;
-
     GLint uni_id = glGetUniformBlockIndex(prog, "uConfig");
     glUniformBlockBinding(prog, uni_id, 0);
 
@@ -77,13 +63,15 @@ bool GLRenderer::BuildRenderShader(u32 flags, const char* vs, const char* fs)
     uni_id = glGetUniformLocation(prog, "TexPalMem");
     glUniform1i(uni_id, 1);
 
+    RenderShader[flags] = prog;
+
     return true;
 }
 
 void GLRenderer::UseRenderShader(u32 flags)
 {
     if (CurShaderID == flags) return;
-    glUseProgram(RenderShader[flags][2]);
+    glUseProgram(RenderShader[flags]);
     CurShaderID = flags;
 }
 
@@ -111,21 +99,17 @@ bool GLRenderer::Init()
     glDepthRange(0, 1);
     glClearDepth(1.0);
 
-
-    if (!OpenGL::BuildShaderProgram(kClearVS, kClearFS, ClearShaderPlain, "ClearShader"))
+    if (!OpenGL::CompileVertexFragmentProgram(ClearShaderPlain,
+            kClearVS, kClearFS,
+            "ClearShader",
+            {{"vPosition", 0}},
+            {{"oColor", 0}, {"oAttr", 1}}))
         return false;
 
-    glBindAttribLocation(ClearShaderPlain[2], 0, "vPosition");
-    glBindFragDataLocation(ClearShaderPlain[2], 0, "oColor");
-    glBindFragDataLocation(ClearShaderPlain[2], 1, "oAttr");
-
-    if (!OpenGL::LinkShaderProgram(ClearShaderPlain))
-        return false;
-
-    ClearUniformLoc[0] = glGetUniformLocation(ClearShaderPlain[2], "uColor");
-    ClearUniformLoc[1] = glGetUniformLocation(ClearShaderPlain[2], "uDepth");
-    ClearUniformLoc[2] = glGetUniformLocation(ClearShaderPlain[2], "uOpaquePolyID");
-    ClearUniformLoc[3] = glGetUniformLocation(ClearShaderPlain[2], "uFogFlag");
+    ClearUniformLoc[0] = glGetUniformLocation(ClearShaderPlain, "uColor");
+    ClearUniformLoc[1] = glGetUniformLocation(ClearShaderPlain, "uDepth");
+    ClearUniformLoc[2] = glGetUniformLocation(ClearShaderPlain, "uOpaquePolyID");
+    ClearUniformLoc[3] = glGetUniformLocation(ClearShaderPlain, "uFogFlag");
 
     memset(RenderShader, 0, sizeof(RenderShader));
 
@@ -146,42 +130,35 @@ bool GLRenderer::Init()
     if (!BuildRenderShader(RenderFlag_ShadowMask | RenderFlag_WBuffer,
                            kRenderVS_W, kRenderFS_WSM)) return false;
 
-
-    if (!OpenGL::BuildShaderProgram(kFinalPassVS, kFinalPassEdgeFS, FinalPassEdgeShader, "FinalPassEdgeShader"))
+    if (!OpenGL::CompileVertexFragmentProgram(FinalPassEdgeShader,
+            kFinalPassVS, kFinalPassEdgeFS,
+            "FinalPassEdgeShader",
+            {{"vPosition", 0}},
+            {{"oColor", 0}}))
         return false;
-    if (!OpenGL::BuildShaderProgram(kFinalPassVS, kFinalPassFogFS, FinalPassFogShader, "FinalPassFogShader"))
+    if (!OpenGL::CompileVertexFragmentProgram(FinalPassFogShader,
+            kFinalPassVS, kFinalPassFogFS,
+            "FinalPassFogShader",
+            {{"vPosition", 0}},
+            {{"oColor", 0}}))
         return false;
 
-    glBindAttribLocation(FinalPassEdgeShader[2], 0, "vPosition");
-    glBindFragDataLocation(FinalPassEdgeShader[2], 0, "oColor");
-
-    if (!OpenGL::LinkShaderProgram(FinalPassEdgeShader))
-        return false;
-
-    uni_id = glGetUniformBlockIndex(FinalPassEdgeShader[2], "uConfig");
-    glUniformBlockBinding(FinalPassEdgeShader[2], uni_id, 0);
-
-    glUseProgram(FinalPassEdgeShader[2]);
+    uni_id = glGetUniformBlockIndex(FinalPassEdgeShader, "uConfig");
+    glUniformBlockBinding(FinalPassEdgeShader, uni_id, 0);
 
-    uni_id = glGetUniformLocation(FinalPassEdgeShader[2], "DepthBuffer");
+    glUseProgram(FinalPassEdgeShader);
+    uni_id = glGetUniformLocation(FinalPassEdgeShader, "DepthBuffer");
     glUniform1i(uni_id, 0);
-    uni_id = glGetUniformLocation(FinalPassEdgeShader[2], "AttrBuffer");
+    uni_id = glGetUniformLocation(FinalPassEdgeShader, "AttrBuffer");
     glUniform1i(uni_id, 1);
 
-    glBindAttribLocation(FinalPassFogShader[2], 0, "vPosition");
-    glBindFragDataLocation(FinalPassFogShader[2], 0, "oColor");
+    uni_id = glGetUniformBlockIndex(FinalPassFogShader, "uConfig");
+    glUniformBlockBinding(FinalPassFogShader, uni_id, 0);
 
-    if (!OpenGL::LinkShaderProgram(FinalPassFogShader))
-        return false;
-
-    uni_id = glGetUniformBlockIndex(FinalPassFogShader[2], "uConfig");
-    glUniformBlockBinding(FinalPassFogShader[2], uni_id, 0);
-
-    glUseProgram(FinalPassFogShader[2]);
-
-    uni_id = glGetUniformLocation(FinalPassFogShader[2], "DepthBuffer");
+    glUseProgram(FinalPassFogShader);
+    uni_id = glGetUniformLocation(FinalPassFogShader, "DepthBuffer");
     glUniform1i(uni_id, 0);
-    uni_id = glGetUniformLocation(FinalPassFogShader[2], "AttrBuffer");
+    uni_id = glGetUniformLocation(FinalPassFogShader, "AttrBuffer");
     glUniform1i(uni_id, 1);
 
 
@@ -234,29 +211,26 @@ bool GLRenderer::Init()
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexBufferID);
     glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(IndexBuffer), NULL, GL_DYNAMIC_DRAW);
 
-    glGenFramebuffers(4, &FramebufferID[0]);
-    glBindFramebuffer(GL_FRAMEBUFFER, FramebufferID[0]);
-
-    glGenTextures(8, &FramebufferTex[0]);
-    FrontBuffer = 0;
+    glGenFramebuffers(1, &MainFramebuffer);
 
     // color buffers
-    SetupDefaultTexParams(FramebufferTex[0]);
-    SetupDefaultTexParams(FramebufferTex[1]);
+    glGenTextures(1, &ColorBufferTex);
+    SetupDefaultTexParams(ColorBufferTex);
 
     // depth/stencil buffer
-    SetupDefaultTexParams(FramebufferTex[4]);
-    SetupDefaultTexParams(FramebufferTex[6]);
+    glGenTextures(1, &DepthBufferTex);
+    SetupDefaultTexParams(DepthBufferTex);
 
     // attribute buffer
     // R: opaque polyID (for edgemarking)
     // G: edge flag
     // B: fog flag
-    SetupDefaultTexParams(FramebufferTex[5]);
-    SetupDefaultTexParams(FramebufferTex[7]);
+    glGenTextures(1, &AttrBufferTex);
+    SetupDefaultTexParams(AttrBufferTex);
 
     // downscale framebuffer for display capture (always 256x192)
-    SetupDefaultTexParams(FramebufferTex[3]);
+    glGenTextures(1, &DownScaleBufferTex);
+    SetupDefaultTexParams(DownScaleBufferTex);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 192, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 
     glEnable(GL_BLEND);
@@ -292,8 +266,12 @@ void GLRenderer::DeInit()
     glDeleteTextures(1, &TexMemID);
     glDeleteTextures(1, &TexPalMemID);
 
-    glDeleteFramebuffers(4, &FramebufferID[0]);
-    glDeleteTextures(8, &FramebufferTex[0]);
+    glDeleteFramebuffers(1, &MainFramebuffer);
+    glDeleteFramebuffers(1, &DownscaleFramebuffer);
+    glDeleteTextures(1, &ColorBufferTex);
+    glDeleteTextures(1, &DepthBufferTex);
+    glDeleteTextures(1, &AttrBufferTex);
+    glDeleteTextures(1, &DownScaleBufferTex);
 
     glDeleteVertexArrays(1, &VertexArrayID);
     glDeleteBuffers(1, &VertexBufferID);
@@ -304,8 +282,8 @@ void GLRenderer::DeInit()
 
     for (int i = 0; i < 16; i++)
     {
-        if (!RenderShader[i][2]) continue;
-        OpenGL::DeleteShaderProgram(RenderShader[i]);
+        if (!RenderShader[i]) continue;
+        glDeleteProgram(RenderShader[i]);
     }
 }
 
@@ -323,40 +301,25 @@ void GLRenderer::SetRenderSettings(GPU::RenderSettings& settings)
     ScreenW = 256 * scale;
     ScreenH = 192 * scale;
 
-    glBindTexture(GL_TEXTURE_2D, FramebufferTex[0]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ScreenW, ScreenH, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-    glBindTexture(GL_TEXTURE_2D, FramebufferTex[1]);
+    glBindTexture(GL_TEXTURE_2D, ColorBufferTex);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ScreenW, ScreenH, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 
-    glBindTexture(GL_TEXTURE_2D, FramebufferTex[4]);
+    glBindTexture(GL_TEXTURE_2D, DepthBufferTex);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, ScreenW, ScreenH, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, NULL);
-    glBindTexture(GL_TEXTURE_2D, FramebufferTex[5]);
+    glBindTexture(GL_TEXTURE_2D, AttrBufferTex);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, ScreenW, ScreenH, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
 
-    glBindTexture(GL_TEXTURE_2D, FramebufferTex[6]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, ScreenW, ScreenH, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, NULL);
-    glBindTexture(GL_TEXTURE_2D, FramebufferTex[7]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, ScreenW, ScreenH, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
-
-    glBindFramebuffer(GL_FRAMEBUFFER, FramebufferID[3]);
-    glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, FramebufferTex[3], 0);
+    glBindFramebuffer(GL_FRAMEBUFFER, DownscaleFramebuffer);
+    glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, DownScaleBufferTex, 0);
 
     GLenum fbassign[2] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1};
 
-    glBindFramebuffer(GL_FRAMEBUFFER, FramebufferID[0]);
-    glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, FramebufferTex[0], 0);
-    glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, FramebufferTex[4], 0);
-    glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, FramebufferTex[5], 0);
-    glDrawBuffers(2, fbassign);
-
-    glBindFramebuffer(GL_FRAMEBUFFER, FramebufferID[1]);
-    glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, FramebufferTex[1], 0);
-    glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, FramebufferTex[6], 0);
-    glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, FramebufferTex[7], 0);
+    glBindFramebuffer(GL_FRAMEBUFFER, MainFramebuffer);
+    glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, ColorBufferTex, 0);
+    glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, DepthBufferTex, 0);
+    glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, AttrBufferTex, 0);
     glDrawBuffers(2, fbassign);
 
-    glBindFramebuffer(GL_FRAMEBUFFER, FramebufferID[0]);
-
     glBindBuffer(GL_PIXEL_PACK_BUFFER, PixelbufferID);
     glBufferData(GL_PIXEL_PACK_BUFFER, 256*192*4, NULL, GL_DYNAMIC_READ);
 
@@ -1065,9 +1028,9 @@ void GLRenderer::RenderSceneChunk(int y, int h)
         glStencilMask(0);
 
         glActiveTexture(GL_TEXTURE0);
-        glBindTexture(GL_TEXTURE_2D, FramebufferTex[FrontBuffer ? 6 : 4]);
+        glBindTexture(GL_TEXTURE_2D, DepthBufferTex);
         glActiveTexture(GL_TEXTURE1);
-        glBindTexture(GL_TEXTURE_2D, FramebufferTex[FrontBuffer ? 7 : 5]);
+        glBindTexture(GL_TEXTURE_2D, AttrBufferTex);
 
         glBindBuffer(GL_ARRAY_BUFFER, ClearVertexBufferID);
         glBindVertexArray(ClearVertexArrayID);
@@ -1077,7 +1040,7 @@ void GLRenderer::RenderSceneChunk(int y, int h)
             // edge marking
             // TODO: depth/polyid values at screen edges
 
-            glUseProgram(FinalPassEdgeShader[2]);
+            glUseProgram(FinalPassEdgeShader);
 
             glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ZERO, GL_ONE);
 
@@ -1088,7 +1051,7 @@ void GLRenderer::RenderSceneChunk(int y, int h)
         {
             // fog
 
-            glUseProgram(FinalPassFogShader[2]);
+            glUseProgram(FinalPassFogShader);
 
             if (RenderDispCnt & (1<<6))
                 glBlendFuncSeparate(GL_ZERO, GL_ONE, GL_CONSTANT_COLOR, GL_ONE_MINUS_SRC_ALPHA);
@@ -1116,7 +1079,7 @@ void GLRenderer::RenderFrame()
     CurShaderID = -1;
 
     glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, FramebufferID[FrontBuffer]);
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, MainFramebuffer);
 
     ShaderConfig.uScreenSize[0] = ScreenW;
     ShaderConfig.uScreenSize[1] = ScreenH;
@@ -1222,7 +1185,7 @@ void GLRenderer::RenderFrame()
     // TODO: check whether 'clear polygon ID' affects translucent polyID
     // (for example when alpha is 1..30)
     {
-        glUseProgram(ClearShaderPlain[2]);
+        glUseProgram(ClearShaderPlain);
         glDepthFunc(GL_ALWAYS);
 
         u32 r = RenderClearAttr1 & 0x1F;
@@ -1282,22 +1245,18 @@ void GLRenderer::RenderFrame()
 
         RenderSceneChunk(0, 192);
     }
-
-    FrontBuffer = FrontBuffer ? 0 : 1;
 }
 
 void GLRenderer::PrepareCaptureFrame()
 {
-    // TODO: make sure this picks the right buffer when doing antialiasing
-    int original_fb = FrontBuffer^1;
-
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, FramebufferID[original_fb]);
+    glBindFramebuffer(GL_READ_FRAMEBUFFER, MainFramebuffer);
     glReadBuffer(GL_COLOR_ATTACHMENT0);
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, FramebufferID[3]);
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, DownscaleFramebuffer);
     glDrawBuffer(GL_COLOR_ATTACHMENT0);
     glBlitFramebuffer(0, 0, ScreenW, ScreenH, 0, 0, 256, 192, GL_COLOR_BUFFER_BIT, GL_NEAREST);
 
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, FramebufferID[3]);
+    glBindBuffer(GL_PIXEL_PACK_BUFFER, PixelbufferID);
+    glBindFramebuffer(GL_READ_FRAMEBUFFER, DownscaleFramebuffer);
     glReadPixels(0, 0, 256, 192, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
 }
 
@@ -1307,6 +1266,7 @@ u32* GLRenderer::GetLine(int line)
 
     if (line == 0)
     {
+        glBindBuffer(GL_PIXEL_PACK_BUFFER, PixelbufferID);
         u8* data = (u8*)glMapBuffer(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY);
         if (data) memcpy(&Framebuffer[stride*0], data, 4*stride*192);
         glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
@@ -1326,7 +1286,7 @@ u32* GLRenderer::GetLine(int line)
 
 void GLRenderer::SetupAccelFrame()
 {
-    glBindTexture(GL_TEXTURE_2D, FramebufferTex[FrontBuffer]);
+    glBindTexture(GL_TEXTURE_2D, ColorBufferTex);
 }
 
 }
diff --git a/src/GPU3D_OpenGL.h b/src/GPU3D_OpenGL.h
index a9dd62c..21f815c 100644
--- a/src/GPU3D_OpenGL.h
+++ b/src/GPU3D_OpenGL.h
@@ -40,8 +40,8 @@ public:
     virtual void RenderFrame() override;
     virtual u32* GetLine(int line) override;
 
-    void SetupAccelFrame();
-    void PrepareCaptureFrame();
+    void SetupAccelFrame() override;
+    void PrepareCaptureFrame() override;
 private:
 
     // GL version requirements
@@ -64,7 +64,7 @@ private:
 
     RendererPolygon PolygonList[2048];
 
-    bool BuildRenderShader(u32 flags, const char* vs, const char* fs);
+    bool BuildRenderShader(u32 flags, const std::string& vs, const std::string& fs);
     void UseRenderShader(u32 flags);
     void SetupPolygon(RendererPolygon* rp, Polygon* polygon);
     u32* SetupVertex(Polygon* poly, int vid, Vertex* vtx, u32 vtxattr, u32* vptr);
@@ -83,13 +83,13 @@ private:
     };
 
 
-    GLuint ClearShaderPlain[3];
+    GLuint ClearShaderPlain;
 
-    GLuint RenderShader[16][3];
+    GLuint RenderShader[16];
     GLuint CurShaderID = -1;
 
-    GLuint FinalPassEdgeShader[3];
-    GLuint FinalPassFogShader[3];
+    GLuint FinalPassEdgeShader;
+    GLuint FinalPassFogShader;
 
     // std140 compliant structure
     struct
@@ -142,11 +142,11 @@ private:
     bool BetterPolygons;
     int ScreenW, ScreenH;
 
-    GLuint FramebufferTex[8];
-    int FrontBuffer;
-    GLuint FramebufferID[4], PixelbufferID;
-    u32 Framebuffer[256*192];
-
+    GLuint ColorBufferTex, DepthBufferTex, AttrBufferTex;
+    GLuint DownScaleBufferTex;
+    GLuint PixelbufferID;
 
+    GLuint MainFramebuffer, DownscaleFramebuffer;
+    u32 Framebuffer[256*192];
 };
 }
\ No newline at end of file
diff --git a/src/GPU3D_Texcache.cpp b/src/GPU3D_Texcache.cpp
new file mode 100644
index 0000000..1d409c2
--- /dev/null
+++ b/src/GPU3D_Texcache.cpp
@@ -0,0 +1,269 @@
+#include "GPU3D_Texcache.h"
+
+namespace GPU3D
+{
+
+inline u16 ColorAvg(u16 color0, u16 color1)
+{
+    u32 r0 = color0 & 0x001F;
+    u32 g0 = color0 & 0x03E0;
+    u32 b0 = color0 & 0x7C00;
+    u32 r1 = color1 & 0x001F;
+    u32 g1 = color1 & 0x03E0;
+    u32 b1 = color1 & 0x7C00;
+
+    u32 r = (r0 + r1) >> 1;
+    u32 g = ((g0 + g1) >> 1) & 0x03E0;
+    u32 b = ((b0 + b1) >> 1) & 0x7C00;
+
+    return r | g | b;
+}
+
+inline u16 Color5of3(u16 color0, u16 color1)
+{
+    u32 r0 = color0 & 0x001F;
+    u32 g0 = color0 & 0x03E0;
+    u32 b0 = color0 & 0x7C00;
+    u32 r1 = color1 & 0x001F;
+    u32 g1 = color1 & 0x03E0;
+    u32 b1 = color1 & 0x7C00;
+
+    u32 r = (r0*5 + r1*3) >> 3;
+    u32 g = ((g0*5 + g1*3) >> 3) & 0x03E0;
+    u32 b = ((b0*5 + b1*3) >> 3) & 0x7C00;
+
+    return r | g | b;
+}
+
+inline u16 Color3of5(u16 color0, u16 color1)
+{
+    u32 r0 = color0 & 0x001F;
+    u32 g0 = color0 & 0x03E0;
+    u32 b0 = color0 & 0x7C00;
+    u32 r1 = color1 & 0x001F;
+    u32 g1 = color1 & 0x03E0;
+    u32 b1 = color1 & 0x7C00;
+
+    u32 r = (r0*3 + r1*5) >> 3;
+    u32 g = ((g0*3 + g1*5) >> 3) & 0x03E0;
+    u32 b = ((b0*3 + b1*5) >> 3) & 0x7C00;
+
+    return r | g | b;
+}
+
+inline u32 ConvertRGB5ToRGB8(u16 val)
+{
+    return (((u32)val & 0x1F) << 3)
+        | (((u32)val & 0x3E0) << 6)
+        | (((u32)val & 0x7C00) << 9);
+}
+inline u32 ConvertRGB5ToBGR8(u16 val)
+{
+    return (((u32)val & 0x1F) << 9)
+        | (((u32)val & 0x3E0) << 6)
+        | (((u32)val & 0x7C00) << 3);
+}
+inline u32 ConvertRGB5ToRGB6(u16 val)
+{
+    u8 r = (val & 0x1F) << 1;
+    u8 g = (val & 0x3E0) >> 4;
+    u8 b = (val & 0x7C00) >> 9;
+    if (r) r++;
+    if (g) g++;
+    if (b) b++;
+    return (u32)r | ((u32)g << 8) | ((u32)b << 16);
+}
+
+template <int outputFmt>
+void ConvertBitmapTexture(u32 width, u32 height, u32* output, u8* texData)
+{
+    for (u32 i = 0; i < width*height; i++)
+    {
+        u16 value = *(u16*)&texData[i * 2];
+
+        switch (outputFmt)
+        {
+        case outputFmt_RGB6A5:
+            output[i] = ConvertRGB5ToRGB6(value) | (value & 0x8000 ? 0x1F000000 : 0);
+            break;
+        case outputFmt_RGBA8:
+            output[i] = ConvertRGB5ToRGB8(value) | (value & 0x8000 ? 0xFF000000 : 0);
+            break;
+        case outputFmt_BGRA8:
+            output[i] = ConvertRGB5ToBGR8(value) | (value & 0x8000 ? 0xFF000000 : 0);
+            break;
+        }
+    }
+}
+
+template void ConvertBitmapTexture<outputFmt_RGB6A5>(u32 width, u32 height, u32* output, u8* texData);
+
+template <int outputFmt>
+void ConvertCompressedTexture(u32 width, u32 height, u32* output, u8* texData, u8* texAuxData, u16* palData)
+{
+    // we process a whole block at the time
+    for (int y = 0; y < height / 4; y++)
+    {
+        for (int x = 0; x < width / 4; x++)
+        {
+            u32 data = ((u32*)texData)[x + y * (width / 4)];
+            u16 auxData = ((u16*)texAuxData)[x + y * (width / 4)];
+
+            u32 paletteOffset = auxData & 0x3FFF;
+            u16 color0 = palData[paletteOffset*2] | 0x8000;
+            u16 color1 = palData[paletteOffset*2+1] | 0x8000;
+            u16 color2, color3;
+
+            switch ((auxData >> 14) & 0x3)
+            {
+            case 0:
+                color2 = palData[paletteOffset*2+2] | 0x8000;
+                color3 = 0;
+                break;
+            case 1:
+                {
+                    u32 r0 = color0 & 0x001F;
+                    u32 g0 = color0 & 0x03E0;
+                    u32 b0 = color0 & 0x7C00;
+                    u32 r1 = color1 & 0x001F;
+                    u32 g1 = color1 & 0x03E0;
+                    u32 b1 = color1 & 0x7C00;
+
+                    u32 r = (r0 + r1) >> 1;
+                    u32 g = ((g0 + g1) >> 1) & 0x03E0;
+                    u32 b = ((b0 + b1) >> 1) & 0x7C00;
+                    color2 = r | g | b | 0x8000;
+                }
+                color3 = 0;
+                break;
+            case 2:
+                color2 = palData[paletteOffset*2+2] | 0x8000;
+                color3 = palData[paletteOffset*2+3] | 0x8000;
+                break;
+            case 3:
+                {
+                    u32 r0 = color0 & 0x001F;
+                    u32 g0 = color0 & 0x03E0;
+                    u32 b0 = color0 & 0x7C00;
+                    u32 r1 = color1 & 0x001F;
+                    u32 g1 = color1 & 0x03E0;
+                    u32 b1 = color1 & 0x7C00;
+
+                    u32 r = (r0*5 + r1*3) >> 3;
+                    u32 g = ((g0*5 + g1*3) >> 3) & 0x03E0;
+                    u32 b = ((b0*5 + b1*3) >> 3) & 0x7C00;
+
+                    color2 = r | g | b | 0x8000;
+                }
+                {
+                    u32 r0 = color0 & 0x001F;
+                    u32 g0 = color0 & 0x03E0;
+                    u32 b0 = color0 & 0x7C00;
+                    u32 r1 = color1 & 0x001F;
+                    u32 g1 = color1 & 0x03E0;
+                    u32 b1 = color1 & 0x7C00;
+
+                    u32 r = (r0*3 + r1*5) >> 3;
+                    u32 g = ((g0*3 + g1*5) >> 3) & 0x03E0;
+                    u32 b = ((b0*3 + b1*5) >> 3) & 0x7C00;
+
+                    color3 = r | g | b | 0x8000;
+                }
+                break;
+            }
+
+            // in 2020 our default data types are big enough to be used as lookup tables...
+            u64 packed = color0 | ((u64)color1 << 16) | ((u64)color2 << 32) | ((u64)color3 << 48);
+
+            for (int j = 0; j < 4; j++)
+            {
+                for (int i = 0; i < 4; i++)
+                {
+                    u16 color = (packed >> 16 * (data >> 2 * (i + j * 4))) & 0xFFFF;
+                    u32 res;
+                    switch (outputFmt)
+                    {
+                    case outputFmt_RGB6A5: res = ConvertRGB5ToRGB6(color)
+                        | ((color & 0x8000) ? 0x1F000000 : 0); break;
+                    case outputFmt_RGBA8: res = ConvertRGB5ToRGB8(color)
+                        | ((color & 0x8000) ? 0xFF000000 : 0); break;
+                    case outputFmt_BGRA8: res = ConvertRGB5ToBGR8(color)
+                        | ((color & 0x8000) ? 0xFF000000 : 0); break;
+                    }
+                    output[x * 4 + i + (y * 4 + j) * width] = res;
+                }
+            }
+        }
+    }
+}
+
+template void ConvertCompressedTexture<outputFmt_RGB6A5>(u32, u32, u32*, u8*, u8*, u16*);
+
+template <int outputFmt, int X, int Y>
+void ConvertAXIYTexture(u32 width, u32 height, u32* output, u8* texData, u16* palData)
+{
+    for (int y = 0; y < height; y++)
+    {
+        for (int x = 0; x < width; x++)
+        {
+            u8 val = texData[x + y * width];
+
+            u32 idx = val & ((1 << Y) - 1);
+
+            u16 color = palData[idx];
+            u32 alpha = (val >> Y) & ((1 << X) - 1);
+            if (X != 5)
+                alpha = alpha * 4 + alpha / 2;
+
+            u32 res;
+            switch (outputFmt)
+            {
+            case outputFmt_RGB6A5: res = ConvertRGB5ToRGB6(color) | alpha << 24; break;
+            // make sure full alpha == 255
+            case outputFmt_RGBA8: res = ConvertRGB5ToRGB8(color) | (alpha << 27 | (alpha & 0x1C) << 22); break;
+            case outputFmt_BGRA8: res = ConvertRGB5ToBGR8(color) | (alpha << 27 | (alpha & 0x1C) << 22); break;
+            }
+            output[x + y * width] = res;
+        }
+    }
+}
+
+template void ConvertAXIYTexture<outputFmt_RGB6A5, 5, 3>(u32, u32, u32*, u8*, u16*);
+template void ConvertAXIYTexture<outputFmt_RGB6A5, 3, 5>(u32, u32, u32*, u8*, u16*);
+
+template <int outputFmt, int colorBits>
+void ConvertNColorsTexture(u32 width, u32 height, u32* output, u8* texData, u16* palData, bool color0Transparent)
+{
+    for (int y = 0; y < height; y++)
+    {
+        for (int x = 0; x < width / (8 / colorBits); x++)
+        {
+            u8 val = texData[x + y * (width / (8 / colorBits))];
+
+            for (int i = 0; i < 8 / colorBits; i++)
+            {
+                u32 index = (val >> (i * colorBits)) & ((1 << colorBits) - 1);
+                u16 color = palData[index];
+
+                bool transparent = color0Transparent && index == 0;
+                u32 res;
+                switch (outputFmt)
+                {
+                case outputFmt_RGB6A5: res = ConvertRGB5ToRGB6(color)
+                    | (transparent ? 0 : 0x1F000000); break;
+                case outputFmt_RGBA8: res = ConvertRGB5ToRGB8(color)
+                    | (transparent ? 0 : 0xFF000000); break;
+                case outputFmt_BGRA8: res = ConvertRGB5ToBGR8(color)
+                    | (transparent ? 0 : 0xFF000000); break;
+                }
+                output[x * (8 / colorBits) + y * width + i] = res;
+            }
+        }
+    }
+}
+
+template void ConvertNColorsTexture<outputFmt_RGB6A5, 2>(u32, u32, u32*, u8*, u16*, bool);
+template void ConvertNColorsTexture<outputFmt_RGB6A5, 4>(u32, u32, u32*, u8*, u16*, bool);
+template void ConvertNColorsTexture<outputFmt_RGB6A5, 8>(u32, u32, u32*, u8*, u16*, bool);
+
+}
\ No newline at end of file
diff --git a/src/GPU3D_Texcache.h b/src/GPU3D_Texcache.h
new file mode 100644
index 0000000..73d70cb
--- /dev/null
+++ b/src/GPU3D_Texcache.h
@@ -0,0 +1,309 @@
+#ifndef GPU3D_TEXCACHE
+#define GPU3D_TEXCACHE
+
+#include "types.h"
+#include "GPU.h"
+
+#include <assert.h>
+#include <unordered_map>
+
+#define XXH_STATIC_LINKING_ONLY
+#include "xxhash/xxhash.h"
+
+namespace GPU3D
+{
+
+inline u32 TextureWidth(u32 texparam)
+{
+    return 8 << ((texparam >> 20) & 0x7);
+}
+
+inline u32 TextureHeight(u32 texparam)
+{
+    return 8 << ((texparam >> 23) & 0x7);
+}
+
+enum
+{
+    outputFmt_RGB6A5,
+    outputFmt_RGBA8,
+    outputFmt_BGRA8
+};
+
+template <int outputFmt>
+void ConvertBitmapTexture(u32 width, u32 height, u32* output, u8* texData);
+template <int outputFmt>
+void ConvertCompressedTexture(u32 width, u32 height, u32* output, u8* texData, u8* texAuxData, u16* palData);
+template <int outputFmt, int X, int Y>
+void ConvertAXIYTexture(u32 width, u32 height, u32* output, u8* texData, u16* palData);
+template <int outputFmt, int colorBits>
+void ConvertNColorsTexture(u32 width, u32 height, u32* output, u8* texData, u16* palData, bool color0Transparent);
+
+template <typename TexLoaderT, typename TexHandleT>
+class Texcache
+{
+public:
+    Texcache(const TexLoaderT& texloader)
+        : TexLoader(texloader) // probably better if this would be a move constructor???
+    {}
+
+    bool Update()
+    {
+        auto textureDirty = GPU::VRAMDirty_Texture.DeriveState(GPU::VRAMMap_Texture);
+        auto texPalDirty = GPU::VRAMDirty_TexPal.DeriveState(GPU::VRAMMap_TexPal);
+
+        bool textureChanged = GPU::MakeVRAMFlat_TextureCoherent(textureDirty);
+        bool texPalChanged = GPU::MakeVRAMFlat_TexPalCoherent(texPalDirty);
+
+        if (textureChanged || texPalChanged)
+        {
+            //printf("check invalidation %d\n", TexCache.size());
+            for (auto it = Cache.begin(); it != Cache.end();)
+            {
+                TexCacheEntry& entry = it->second;
+                if (textureChanged)
+                {
+                    for (u32 i = 0; i < 2; i++)
+                    {
+                        u32 startBit = entry.TextureRAMStart[i] / GPU::VRAMDirtyGranularity;
+                        u32 bitsCount = ((entry.TextureRAMStart[i] + entry.TextureRAMSize[i] + GPU::VRAMDirtyGranularity - 1) / GPU::VRAMDirtyGranularity) - startBit;
+
+                        u32 startEntry = startBit >> 6;
+                        u64 entriesCount = ((startBit + bitsCount + 0x3F) >> 6) - startEntry;
+                        for (u32 j = startEntry; j < startEntry + entriesCount; j++)
+                        {
+                            if (GetRangedBitMask(j, startBit, bitsCount) & textureDirty.Data[j])
+                            {
+                                u64 newTexHash = XXH3_64bits(&GPU::VRAMFlat_Texture[entry.TextureRAMStart[i]], entry.TextureRAMSize[i]);
+
+                                if (newTexHash != entry.TextureHash[i])
+                                    goto invalidate;
+                            }
+                        }
+                    }
+                }
+
+                if (texPalChanged && entry.TexPalSize > 0)
+                {
+                    u32 startBit = entry.TexPalStart / GPU::VRAMDirtyGranularity;
+                    u32 bitsCount = ((entry.TexPalStart + entry.TexPalSize + GPU::VRAMDirtyGranularity - 1) / GPU::VRAMDirtyGranularity) - startBit;
+
+                    u32 startEntry = startBit >> 6;
+                    u64 entriesCount = ((startBit + bitsCount + 0x3F) >> 6) - startEntry;
+                    for (u32 j = startEntry; j < startEntry + entriesCount; j++)
+                    {
+                        if (GetRangedBitMask(j, startBit, bitsCount) & texPalDirty.Data[j])
+                        {
+                            u64 newPalHash = XXH3_64bits(&GPU::VRAMFlat_TexPal[entry.TexPalStart], entry.TexPalSize);
+                            if (newPalHash != entry.TexPalHash)
+                                goto invalidate;
+                        }
+                    }
+                }
+
+                it++;
+                continue;
+            invalidate:
+                FreeTextures[entry.WidthLog2][entry.HeightLog2].push_back(entry.Texture);
+
+                //printf("invalidating texture %d\n", entry.ImageDescriptor);
+
+                it = Cache.erase(it);
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    void GetTexture(u32 texParam, u32 palBase, TexHandleT& textureHandle, u32& layer, u32*& helper)
+    {
+        // remove sampling and texcoord gen params
+        texParam &= ~0xC00F0000;
+
+        u32 fmt = (texParam >> 26) & 0x7;
+        u64 key = texParam;
+        if (fmt != 7)
+        {
+            key |= (u64)palBase << 32;
+            if (fmt == 5)
+                key &= ~((u64)1 << 29);
+        }
+        //printf("%" PRIx64 " %" PRIx32 " %" PRIx32 "\n", key, texParam, palBase);
+
+        assert(fmt != 0 && "no texture is not a texture format!");
+
+        auto it = Cache.find(key);
+
+        if (it != Cache.end())
+        {
+            textureHandle = it->second.Texture.TextureID;
+            layer = it->second.Texture.Layer;
+            helper = &it->second.LastVariant;
+            return;
+        }
+
+        u32 widthLog2 = (texParam >> 20) & 0x7;
+        u32 heightLog2 = (texParam >> 23) & 0x7;
+        u32 width = 8 << widthLog2;
+        u32 height = 8 << heightLog2;
+
+        u32 addr = (texParam & 0xFFFF) * 8;
+
+        TexCacheEntry entry = {0};
+
+        entry.TextureRAMStart[0] = addr;
+        entry.WidthLog2 = widthLog2;
+        entry.HeightLog2 = heightLog2;
+
+        // apparently a new texture
+        if (fmt == 7)
+        {
+            entry.TextureRAMSize[0] = width*height*2;
+
+            ConvertBitmapTexture<outputFmt_RGB6A5>(width, height, DecodingBuffer, &GPU::VRAMFlat_Texture[addr]);
+        }
+        else if (fmt == 5)
+        {
+            u8* texData = &GPU::VRAMFlat_Texture[addr];
+            u32 slot1addr = 0x20000 + ((addr & 0x1FFFC) >> 1);
+            if (addr >= 0x40000)
+                slot1addr += 0x10000;
+            u8* texAuxData = &GPU::VRAMFlat_Texture[slot1addr];
+
+            u16* palData = (u16*)(GPU::VRAMFlat_TexPal + palBase*16);
+
+            entry.TextureRAMSize[0] = width*height/16*4;
+            entry.TextureRAMStart[1] = slot1addr;
+            entry.TextureRAMSize[1] = width*height/16*2;
+            entry.TexPalStart = palBase*16;
+            entry.TexPalSize = 0x10000;
+
+            ConvertCompressedTexture<outputFmt_RGB6A5>(width, height, DecodingBuffer, texData, texAuxData, palData);
+        }
+        else
+        {
+            u32 texSize, palAddr = palBase*16, numPalEntries;
+            switch (fmt)
+            {
+            case 1: texSize = width*height; numPalEntries = 32; break;
+            case 6: texSize = width*height; numPalEntries = 8; break;
+            case 2: texSize = width*height/4; numPalEntries = 4; palAddr >>= 1; break;
+            case 3: texSize = width*height/2; numPalEntries = 16; break;
+            case 4: texSize = width*height; numPalEntries = 256; break;
+            }
+
+            palAddr &= 0x1FFFF;
+
+            /*printf("creating texture | fmt: %d | %dx%d | %08x | %08x\n", fmt, width, height, addr, palAddr);
+            svcSleepThread(1000*1000);*/
+
+            entry.TextureRAMSize[0] = texSize;
+            entry.TexPalStart = palAddr;
+            entry.TexPalSize = numPalEntries*2;
+
+            u8* texData = &GPU::VRAMFlat_Texture[addr];
+            u16* palData = (u16*)(GPU::VRAMFlat_TexPal + palAddr);
+
+            //assert(entry.TexPalStart+entry.TexPalSize <= 128*1024*1024);
+
+            bool color0Transparent = texParam & (1 << 29);
+
+            switch (fmt)
+            {
+            case 1: ConvertAXIYTexture<outputFmt_RGB6A5, 3, 5>(width, height, DecodingBuffer, texData, palData); break;
+            case 6: ConvertAXIYTexture<outputFmt_RGB6A5, 5, 3>(width, height, DecodingBuffer, texData, palData); break;
+            case 2: ConvertNColorsTexture<outputFmt_RGB6A5, 2>(width, height, DecodingBuffer, texData, palData, color0Transparent); break;
+            case 3: ConvertNColorsTexture<outputFmt_RGB6A5, 4>(width, height, DecodingBuffer, texData, palData, color0Transparent); break;
+            case 4: ConvertNColorsTexture<outputFmt_RGB6A5, 8>(width, height, DecodingBuffer, texData, palData, color0Transparent); break;
+            }
+        }
+
+        for (int i = 0; i < 2; i++)
+        {
+            if (entry.TextureRAMSize[i])
+                entry.TextureHash[i] = XXH3_64bits(&GPU::VRAMFlat_Texture[entry.TextureRAMStart[i]], entry.TextureRAMSize[i]);
+        }
+        if (entry.TexPalSize)
+            entry.TexPalHash = XXH3_64bits(&GPU::VRAMFlat_TexPal[entry.TexPalStart], entry.TexPalSize);
+
+        auto& texArrays = TexArrays[widthLog2][heightLog2];
+        auto& freeTextures = FreeTextures[widthLog2][heightLog2];
+
+        if (freeTextures.size() == 0)
+        {
+            texArrays.resize(texArrays.size()+1);
+            GLuint& array = texArrays[texArrays.size()-1];
+
+            u32 layers = std::min<u32>((8*1024*1024) / (width*height*4), 64);
+
+            // allocate new array texture
+            //printf("allocating new layer set for %d %d %d %d\n", width, height, texArrays.size()-1, array.ImageDescriptor);
+            array = TexLoader.GenerateTexture(width, height, layers);
+
+            for (u32 i = 0; i < layers; i++)
+            {
+                freeTextures.push_back(TexArrayEntry{array, i});
+            }
+        }
+
+        TexArrayEntry storagePlace = freeTextures[freeTextures.size()-1];
+        freeTextures.pop_back();
+
+        entry.Texture = storagePlace;
+
+        TexLoader.UploadTexture(storagePlace.TextureID, width, height, storagePlace.Layer, DecodingBuffer);
+        //printf("using storage place %d %d | %d %d (%d)\n", width, height, storagePlace.TexArrayIdx, storagePlace.LayerIdx, array.ImageDescriptor);
+
+        textureHandle = storagePlace.TextureID;
+        layer = storagePlace.Layer;
+        helper = &Cache.emplace(std::make_pair(key, entry)).first->second.LastVariant;
+    }
+
+    void Reset()
+    {
+        for (u32 i = 0; i < 8; i++)
+        {
+            for (u32 j = 0; j < 8; j++)
+            {
+                for (u32 k = 0; k < TexArrays[i][j].size(); k++)
+                    TexLoader.DeleteTexture(TexArrays[i][j][k]);
+                TexArrays[i][j].clear();
+                FreeTextures[i][j].clear();
+            }
+        }
+        Cache.clear();
+    }
+private:
+    struct TexArrayEntry
+    {
+        TexHandleT TextureID;
+        u32 Layer;
+    };
+
+    struct TexCacheEntry
+    {
+        u32 LastVariant; // very cheap way to make variant lookup faster
+
+        u32 TextureRAMStart[2], TextureRAMSize[2];
+        u32 TexPalStart, TexPalSize;
+        u8 WidthLog2, HeightLog2;
+        TexArrayEntry Texture;
+
+        u64 TextureHash[2];
+        u64 TexPalHash;
+    };
+    std::unordered_map<u64, TexCacheEntry> Cache;
+
+    TexLoaderT TexLoader;
+
+    std::vector<TexArrayEntry> FreeTextures[8][8];
+    std::vector<TexHandleT> TexArrays[8][8];
+
+    u32 DecodingBuffer[1024*1024];
+};
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/GPU3D_TexcacheOpenGL.cpp b/src/GPU3D_TexcacheOpenGL.cpp
new file mode 100644
index 0000000..0473237
--- /dev/null
+++ b/src/GPU3D_TexcacheOpenGL.cpp
@@ -0,0 +1,29 @@
+#include "GPU3D_TexcacheOpenGL.h"
+
+namespace GPU3D
+{
+
+GLuint TexcacheOpenGLLoader::GenerateTexture(u32 width, u32 height, u32 layers)
+{
+    GLuint texarray;
+    glGenTextures(1, &texarray);
+    glBindTexture(GL_TEXTURE_2D_ARRAY, texarray);
+    glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8UI, width, height, layers);
+    return texarray;
+}
+
+void TexcacheOpenGLLoader::UploadTexture(GLuint handle, u32 width, u32 height, u32 layer, void* data)
+{
+    glBindTexture(GL_TEXTURE_2D_ARRAY, handle);
+    glTexSubImage3D(GL_TEXTURE_2D_ARRAY,
+        0, 0, 0, layer,
+        width, height, 1,
+        GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, data);
+}
+
+void TexcacheOpenGLLoader::DeleteTexture(GLuint handle)
+{
+    glDeleteTextures(1, &handle);
+}
+
+}
\ No newline at end of file
diff --git a/src/GPU3D_TexcacheOpenGL.h b/src/GPU3D_TexcacheOpenGL.h
new file mode 100644
index 0000000..d61ae24
--- /dev/null
+++ b/src/GPU3D_TexcacheOpenGL.h
@@ -0,0 +1,25 @@
+#ifndef GPU3D_TEXCACHEOPENGL
+#define GPU3D_TEXCACHEOPENGL
+
+#include "GPU3D_Texcache.h"
+#include "OpenGLSupport.h"
+
+namespace GPU3D
+{
+
+template <typename, typename>
+class Texcache;
+
+class TexcacheOpenGLLoader
+{
+public:
+    GLuint GenerateTexture(u32 width, u32 height, u32 layers);
+    void UploadTexture(GLuint handle, u32 width, u32 height, u32 layer, void* data);
+    void DeleteTexture(GLuint handle);
+};
+
+using TexcacheOpenGL = Texcache<TexcacheOpenGLLoader, GLuint>;
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/GPU_OpenGL.cpp b/src/GPU_OpenGL.cpp
index 837d224..55c2c7c 100644
--- a/src/GPU_OpenGL.cpp
+++ b/src/GPU_OpenGL.cpp
@@ -34,7 +34,11 @@ using namespace OpenGL;
 
 bool GLCompositor::Init()
 {
-    if (!OpenGL::BuildShaderProgram(kCompositorVS, kCompositorFS_Nearest, CompShader[0], "CompositorShader"))
+    if (!OpenGL::CompileVertexFragmentProgram(CompShader[0],
+            kCompositorVS, kCompositorFS_Nearest, 
+            "CompositorShader",
+            {{"vPosition", 0}, {"vTexcoord", 1}},
+            {{"oColor", 0}}))
     //if (!OpenGL::BuildShaderProgram(kCompositorVS, kCompositorFS_Linear, CompShader[0], "CompositorShader"))
     //if (!OpenGL::BuildShaderProgram(kCompositorVS_xBRZ, kCompositorFS_xBRZ, CompShader[0], "CompositorShader"))
         return false;
@@ -43,20 +47,13 @@ bool GLCompositor::Init()
     {
         GLint uni_id;
 
-        glBindAttribLocation(CompShader[i][2], 0, "vPosition");
-        glBindAttribLocation(CompShader[i][2], 1, "vTexcoord");
-        glBindFragDataLocation(CompShader[i][2], 0, "oColor");
+        CompScaleLoc[i] = glGetUniformLocation(CompShader[i], "u3DScale");
+        Comp3DXPosLoc[i] = glGetUniformLocation(CompShader[i], "u3DXPos");
 
-        if (!OpenGL::LinkShaderProgram(CompShader[i]))
-            return false;
-
-        CompScaleLoc[i] = glGetUniformLocation(CompShader[i][2], "u3DScale");
-        Comp3DXPosLoc[i] = glGetUniformLocation(CompShader[i][2], "u3DXPos");
-
-        glUseProgram(CompShader[i][2]);
-        uni_id = glGetUniformLocation(CompShader[i][2], "ScreenTex");
+        glUseProgram(CompShader[i]);
+        uni_id = glGetUniformLocation(CompShader[i], "ScreenTex");
         glUniform1i(uni_id, 0);
-        uni_id = glGetUniformLocation(CompShader[i][2], "_3DTex");
+        uni_id = glGetUniformLocation(CompShader[i], "_3DTex");
         glUniform1i(uni_id, 1);
     }
 
@@ -133,7 +130,7 @@ void GLCompositor::DeInit()
     glDeleteBuffers(1, &CompVertexBufferID);
 
     for (int i = 0; i < 1; i++)
-        OpenGL::DeleteShaderProgram(CompShader[i]);
+        glDeleteProgram(CompShader[i]);
 }
 
 void GLCompositor::Reset()
@@ -183,9 +180,9 @@ void GLCompositor::Stop()
 
 void GLCompositor::RenderFrame()
 {
-    int frontbuf = GPU::FrontBuffer;
+    int backbuf = GPU::FrontBuffer ^ 1;
     glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, CompScreenOutputFB[frontbuf]);
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, CompScreenOutputFB[backbuf]);
 
     glDisable(GL_DEPTH_TEST);
     glDisable(GL_STENCIL_TEST);
@@ -197,7 +194,7 @@ void GLCompositor::RenderFrame()
     glClear(GL_COLOR_BUFFER_BIT);
 
     // TODO: select more shaders (filtering, etc)
-    OpenGL::UseShaderProgram(CompShader[0]);
+    glUseProgram(CompShader[0]);
     glUniform1ui(CompScaleLoc[0], Scale);
 
     // TODO: support setting this midframe, if ever needed
@@ -206,16 +203,16 @@ void GLCompositor::RenderFrame()
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, CompScreenInputTex);
 
-    if (GPU::Framebuffer[frontbuf][0] && GPU::Framebuffer[frontbuf][1])
+    if (GPU::Framebuffer[backbuf][0] && GPU::Framebuffer[backbuf][1])
     {
         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 256*3 + 1, 192, GL_RGBA_INTEGER,
-                        GL_UNSIGNED_BYTE, GPU::Framebuffer[frontbuf][0]);
+                        GL_UNSIGNED_BYTE, GPU::Framebuffer[backbuf][0]);
         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 192, 256*3 + 1, 192, GL_RGBA_INTEGER,
-                        GL_UNSIGNED_BYTE, GPU::Framebuffer[frontbuf][1]);
+                        GL_UNSIGNED_BYTE, GPU::Framebuffer[backbuf][1]);
     }
 
     glActiveTexture(GL_TEXTURE1);
-    reinterpret_cast<GPU3D::GLRenderer*>(GPU3D::CurrentRenderer.get())->SetupAccelFrame();
+    GPU3D::CurrentRenderer->SetupAccelFrame();
 
     glBindBuffer(GL_ARRAY_BUFFER, CompVertexBufferID);
     glBindVertexArray(CompVertexArrayID);
diff --git a/src/GPU_OpenGL.h b/src/GPU_OpenGL.h
index d27ae20..165dd7c 100644
--- a/src/GPU_OpenGL.h
+++ b/src/GPU_OpenGL.h
@@ -46,7 +46,7 @@ private:
     int Scale;
     int ScreenH, ScreenW;
 
-    GLuint CompShader[1][3];
+    GLuint CompShader[1];
     GLuint CompScaleLoc[1];
     GLuint Comp3DXPosLoc[1];
 
diff --git a/src/NDS.cpp b/src/NDS.cpp
index 2f1759f..2c24c65 100644
--- a/src/NDS.cpp
+++ b/src/NDS.cpp
@@ -33,6 +33,7 @@
 #include "AREngine.h"
 #include "Platform.h"
 #include "FreeBIOS.h"
+#include "GPU3D.h"
 
 #ifdef JIT_ENABLED
 #include "ARMJIT.h"
diff --git a/src/NonStupidBitfield.h b/src/NonStupidBitfield.h
index a4fe7ec..6d9cd2c 100644
--- a/src/NonStupidBitfield.h
+++ b/src/NonStupidBitfield.h
@@ -26,6 +26,32 @@
 #include <initializer_list>
 #include <algorithm>
 
+inline u64 GetRangedBitMask(u32 idx, u32 startBit, u32 bitsCount)
+{
+    u32 startEntry = startBit >> 6;
+    u64 entriesCount = ((startBit + bitsCount + 0x3F) >> 6) - startEntry;
+
+    if (entriesCount > 1)
+    {
+        if (idx == startEntry)
+            return 0xFFFFFFFFFFFFFFFF << (startBit & 0x3F);
+        if (((startBit + bitsCount) & 0x3F) && idx == startEntry + entriesCount - 1)
+            return ~(0xFFFFFFFFFFFFFFFF << ((startBit + bitsCount) & 0x3F));
+
+        return 0xFFFFFFFFFFFFFFFF;
+    }
+    else if (idx == startEntry)
+    {
+        return bitsCount == 64
+            ? 0xFFFFFFFFFFFFFFFF
+            : ((1ULL << bitsCount) - 1) << (startBit & 0x3F);
+    }
+    else
+    {
+        return 0;
+    }
+}
+
 // like std::bitset but less stupid and optimised for 
 // our use case (keeping track of memory invalidations)
 
@@ -164,6 +190,11 @@ struct NonStupidBitField
         return Ref{*this, idx};
     }
 
+    bool operator[](u32 idx) const
+    {
+        return Data[idx >> 6] & (1ULL << (idx & 0x3F));
+    }
+
     void SetRange(u32 startBit, u32 bitsCount)
     {
         u32 startEntry = startBit >> 6;
@@ -185,6 +216,26 @@ struct NonStupidBitField
         }
     }
 
+    int Min() const
+    {
+        for (int i = 0; i < DataLength; i++)
+        {
+            if (Data[i])
+                return i * 64 + __builtin_ctzll(Data[i]);
+        }
+        return -1;
+    }
+
+    int Max() const
+    {
+        for (int i = DataLength - 1; i >= 0; i--)
+        {
+            if (Data[i])
+                return i * 64 + (63 - __builtin_clzll(Data[i]));
+        }
+        return -1;
+    }
+
     NonStupidBitField& operator|=(const NonStupidBitField<Size>& other)
     {
         for (u32 i = 0; i < DataLength; i++)
@@ -193,6 +244,7 @@ struct NonStupidBitField
         }
         return *this;
     }
+
     NonStupidBitField& operator&=(const NonStupidBitField<Size>& other)
     {
         for (u32 i = 0; i < DataLength; i++)
@@ -201,6 +253,20 @@ struct NonStupidBitField
         }
         return *this;
     }
+
+    operator bool() const
+    {
+        for (int i = 0; i < DataLength - 1; i++)
+        {
+            if (Data[i])
+                return true;
+        }
+        if (Data[DataLength-1] & ((Size&0x3F) ? ~(0xFFFFFFFFFFFFFFFF << (Size&0x3F)) : 0xFFFFFFFFFFFFFFFF))
+        {
+            return true;
+        }
+        return false;
+    }
 };
 
 
diff --git a/src/OpenGLSupport.cpp b/src/OpenGLSupport.cpp
index 958930d..4cb0e97 100644
--- a/src/OpenGLSupport.cpp
+++ b/src/OpenGLSupport.cpp
@@ -18,109 +18,323 @@
 
 #include "OpenGLSupport.h"
 
+#include <unordered_map>
+#include <vector>
+
+#include <assert.h>
+
+#define XXH_STATIC_LINKING_ONLY
+#include "xxhash/xxhash.h"
+
 using Platform::Log;
 using Platform::LogLevel;
 
 namespace OpenGL
 {
 
-bool BuildShaderProgram(const char* vs, const char* fs, GLuint* ids, const char* name)
+struct ShaderCacheEntry
 {
-    int len;
-    int res;
+    u32 Length;
+    u8* Data;
+    u32 BinaryFormat;
 
-    ids[0] = glCreateShader(GL_VERTEX_SHADER);
-    len = strlen(vs);
-    glShaderSource(ids[0], 1, &vs, &len);
-    glCompileShader(ids[0]);
+    ShaderCacheEntry(u8* data, u32 length, u32 binaryFmt)
+        : Length(length), Data(data), BinaryFormat(binaryFmt)
+    {
+        assert(data != nullptr);
+    }
 
-    glGetShaderiv(ids[0], GL_COMPILE_STATUS, &res);
-    if (res != GL_TRUE)
+    ShaderCacheEntry(const ShaderCacheEntry&) = delete;
+    ShaderCacheEntry(ShaderCacheEntry&& other)
     {
-        glGetShaderiv(ids[0], GL_INFO_LOG_LENGTH, &res);
-        if (res < 1) res = 1024;
-        char* log = new char[res+1];
-        glGetShaderInfoLog(ids[0], res+1, NULL, log);
-        Log(LogLevel::Error, "OpenGL: failed to compile vertex shader %s: %s\n", name, log);
-        Log(LogLevel::Debug, "shader source:\n--\n%s\n--\n", vs);
-        delete[] log;
+        Data = other.Data;
+        Length = other.Length;
+        BinaryFormat = other.BinaryFormat;
 
-        glDeleteShader(ids[0]);
+        other.Data = nullptr;
+        other.Length = 0;
+        other.BinaryFormat = 0;
+    }
 
-        return false;
+    ~ShaderCacheEntry()
+    {
+        if (Data) // check whether it was moved
+            delete[] Data;
+    }
+};
+
+std::unordered_map<u64, ShaderCacheEntry> ShaderCache;
+std::vector<u64> NewShaders;
+
+constexpr u32 ShaderCacheMagic = 0x11CAC4E1;
+constexpr u32 ShaderCacheVersion = 1;
+
+void LoadShaderCache()
+{
+    // for now the shader cache only contains only compute shaders
+    // because they take the longest to compile
+    FILE* file = Platform::OpenLocalFile("shadercache", "rb");
+    if (file == nullptr)
+    {
+        Log(LogLevel::Error, "Could not find shader cache\n");
+        return;
+    }
+
+    u32 magic, version, numPrograms;
+    if (fread(&magic, 4, 1, file) != 1 || magic != ShaderCacheMagic)
+    {
+        Log(LogLevel::Error, "Shader cache file has invalid magic\n");
+        goto fileInvalid;
     }
 
-    ids[1] = glCreateShader(GL_FRAGMENT_SHADER);
-    len = strlen(fs);
-    glShaderSource(ids[1], 1, &fs, &len);
-    glCompileShader(ids[1]);
+    if (fread(&version, 4, 1, file) != 1 || version != ShaderCacheVersion)
+    {
+        Log(LogLevel::Error, "Shader cache file has bad version\n");
+        goto fileInvalid;
+    }
+
+    if (fread(&numPrograms, 4, 1, file) != 1)
+    {
+        Log(LogLevel::Error, "Shader cache file invalid program count\n");
+        goto fileInvalid;
+    }
+
+    // not the best approach, because once changes pile up
+    // we read and overwrite the old files
+    for (u32 i = 0; i < numPrograms; i++)
+    {
+        int error = 3;
+
+        u32 length, binaryFormat;
+        u64 sourceHash;
+        error -= fread(&sourceHash, 8, 1, file);
+        error -= fread(&length, 4, 1, file);
+        error -= fread(&binaryFormat, 4, 1, file);
+
+        if (error != 0)
+        {
+            Log(LogLevel::Error, "Invalid shader cache entry\n");
+            goto fileInvalid;
+        }
+
+        u8* data = new u8[length];
+        if (fread(data, length, 1, file) != 1)
+        {
+            Log(LogLevel::Error, "Could not read shader cache entry data\n");
+            delete[] data;
+            goto fileInvalid;
+        }
+
+        ShaderCache.erase(sourceHash);
+        ShaderCache.emplace(sourceHash, ShaderCacheEntry(data, length, binaryFormat));
+    }
+
+fileInvalid:
+    fclose(file);
+}
+
+void SaveShaderCache()
+{
+    FILE* file = Platform::OpenLocalFile("shadercache", "rb+");
+    if (file == nullptr)
+        file = Platform::OpenLocalFile("shadercache", "wb");
+
+    if (file == nullptr)
+    {
+        Log(LogLevel::Error, "Could not open or create shader cache file\n");
+        return;
+    }
+
+    int written = 3;
+    u32 magic = ShaderCacheMagic, version = ShaderCacheVersion, numPrograms = ShaderCache.size();
+    written -= fwrite(&magic, 4, 1, file);
+    written -= fwrite(&version, 4, 1, file);
+    written -= fwrite(&numPrograms, 4, 1, file);
+
+    if (written != 0)
+    {
+        Log(LogLevel::Error, "Could not write shader cache header\n");
+        goto writeError;
+    }
+
+    fseek(file, 0, SEEK_END);
+
+    printf("new shaders %d\n", NewShaders.size());
 
-    glGetShaderiv(ids[1], GL_COMPILE_STATUS, &res);
+    for (u64 newShader : NewShaders)
+    {
+        int error = 4;
+        auto it = ShaderCache.find(newShader);
+
+        error -= fwrite(&it->first, 8, 1, file);
+        error -= fwrite(&it->second.Length, 4, 1, file);
+        error -= fwrite(&it->second.BinaryFormat, 4, 1, file);
+        error -= fwrite(it->second.Data, it->second.Length, 1, file);
+
+        if (error != 0)
+        {
+            Log(LogLevel::Error, "Could not insert new shader cache entry\n");
+            goto writeError;
+        }
+    }
+
+writeError:
+    fclose(file);
+
+    NewShaders.clear();
+}
+
+bool CompilerShader(GLuint& id, const std::string& source, const std::string& name, const std::string& type)
+{
+    int res;
+
+    const char* sourceC = source.c_str();
+    int len = source.length();
+    glShaderSource(id, 1, &sourceC, &len);
+    glCompileShader(id);
+
+    glGetShaderiv(id, GL_COMPILE_STATUS, &res);
     if (res != GL_TRUE)
     {
-        glGetShaderiv(ids[1], GL_INFO_LOG_LENGTH, &res);
+        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &res);
         if (res < 1) res = 1024;
         char* log = new char[res+1];
-        glGetShaderInfoLog(ids[1], res+1, NULL, log);
-        Log(LogLevel::Error, "OpenGL: failed to compile fragment shader %s: %s\n", name, log);
-        //printf("shader source:\n--\n%s\n--\n", fs);
+        glGetShaderInfoLog(id, res+1, NULL, log);
+        Log(LogLevel::Error, "OpenGL: failed to compile %s shader %s: %s\n", type.c_str(), name.c_str(), log);
+        Log(LogLevel::Debug, "shader source:\n--\n%s\n--\n", source.c_str());
         delete[] log;
 
-        FILE* logf = fopen("shaderfail.log", "w");
-        fwrite(fs, len+1, 1, logf);
-        fclose(logf);
-
-        glDeleteShader(ids[0]);
-        glDeleteShader(ids[1]);
-
         return false;
     }
 
-    ids[2] = glCreateProgram();
-    glAttachShader(ids[2], ids[0]);
-    glAttachShader(ids[2], ids[1]);
-
     return true;
 }
 
-bool LinkShaderProgram(GLuint* ids)
+bool LinkProgram(GLuint& result, GLuint* ids, int numIds)
 {
     int res;
 
-    glLinkProgram(ids[2]);
+    for (int i = 0; i < numIds; i++)
+    {
+        glAttachShader(result, ids[i]);
+    }
 
-    glDetachShader(ids[2], ids[0]);
-    glDetachShader(ids[2], ids[1]);
+    glLinkProgram(result);
 
-    glDeleteShader(ids[0]);
-    glDeleteShader(ids[1]);
+    for (int i = 0; i < numIds; i++)
+        glDetachShader(result, ids[i]);
 
-    glGetProgramiv(ids[2], GL_LINK_STATUS, &res);
+    glGetProgramiv(result, GL_LINK_STATUS, &res);
     if (res != GL_TRUE)
     {
-        glGetProgramiv(ids[2], GL_INFO_LOG_LENGTH, &res);
+        glGetProgramiv(result, GL_INFO_LOG_LENGTH, &res);
         if (res < 1) res = 1024;
         char* log = new char[res+1];
-        glGetProgramInfoLog(ids[2], res+1, NULL, log);
+        glGetProgramInfoLog(result, res+1, NULL, log);
         Log(LogLevel::Error, "OpenGL: failed to link shader program: %s\n", log);
         delete[] log;
 
-        glDeleteProgram(ids[2]);
-
         return false;
     }
 
     return true;
 }
 
-void DeleteShaderProgram(GLuint* ids)
+bool CompileComputeProgram(GLuint& result, const std::string& source, const std::string& name)
 {
-    glDeleteProgram(ids[2]);
+    result = glCreateProgram();
+
+    /*u64 sourceHash = XXH64(source.data(), source.size(), 0);
+    auto it = ShaderCache.find(sourceHash);
+    if (it != ShaderCache.end())
+    {
+        glProgramBinary(result, it->second.BinaryFormat, it->second.Data, it->second.Length);
+
+        GLint linkStatus;
+        glGetProgramiv(result, GL_LINK_STATUS, &linkStatus);
+        if (linkStatus == GL_TRUE)
+        {
+            Log(LogLevel::Info, "Restored shader %s from cache\n", name.c_str());
+            return true;
+        }
+        else
+        {
+        }
+    }*/
+    Log(LogLevel::Error, "Shader %s from cache was rejected\n", name.c_str());
+
+    GLuint shader = glCreateShader(GL_COMPUTE_SHADER);
+    bool linkingSucess = false;
+
+    if (!CompilerShader(shader, source, name, "compute"))
+        goto error;
+
+    linkingSucess = LinkProgram(result, &shader, 1);
+
+error:
+    glDeleteShader(shader);
+
+    if (!linkingSucess)
+    {
+        glDeleteProgram(result);
+    }
+    /*else
+    {
+        GLint length;
+        GLenum format;
+        glGetProgramiv(result, GL_PROGRAM_BINARY_LENGTH, &length);
+
+        u8* buffer = new u8[length];
+        glGetProgramBinary(result, length, nullptr, &format, buffer);
+
+        ShaderCache.emplace(sourceHash, ShaderCacheEntry(buffer, length, format));
+        NewShaders.push_back(sourceHash);
+    }*/
+
+    return linkingSucess;
 }
 
-void UseShaderProgram(GLuint* ids)
+bool CompileVertexFragmentProgram(GLuint& result,
+    const std::string& vs, const std::string& fs,
+    const std::string& name,
+    const std::initializer_list<AttributeTarget>& vertexInAttrs,
+    const std::initializer_list<AttributeTarget>& fragmentOutAttrs)
 {
-    glUseProgram(ids[2]);
+    GLuint shaders[2] =
+    {
+        glCreateShader(GL_VERTEX_SHADER),
+        glCreateShader(GL_FRAGMENT_SHADER)
+    };
+    result = glCreateProgram();
+
+    bool linkingSucess = false;
+
+    if (!CompilerShader(shaders[0], vs, name, "vertex"))
+        goto error;
+
+    if (!CompilerShader(shaders[1], fs, name, "fragment"))
+        goto error;
+
+
+    for (const AttributeTarget& target : vertexInAttrs)
+    {
+        glBindAttribLocation(result, target.Location, target.Name);
+    }
+    for (const AttributeTarget& target : fragmentOutAttrs)
+    {
+        glBindFragDataLocation(result, target.Location, target.Name);
+    }
+
+    linkingSucess = LinkProgram(result, shaders, 2);
+
+error:
+    glDeleteShader(shaders[1]);
+    glDeleteShader(shaders[0]);
+
+    if (!linkingSucess)
+        glDeleteProgram(result);
+
+    return linkingSucess;
 }
 
 }
diff --git a/src/OpenGLSupport.h b/src/OpenGLSupport.h
index 14be01a..ec2cb1f 100644
--- a/src/OpenGLSupport.h
+++ b/src/OpenGLSupport.h
@@ -29,10 +29,23 @@
 namespace OpenGL
 {
 
-bool BuildShaderProgram(const char* vs, const char* fs, GLuint* ids, const char* name);
-bool LinkShaderProgram(GLuint* ids);
-void DeleteShaderProgram(GLuint* ids);
-void UseShaderProgram(GLuint* ids);
+void LoadShaderCache();
+void SaveShaderCache();
+
+struct AttributeTarget
+{
+    const char* Name;
+    u32 Location;
+};
+
+
+bool CompileVertexFragmentProgram(GLuint& result,
+    const std::string& vs, const std::string& fs,
+    const std::string& name,
+    const std::initializer_list<AttributeTarget>& vertexInAttrs,
+    const std::initializer_list<AttributeTarget>& fragmentOutAttrs);
+
+bool CompileComputeProgram(GLuint& result, const std::string& source, const std::string& name);
 
 }
 
diff --git a/src/frontend/qt_sdl/Config.cpp b/src/frontend/qt_sdl/Config.cpp
index 898e4a1..699f530 100644
--- a/src/frontend/qt_sdl/Config.cpp
+++ b/src/frontend/qt_sdl/Config.cpp
@@ -21,6 +21,7 @@
 #include <stdlib.h>
 #include "Platform.h"
 #include "Config.h"
+#include "GPU.h"
 
 
 namespace Config
@@ -57,6 +58,7 @@ bool Threaded3D;
 
 int GL_ScaleFactor;
 bool GL_BetterPolygons;
+bool GL_HiresCoordinates;
 
 bool LimitFPS;
 bool AudioSync;
@@ -232,11 +234,12 @@ ConfigEntry ConfigFile[] =
     {"ScreenVSync",         1, &ScreenVSync,         false, false},
     {"ScreenVSyncInterval", 0, &ScreenVSyncInterval, 1, false},
 
-    {"3DRenderer", 0, &_3DRenderer, 0, false},
+    {"3DRenderer", 0, &_3DRenderer, GPU::renderer3D_Software, false},
     {"Threaded3D", 1, &Threaded3D, true, false},
 
     {"GL_ScaleFactor", 0, &GL_ScaleFactor, 1, false},
     {"GL_BetterPolygons", 1, &GL_BetterPolygons, false, false},
+    {"GL_HiresCoordinates", 1, &GL_HiresCoordinates, true, false},
 
     {"LimitFPS", 1, &LimitFPS, true, false},
     {"AudioSync", 1, &AudioSync, false},
diff --git a/src/frontend/qt_sdl/Config.cpp.orig b/src/frontend/qt_sdl/Config.cpp.orig
new file mode 100644
index 0000000..898e4a1
--- /dev/null
+++ b/src/frontend/qt_sdl/Config.cpp.orig
@@ -0,0 +1,455 @@
+/*
+    Copyright 2016-2022 melonDS team
+
+    This file is part of melonDS.
+
+    melonDS is free software: you can redistribute it and/or modify it under
+    the terms of the GNU General Public License as published by the Free
+    Software Foundation, either version 3 of the License, or (at your option)
+    any later version.
+
+    melonDS is distributed in the hope that it will be useful, but WITHOUT ANY
+    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+    FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with melonDS. If not, see http://www.gnu.org/licenses/.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "Platform.h"
+#include "Config.h"
+
+
+namespace Config
+{
+
+int KeyMapping[12];
+int JoyMapping[12];
+
+int HKKeyMapping[HK_MAX];
+int HKJoyMapping[HK_MAX];
+
+int JoystickID;
+
+int WindowWidth;
+int WindowHeight;
+bool WindowMaximized;
+
+int ScreenRotation;
+int ScreenGap;
+int ScreenLayout;
+bool ScreenSwap;
+int ScreenSizing;
+bool IntegerScaling;
+int ScreenAspectTop;
+int ScreenAspectBot;
+bool ScreenFilter;
+
+bool ScreenUseGL;
+bool ScreenVSync;
+int ScreenVSyncInterval;
+
+int _3DRenderer;
+bool Threaded3D;
+
+int GL_ScaleFactor;
+bool GL_BetterPolygons;
+
+bool LimitFPS;
+bool AudioSync;
+bool ShowOSD;
+
+int ConsoleType;
+bool DirectBoot;
+
+#ifdef JIT_ENABLED
+bool JIT_Enable = false;
+int JIT_MaxBlockSize = 32;
+bool JIT_BranchOptimisations = true;
+bool JIT_LiteralOptimisations = true;
+bool JIT_FastMemory = true;
+#endif
+
+bool ExternalBIOSEnable;
+
+std::string BIOS9Path;
+std::string BIOS7Path;
+std::string FirmwarePath;
+
+std::string DSiBIOS9Path;
+std::string DSiBIOS7Path;
+std::string DSiFirmwarePath;
+std::string DSiNANDPath;
+
+bool DLDIEnable;
+std::string DLDISDPath;
+int DLDISize;
+bool DLDIReadOnly;
+bool DLDIFolderSync;
+std::string DLDIFolderPath;
+
+bool DSiSDEnable;
+std::string DSiSDPath;
+int DSiSDSize;
+bool DSiSDReadOnly;
+bool DSiSDFolderSync;
+std::string DSiSDFolderPath;
+
+bool FirmwareOverrideSettings;
+std::string FirmwareUsername;
+int FirmwareLanguage;
+int FirmwareBirthdayMonth;
+int FirmwareBirthdayDay;
+int FirmwareFavouriteColour;
+std::string FirmwareMessage;
+std::string FirmwareMAC;
+std::string WifiSettingsPath = "wfcsettings.bin"; // Should this be configurable?
+
+int MPAudioMode;
+int MPRecvTimeout;
+
+std::string LANDevice;
+bool DirectLAN;
+
+bool SavestateRelocSRAM;
+
+int AudioInterp;
+int AudioBitDepth;
+int AudioVolume;
+bool DSiVolumeSync;
+int MicInputType;
+std::string MicDevice;
+std::string MicWavPath;
+
+std::string LastROMFolder;
+std::string LastBIOSFolder;
+
+std::string RecentROMList[10];
+
+std::string SaveFilePath;
+std::string SavestatePath;
+std::string CheatFilePath;
+
+bool EnableCheats;
+
+bool MouseHide;
+int MouseHideSeconds;
+
+bool PauseLostFocus;
+
+bool DSBatteryLevelOkay;
+int DSiBatteryLevel;
+bool DSiBatteryCharging;
+
+bool DSiFullBIOSBoot;
+
+CameraConfig Camera[2];
+
+
+const char* kConfigFile = "melonDS.ini";
+const char* kUniqueConfigFile = "melonDS.%d.ini";
+
+ConfigEntry ConfigFile[] =
+{
+    {"Key_A",      0, &KeyMapping[0],  -1, true},
+    {"Key_B",      0, &KeyMapping[1],  -1, true},
+    {"Key_Select", 0, &KeyMapping[2],  -1, true},
+    {"Key_Start",  0, &KeyMapping[3],  -1, true},
+    {"Key_Right",  0, &KeyMapping[4],  -1, true},
+    {"Key_Left",   0, &KeyMapping[5],  -1, true},
+    {"Key_Up",     0, &KeyMapping[6],  -1, true},
+    {"Key_Down",   0, &KeyMapping[7],  -1, true},
+    {"Key_R",      0, &KeyMapping[8],  -1, true},
+    {"Key_L",      0, &KeyMapping[9],  -1, true},
+    {"Key_X",      0, &KeyMapping[10], -1, true},
+    {"Key_Y",      0, &KeyMapping[11], -1, true},
+
+    {"Joy_A",      0, &JoyMapping[0],  -1, true},
+    {"Joy_B",      0, &JoyMapping[1],  -1, true},
+    {"Joy_Select", 0, &JoyMapping[2],  -1, true},
+    {"Joy_Start",  0, &JoyMapping[3],  -1, true},
+    {"Joy_Right",  0, &JoyMapping[4],  -1, true},
+    {"Joy_Left",   0, &JoyMapping[5],  -1, true},
+    {"Joy_Up",     0, &JoyMapping[6],  -1, true},
+    {"Joy_Down",   0, &JoyMapping[7],  -1, true},
+    {"Joy_R",      0, &JoyMapping[8],  -1, true},
+    {"Joy_L",      0, &JoyMapping[9],  -1, true},
+    {"Joy_X",      0, &JoyMapping[10], -1, true},
+    {"Joy_Y",      0, &JoyMapping[11], -1, true},
+
+    {"HKKey_Lid",                 0, &HKKeyMapping[HK_Lid],                 -1, true},
+    {"HKKey_Mic",                 0, &HKKeyMapping[HK_Mic],                 -1, true},
+    {"HKKey_Pause",               0, &HKKeyMapping[HK_Pause],               -1, true},
+    {"HKKey_Reset",               0, &HKKeyMapping[HK_Reset],               -1, true},
+    {"HKKey_FastForward",         0, &HKKeyMapping[HK_FastForward],         -1, true},
+    {"HKKey_FastForwardToggle",   0, &HKKeyMapping[HK_FastForwardToggle],   -1, true},
+    {"HKKey_FullscreenToggle",    0, &HKKeyMapping[HK_FullscreenToggle],    -1, true},
+    {"HKKey_SwapScreens",         0, &HKKeyMapping[HK_SwapScreens],         -1, true},
+    {"HKKey_SwapScreenEmphasis",  0, &HKKeyMapping[HK_SwapScreenEmphasis],  -1, true},
+    {"HKKey_SolarSensorDecrease", 0, &HKKeyMapping[HK_SolarSensorDecrease], -1, true},
+    {"HKKey_SolarSensorIncrease", 0, &HKKeyMapping[HK_SolarSensorIncrease], -1, true},
+    {"HKKey_FrameStep",           0, &HKKeyMapping[HK_FrameStep],           -1, true},
+    {"HKKey_PowerButton",         0, &HKKeyMapping[HK_PowerButton],         -1, true},
+    {"HKKey_VolumeUp",            0, &HKKeyMapping[HK_VolumeUp],            -1, true},
+    {"HKKey_VolumeDown",          0, &HKKeyMapping[HK_VolumeDown],          -1, true},
+
+    {"HKJoy_Lid",                 0, &HKJoyMapping[HK_Lid],                 -1, true},
+    {"HKJoy_Mic",                 0, &HKJoyMapping[HK_Mic],                 -1, true},
+    {"HKJoy_Pause",               0, &HKJoyMapping[HK_Pause],               -1, true},
+    {"HKJoy_Reset",               0, &HKJoyMapping[HK_Reset],               -1, true},
+    {"HKJoy_FastForward",         0, &HKJoyMapping[HK_FastForward],         -1, true},
+    {"HKJoy_FastForwardToggle",   0, &HKJoyMapping[HK_FastForwardToggle],   -1, true},
+    {"HKJoy_FullscreenToggle",    0, &HKJoyMapping[HK_FullscreenToggle],    -1, true},
+    {"HKJoy_SwapScreens",         0, &HKJoyMapping[HK_SwapScreens],         -1, true},
+    {"HKJoy_SwapScreenEmphasis",  0, &HKJoyMapping[HK_SwapScreenEmphasis],  -1, true},
+    {"HKJoy_SolarSensorDecrease", 0, &HKJoyMapping[HK_SolarSensorDecrease], -1, true},
+    {"HKJoy_SolarSensorIncrease", 0, &HKJoyMapping[HK_SolarSensorIncrease], -1, true},
+    {"HKJoy_FrameStep",           0, &HKJoyMapping[HK_FrameStep],           -1, true},
+    {"HKJoy_PowerButton",         0, &HKJoyMapping[HK_PowerButton],         -1, true},
+    {"HKJoy_VolumeUp",            0, &HKJoyMapping[HK_VolumeUp],            -1, true},
+    {"HKJoy_VolumeDown",          0, &HKJoyMapping[HK_VolumeDown],          -1, true},
+
+    {"JoystickID", 0, &JoystickID, 0, true},
+
+    {"WindowWidth",  0, &WindowWidth,  256, true},
+    {"WindowHeight", 0, &WindowHeight, 384, true},
+    {"WindowMax",    1, &WindowMaximized, false, true},
+
+    {"ScreenRotation", 0, &ScreenRotation, 0, true},
+    {"ScreenGap",      0, &ScreenGap,      0, true},
+    {"ScreenLayout",   0, &ScreenLayout,   0, true},
+    {"ScreenSwap",     1, &ScreenSwap,     false, true},
+    {"ScreenSizing",   0, &ScreenSizing,   0, true},
+    {"IntegerScaling", 1, &IntegerScaling, false, true},
+    {"ScreenAspectTop",0, &ScreenAspectTop,0, true},
+    {"ScreenAspectBot",0, &ScreenAspectBot,0, true},
+    {"ScreenFilter",   1, &ScreenFilter,   true, true},
+
+    {"ScreenUseGL",         1, &ScreenUseGL,         false, false},
+    {"ScreenVSync",         1, &ScreenVSync,         false, false},
+    {"ScreenVSyncInterval", 0, &ScreenVSyncInterval, 1, false},
+
+    {"3DRenderer", 0, &_3DRenderer, 0, false},
+    {"Threaded3D", 1, &Threaded3D, true, false},
+
+    {"GL_ScaleFactor", 0, &GL_ScaleFactor, 1, false},
+    {"GL_BetterPolygons", 1, &GL_BetterPolygons, false, false},
+
+    {"LimitFPS", 1, &LimitFPS, true, false},
+    {"AudioSync", 1, &AudioSync, false},
+    {"ShowOSD", 1, &ShowOSD, true, false},
+
+    {"ConsoleType", 0, &ConsoleType, 0, false},
+    {"DirectBoot", 1, &DirectBoot, true, false},
+
+#ifdef JIT_ENABLED
+    {"JIT_Enable", 1, &JIT_Enable, false, false},
+    {"JIT_MaxBlockSize", 0, &JIT_MaxBlockSize, 32, false},
+    {"JIT_BranchOptimisations", 1, &JIT_BranchOptimisations, true, false},
+    {"JIT_LiteralOptimisations", 1, &JIT_LiteralOptimisations, true, false},
+    #ifdef __APPLE__
+        {"JIT_FastMemory", 1, &JIT_FastMemory, false, false},
+    #else
+        {"JIT_FastMemory", 1, &JIT_FastMemory, true, false},
+    #endif
+#endif
+
+    {"ExternalBIOSEnable", 1, &ExternalBIOSEnable, false, false},
+
+    {"BIOS9Path", 2, &BIOS9Path, (std::string)"", false},
+    {"BIOS7Path", 2, &BIOS7Path, (std::string)"", false},
+    {"FirmwarePath", 2, &FirmwarePath, (std::string)"", false},
+
+    {"DSiBIOS9Path", 2, &DSiBIOS9Path, (std::string)"", false},
+    {"DSiBIOS7Path", 2, &DSiBIOS7Path, (std::string)"", false},
+    {"DSiFirmwarePath", 2, &DSiFirmwarePath, (std::string)"", false},
+    {"DSiNANDPath", 2, &DSiNANDPath, (std::string)"", false},
+
+    {"DLDIEnable", 1, &DLDIEnable, false, false},
+    {"DLDISDPath", 2, &DLDISDPath, (std::string)"dldi.bin", false},
+    {"DLDISize", 0, &DLDISize, 0, false},
+    {"DLDIReadOnly", 1, &DLDIReadOnly, false, false},
+    {"DLDIFolderSync", 1, &DLDIFolderSync, false, false},
+    {"DLDIFolderPath", 2, &DLDIFolderPath, (std::string)"", false},
+
+    {"DSiSDEnable", 1, &DSiSDEnable, false, false},
+    {"DSiSDPath", 2, &DSiSDPath, (std::string)"dsisd.bin", false},
+    {"DSiSDSize", 0, &DSiSDSize, 0, false},
+    {"DSiSDReadOnly", 1, &DSiSDReadOnly, false, false},
+    {"DSiSDFolderSync", 1, &DSiSDFolderSync, false, false},
+    {"DSiSDFolderPath", 2, &DSiSDFolderPath, (std::string)"", false},
+
+    {"FirmwareOverrideSettings", 1, &FirmwareOverrideSettings, false, true},
+    {"FirmwareUsername", 2, &FirmwareUsername, (std::string)"melonDS", true},
+    {"FirmwareLanguage", 0, &FirmwareLanguage, 1, true},
+    {"FirmwareBirthdayMonth", 0, &FirmwareBirthdayMonth, 1, true},
+    {"FirmwareBirthdayDay", 0, &FirmwareBirthdayDay, 1, true},
+    {"FirmwareFavouriteColour", 0, &FirmwareFavouriteColour, 0, true},
+    {"FirmwareMessage", 2, &FirmwareMessage, (std::string)"", true},
+    {"FirmwareMAC", 2, &FirmwareMAC, (std::string)"", true},
+
+    {"MPAudioMode", 0, &MPAudioMode, 1, false},
+    {"MPRecvTimeout", 0, &MPRecvTimeout, 25, false},
+
+    {"LANDevice", 2, &LANDevice, (std::string)"", false},
+    {"DirectLAN", 1, &DirectLAN, false, false},
+
+    {"SavStaRelocSRAM", 1, &SavestateRelocSRAM, false, false},
+
+    {"AudioInterp", 0, &AudioInterp, 0, false},
+    {"AudioBitDepth", 0, &AudioBitDepth, 0, false},
+    {"AudioVolume", 0, &AudioVolume, 256, true},
+    {"DSiVolumeSync", 1, &DSiVolumeSync, false, true},
+    {"MicInputType", 0, &MicInputType, 1, false},
+    {"MicDevice", 2, &MicDevice, (std::string)"", false},
+    {"MicWavPath", 2, &MicWavPath, (std::string)"", false},
+
+    {"LastROMFolder", 2, &LastROMFolder, (std::string)"", true},
+    {"LastBIOSFolder", 2, &LastBIOSFolder, (std::string)"", true},
+
+    {"RecentROM_0", 2, &RecentROMList[0], (std::string)"", true},
+    {"RecentROM_1", 2, &RecentROMList[1], (std::string)"", true},
+    {"RecentROM_2", 2, &RecentROMList[2], (std::string)"", true},
+    {"RecentROM_3", 2, &RecentROMList[3], (std::string)"", true},
+    {"RecentROM_4", 2, &RecentROMList[4], (std::string)"", true},
+    {"RecentROM_5", 2, &RecentROMList[5], (std::string)"", true},
+    {"RecentROM_6", 2, &RecentROMList[6], (std::string)"", true},
+    {"RecentROM_7", 2, &RecentROMList[7], (std::string)"", true},
+    {"RecentROM_8", 2, &RecentROMList[8], (std::string)"", true},
+    {"RecentROM_9", 2, &RecentROMList[9], (std::string)"", true},
+
+    {"SaveFilePath", 2, &SaveFilePath, (std::string)"", true},
+    {"SavestatePath", 2, &SavestatePath, (std::string)"", true},
+    {"CheatFilePath", 2, &CheatFilePath, (std::string)"", true},
+
+    {"EnableCheats", 1, &EnableCheats, false, true},
+
+    {"MouseHide",        1, &MouseHide,        false, false},
+    {"MouseHideSeconds", 0, &MouseHideSeconds, 5, false},
+    {"PauseLostFocus",   1, &PauseLostFocus,   false, false},
+
+    {"DSBatteryLevelOkay",   1, &DSBatteryLevelOkay, true, true},
+    {"DSiBatteryLevel",    0, &DSiBatteryLevel, 0xF, true},
+    {"DSiBatteryCharging", 1, &DSiBatteryCharging, true, true},
+
+    {"DSiFullBIOSBoot", 1, &DSiFullBIOSBoot, false, true},
+
+    // TODO!!
+    // we need a more elegant way to deal with this
+    {"Camera0_InputType", 0, &Camera[0].InputType, 0, false},
+    {"Camera0_ImagePath", 2, &Camera[0].ImagePath, (std::string)"", false},
+    {"Camera0_CamDeviceName", 2, &Camera[0].CamDeviceName, (std::string)"", false},
+    {"Camera0_XFlip", 1, &Camera[0].XFlip, false, false},
+    {"Camera1_InputType", 0, &Camera[1].InputType, 0, false},
+    {"Camera1_ImagePath", 2, &Camera[1].ImagePath, (std::string)"", false},
+    {"Camera1_CamDeviceName", 2, &Camera[1].CamDeviceName, (std::string)"", false},
+    {"Camera1_XFlip", 1, &Camera[1].XFlip, false, false},
+
+    {"", -1, nullptr, 0, false}
+};
+
+
+void LoadFile(int inst)
+{
+    Platform::FileHandle* f;
+    if (inst > 0)
+    {
+        char name[100] = {0};
+        snprintf(name, 99, kUniqueConfigFile, inst+1);
+        f = Platform::OpenLocalFile(name, Platform::FileMode::ReadText);
+    }
+    else
+        f = Platform::OpenLocalFile(kConfigFile, Platform::FileMode::ReadText);
+
+    if (!f) return;
+
+    char linebuf[1024];
+    char entryname[32];
+    char entryval[1024];
+    while (!Platform::IsEndOfFile(f))
+    {
+        if (!Platform::FileReadLine(linebuf, 1024, f))
+            break;
+
+        int ret = sscanf(linebuf, "%31[A-Za-z_0-9]=%[^\t\r\n]", entryname, entryval);
+        entryname[31] = '\0';
+        if (ret < 2) continue;
+
+        for (ConfigEntry* entry = &ConfigFile[0]; entry->Value; entry++)
+        {
+            if (!strncmp(entry->Name, entryname, 32))
+            {
+                if ((inst > 0) && (!entry->InstanceUnique))
+                    break;
+
+                switch (entry->Type)
+                {
+                case 0: *(int*)entry->Value = strtol(entryval, NULL, 10); break;
+                case 1: *(bool*)entry->Value = strtol(entryval, NULL, 10) ? true:false; break;
+                case 2: *(std::string*)entry->Value = entryval; break;
+                }
+
+                break;
+            }
+        }
+    }
+
+    CloseFile(f);
+}
+
+void Load()
+{
+
+    for (ConfigEntry* entry = &ConfigFile[0]; entry->Value; entry++)
+    {
+        switch (entry->Type)
+        {
+        case 0: *(int*)entry->Value = std::get<int>(entry->Default); break;
+        case 1: *(bool*)entry->Value = std::get<bool>(entry->Default); break;
+        case 2: *(std::string*)entry->Value = std::get<std::string>(entry->Default); break;
+        }
+    }
+
+    LoadFile(0);
+
+    int inst = Platform::InstanceID();
+    if (inst > 0)
+        LoadFile(inst);
+}
+
+void Save()
+{
+    int inst = Platform::InstanceID();
+
+    Platform::FileHandle* f;
+    if (inst > 0)
+    {
+        char name[100] = {0};
+        snprintf(name, 99, kUniqueConfigFile, inst+1);
+        f = Platform::OpenLocalFile(name, Platform::FileMode::WriteText);
+    }
+    else
+        f = Platform::OpenLocalFile(kConfigFile, Platform::FileMode::WriteText);
+
+    if (!f) return;
+
+    for (ConfigEntry* entry = &ConfigFile[0]; entry->Value; entry++)
+    {
+        if ((inst > 0) && (!entry->InstanceUnique))
+            continue;
+
+        switch (entry->Type)
+        {
+        case 0: Platform::FileWriteFormatted(f, "%s=%d\r\n", entry->Name, *(int*)entry->Value); break;
+        case 1: Platform::FileWriteFormatted(f, "%s=%d\r\n", entry->Name, *(bool*)entry->Value ? 1:0); break;
+        case 2: Platform::FileWriteFormatted(f, "%s=%s\r\n", entry->Name, (*(std::string*)entry->Value).c_str()); break;
+        }
+    }
+
+    CloseFile(f);
+}
+
+}
diff --git a/src/frontend/qt_sdl/Config.h b/src/frontend/qt_sdl/Config.h
index 504c068..9f3f6e4 100644
--- a/src/frontend/qt_sdl/Config.h
+++ b/src/frontend/qt_sdl/Config.h
@@ -103,6 +103,7 @@ extern bool Threaded3D;
 
 extern int GL_ScaleFactor;
 extern bool GL_BetterPolygons;
+extern bool GL_HiresCoordinates;
 
 extern bool LimitFPS;
 extern bool AudioSync;
diff --git a/src/frontend/qt_sdl/OSD.cpp b/src/frontend/qt_sdl/OSD.cpp
index d3becc1..6842d5f 100644
--- a/src/frontend/qt_sdl/OSD.cpp
+++ b/src/frontend/qt_sdl/OSD.cpp
@@ -57,7 +57,7 @@ struct Item
 
 std::deque<Item> ItemQueue;
 
-GLuint Shader[3];
+GLuint Shader;
 GLint uScreenSize, uOSDPos, uOSDSize;
 GLfloat uScaleFactor;
 GLuint OSDVertexArray;
@@ -70,20 +70,19 @@ bool Init(bool openGL)
 {
     if (openGL)
     {
-        OpenGL::BuildShaderProgram(kScreenVS_OSD, kScreenFS_OSD, Shader, "OSDShader");
+        OpenGL::CompileVertexFragmentProgram(Shader,
+            kScreenVS_OSD, kScreenFS_OSD,
+            "OSDShader",
+            {{"vPosition", 0}},
+            {{"oColor", 0}});
 
-        GLuint pid = Shader[2];
-        glBindAttribLocation(pid, 0, "vPosition");
-        glBindFragDataLocation(pid, 0, "oColor");
+        glUseProgram(Shader);
+        glUniform1i(glGetUniformLocation(Shader, "OSDTex"), 0);
 
-        OpenGL::LinkShaderProgram(Shader);
-        glUseProgram(pid);
-        glUniform1i(glGetUniformLocation(pid, "OSDTex"), 0);
-
-        uScreenSize = glGetUniformLocation(pid, "uScreenSize");
-        uOSDPos = glGetUniformLocation(pid, "uOSDPos");
-        uOSDSize = glGetUniformLocation(pid, "uOSDSize");
-        uScaleFactor = glGetUniformLocation(pid, "uScaleFactor");
+        uScreenSize = glGetUniformLocation(Shader, "uScreenSize");
+        uOSDPos = glGetUniformLocation(Shader, "uOSDPos");
+        uOSDSize = glGetUniformLocation(Shader, "uOSDSize");
+        uScaleFactor = glGetUniformLocation(Shader, "uScaleFactor");
 
         float vertices[6*2] =
         {
@@ -425,7 +424,7 @@ void DrawGL(float w, float h)
 
     u32 y = kOSDMargin;
 
-    glUseProgram(Shader[2]);
+    glUseProgram(Shader);
 
     glUniform2f(uScreenSize, w, h);
     glUniform1f(uScaleFactor, mainWindow->devicePixelRatioF());
diff --git a/src/frontend/qt_sdl/VideoSettingsDialog.cpp b/src/frontend/qt_sdl/VideoSettingsDialog.cpp
index 95ec7d3..5ef10c5 100644
--- a/src/frontend/qt_sdl/VideoSettingsDialog.cpp
+++ b/src/frontend/qt_sdl/VideoSettingsDialog.cpp
@@ -23,6 +23,7 @@
 #include "types.h"
 #include "Platform.h"
 #include "Config.h"
+#include "GPU.h"
 
 #include "VideoSettingsDialog.h"
 #include "ui_VideoSettingsDialog.h"
@@ -30,11 +31,20 @@
 
 inline bool UsesGL()
 {
-    return (Config::ScreenUseGL != 0) || (Config::_3DRenderer != 0);
+    return (Config::ScreenUseGL != 0) || (Config::_3DRenderer != GPU::renderer3D_Software);
 }
 
 VideoSettingsDialog* VideoSettingsDialog::currentDlg = nullptr;
 
+void VideoSettingsDialog::setEnabled()
+{
+    bool softwareRenderer = Config::_3DRenderer == GPU::renderer3D_Software;
+    ui->cbGLDisplay->setEnabled(softwareRenderer);
+    ui->cbSoftwareThreaded->setEnabled(softwareRenderer);
+    ui->cbxGLResolution->setEnabled(!softwareRenderer);
+    ui->cbBetterPolygons->setEnabled(Config::_3DRenderer == GPU::renderer3D_OpenGL);
+    ui->cbxComputeHiResCoords->setEnabled(Config::_3DRenderer == GPU::renderer3D_OpenGLCompute);
+}
 
 VideoSettingsDialog::VideoSettingsDialog(QWidget* parent) : QDialog(parent), ui(new Ui::VideoSettingsDialog)
 {
@@ -48,10 +58,12 @@ VideoSettingsDialog::VideoSettingsDialog(QWidget* parent) : QDialog(parent), ui(
     oldSoftThreaded = Config::Threaded3D;
     oldGLScale = Config::GL_ScaleFactor;
     oldGLBetterPolygons = Config::GL_BetterPolygons;
+    oldHiresCoordinates = Config::GL_HiresCoordinates;
 
     grp3DRenderer = new QButtonGroup(this);
-    grp3DRenderer->addButton(ui->rb3DSoftware, 0);
-    grp3DRenderer->addButton(ui->rb3DOpenGL,   1);
+    grp3DRenderer->addButton(ui->rb3DSoftware, GPU::renderer3D_Software);
+    grp3DRenderer->addButton(ui->rb3DOpenGL,   GPU::renderer3D_OpenGL);
+    grp3DRenderer->addButton(ui->rb3DCompute,  GPU::renderer3D_OpenGLCompute);
 #if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
     connect(grp3DRenderer, SIGNAL(buttonClicked(int)), this, SLOT(onChange3DRenderer(int)));
 #else
@@ -75,25 +87,13 @@ VideoSettingsDialog::VideoSettingsDialog(QWidget* parent) : QDialog(parent), ui(
     ui->cbxGLResolution->setCurrentIndex(Config::GL_ScaleFactor-1);
 
     ui->cbBetterPolygons->setChecked(Config::GL_BetterPolygons != 0);
+    ui->cbxComputeHiResCoords->setChecked(Config::GL_HiresCoordinates != 0);
 
     if (!Config::ScreenVSync)
         ui->sbVSyncInterval->setEnabled(false);
     setVsyncControlEnable(UsesGL());
 
-    if (Config::_3DRenderer == 0)
-    {
-        ui->cbGLDisplay->setEnabled(true);
-        ui->cbSoftwareThreaded->setEnabled(true);
-        ui->cbxGLResolution->setEnabled(false);
-        ui->cbBetterPolygons->setEnabled(false);
-    }
-    else
-    {
-        ui->cbGLDisplay->setEnabled(false);
-        ui->cbSoftwareThreaded->setEnabled(false);
-        ui->cbxGLResolution->setEnabled(true);
-        ui->cbBetterPolygons->setEnabled(true);
-    }
+    setEnabled();
 }
 
 VideoSettingsDialog::~VideoSettingsDialog()
@@ -119,6 +119,7 @@ void VideoSettingsDialog::on_VideoSettingsDialog_rejected()
     Config::Threaded3D = oldSoftThreaded;
     Config::GL_ScaleFactor = oldGLScale;
     Config::GL_BetterPolygons = oldGLBetterPolygons;
+    Config::GL_HiresCoordinates = oldHiresCoordinates;
 
     emit updateVideoSettings(old_gl != UsesGL());
 
@@ -133,31 +134,18 @@ void VideoSettingsDialog::setVsyncControlEnable(bool hasOGL)
 
 void VideoSettingsDialog::onChange3DRenderer(int renderer)
 {
-    bool old_gl = (Config::ScreenUseGL != 0) || (Config::_3DRenderer != 0);
+    bool old_gl = UsesGL();
 
     Config::_3DRenderer = renderer;
 
-    if (renderer == 0)
-    {
-        ui->cbGLDisplay->setEnabled(true);
-        ui->cbSoftwareThreaded->setEnabled(true);
-        ui->cbxGLResolution->setEnabled(false);
-        ui->cbBetterPolygons->setEnabled(false);
-    }
-    else
-    {
-        ui->cbGLDisplay->setEnabled(false);
-        ui->cbSoftwareThreaded->setEnabled(false);
-        ui->cbxGLResolution->setEnabled(true);
-        ui->cbBetterPolygons->setEnabled(true);
-    }
+    setEnabled();
 
     emit updateVideoSettings(old_gl != UsesGL());
 }
 
 void VideoSettingsDialog::on_cbGLDisplay_stateChanged(int state)
 {
-    bool old_gl = (Config::ScreenUseGL != 0) || (Config::_3DRenderer != 0);
+    bool old_gl = UsesGL();
 
     Config::ScreenUseGL = (state != 0);
 
@@ -205,3 +193,10 @@ void VideoSettingsDialog::on_cbBetterPolygons_stateChanged(int state)
 
     emit updateVideoSettings(false);
 }
+
+void VideoSettingsDialog::on_cbxComputeHiResCoords_stateChanged(int state)
+{
+    Config::GL_HiresCoordinates = (state != 0);
+
+    emit updateVideoSettings(false);
+}
diff --git a/src/frontend/qt_sdl/VideoSettingsDialog.h b/src/frontend/qt_sdl/VideoSettingsDialog.h
index 7fee5bb..166a826 100644
--- a/src/frontend/qt_sdl/VideoSettingsDialog.h
+++ b/src/frontend/qt_sdl/VideoSettingsDialog.h
@@ -65,10 +65,12 @@ private slots:
 
     void on_cbxGLResolution_currentIndexChanged(int idx);
     void on_cbBetterPolygons_stateChanged(int state);
+    void on_cbxComputeHiResCoords_stateChanged(int state);
 
     void on_cbSoftwareThreaded_stateChanged(int state);
 private:
     void setVsyncControlEnable(bool hasOGL);
+    void setEnabled();
 
     Ui::VideoSettingsDialog* ui;
 
@@ -81,6 +83,7 @@ private:
     int oldSoftThreaded;
     int oldGLScale;
     int oldGLBetterPolygons;
+    int oldHiresCoordinates;
 };
 
 #endif // VIDEOSETTINGSDIALOG_H
diff --git a/src/frontend/qt_sdl/VideoSettingsDialog.ui b/src/frontend/qt_sdl/VideoSettingsDialog.ui
index 11cfe3d..ff9baf8 100644
--- a/src/frontend/qt_sdl/VideoSettingsDialog.ui
+++ b/src/frontend/qt_sdl/VideoSettingsDialog.ui
@@ -6,7 +6,7 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>408</width>
+    <width>427</width>
     <height>262</height>
    </rect>
   </property>
@@ -24,7 +24,7 @@
     <enum>QLayout::SetFixedSize</enum>
    </property>
    <property name="horizontalSpacing">
-    <number>-1</number>
+    <number>6</number>
    </property>
    <item row="1" column="1">
     <widget class="QGroupBox" name="groupBox_3">
@@ -39,6 +39,16 @@
         </property>
        </widget>
       </item>
+      <item row="2" column="0">
+       <widget class="QCheckBox" name="cbBetterPolygons">
+        <property name="whatsThis">
+         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Enabling this may help reduce distortion on quads and more complex polygons, but may also reduce performance.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+        </property>
+        <property name="text">
+         <string>Improved polygon splitting</string>
+        </property>
+       </widget>
+      </item>
       <item row="1" column="0">
        <widget class="QComboBox" name="cbxGLResolution">
         <property name="whatsThis">
@@ -46,13 +56,10 @@
         </property>
        </widget>
       </item>
-      <item row="2" column="0">
-       <widget class="QCheckBox" name="cbBetterPolygons">
-        <property name="whatsThis">
-         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Enabling this may help reduce distortion on quads and more complex polygons, but may also reduce performance.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-        </property>
+      <item row="3" column="0">
+       <widget class="QCheckBox" name="cbxComputeHiResCoords">
         <property name="text">
-         <string>Improved polygon splitting</string>
+         <string>Use high resolution coordinates</string>
         </property>
        </widget>
       </item>
@@ -94,23 +101,7 @@
       <string>Display settings</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
-      <item row="6" column="0">
-       <widget class="QLabel" name="label_2">
-        <property name="sizePolicy">
-         <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-          <horstretch>0</horstretch>
-          <verstretch>0</verstretch>
-         </sizepolicy>
-        </property>
-        <property name="whatsThis">
-         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;The interval at which to synchronize to the monitor's refresh rate. Set to 1 for a 60Hz monitor, 2 for 120Hz, ...&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-        </property>
-        <property name="text">
-         <string>VSync interval:</string>
-        </property>
-       </widget>
-      </item>
-      <item row="6" column="1">
+      <item row="7" column="1">
        <widget class="QSpinBox" name="sbVSyncInterval">
         <property name="whatsThis">
          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;The interval at which to synchronize to the monitor's refresh rate. Set to 1 for a 60Hz monitor, 2 for 120Hz, ...&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
@@ -123,7 +114,7 @@
         </property>
        </widget>
       </item>
-      <item row="4" column="0" colspan="2">
+      <item row="5" column="0" colspan="2">
        <widget class="QCheckBox" name="cbGLDisplay">
         <property name="whatsThis">
          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Use OpenGL to draw the DS screens to the main window. May result in better frame pacing. Mandatory when using the OpenGL 3D renderer.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
@@ -133,17 +124,7 @@
         </property>
        </widget>
       </item>
-      <item row="5" column="0" colspan="2">
-       <widget class="QCheckBox" name="cbVSync">
-        <property name="whatsThis">
-         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;When using OpenGL, synchronize the video output to your monitor's refresh rate.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-        </property>
-        <property name="text">
-         <string>VSync</string>
-        </property>
-       </widget>
-      </item>
-      <item row="3" column="0" colspan="2">
+      <item row="4" column="0" colspan="2">
        <spacer name="verticalSpacer">
         <property name="orientation">
          <enum>Qt::Vertical</enum>
@@ -159,13 +140,39 @@
         </property>
        </spacer>
       </item>
+      <item row="6" column="0" colspan="2">
+       <widget class="QCheckBox" name="cbVSync">
+        <property name="whatsThis">
+         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;When using OpenGL, synchronize the video output to your monitor's refresh rate.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+        </property>
+        <property name="text">
+         <string>VSync</string>
+        </property>
+       </widget>
+      </item>
+      <item row="7" column="0">
+       <widget class="QLabel" name="label_2">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="whatsThis">
+         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;The interval at which to synchronize to the monitor's refresh rate. Set to 1 for a 60Hz monitor, 2 for 120Hz, ...&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+        </property>
+        <property name="text">
+         <string>VSync interval:</string>
+        </property>
+       </widget>
+      </item>
       <item row="2" column="0" colspan="2">
        <widget class="QRadioButton" name="rb3DOpenGL">
         <property name="whatsThis">
          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;The OpenGL renderer may be faster than software and supports graphical enhancements, but is more prone to glitches.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
         </property>
         <property name="text">
-         <string>OpenGL</string>
+         <string>OpenGL (Classic)</string>
         </property>
        </widget>
       </item>
@@ -186,6 +193,13 @@
         </property>
        </widget>
       </item>
+      <item row="3" column="0">
+       <widget class="QRadioButton" name="rb3DCompute">
+        <property name="text">
+         <string>OpenGL (Compute shader)</string>
+        </property>
+       </widget>
+      </item>
      </layout>
     </widget>
    </item>
diff --git a/src/frontend/qt_sdl/main.cpp b/src/frontend/qt_sdl/main.cpp
index 7f0c0ef..a94af1e 100644
--- a/src/frontend/qt_sdl/main.cpp
+++ b/src/frontend/qt_sdl/main.cpp
@@ -228,19 +228,17 @@ void EmuThread::initOpenGL()
     oglContext = windowctx;
     oglContext->MakeCurrent();
 
-    OpenGL::BuildShaderProgram(kScreenVS, kScreenFS, screenShaderProgram, "ScreenShader");
-    GLuint pid = screenShaderProgram[2];
-    glBindAttribLocation(pid, 0, "vPosition");
-    glBindAttribLocation(pid, 1, "vTexcoord");
-    glBindFragDataLocation(pid, 0, "oColor");
+    OpenGL::CompileVertexFragmentProgram(screenShaderProgram,
+        kScreenVS, kScreenFS,
+        "ScreenShader",
+        {{"vPosition", 0}, {"vTexcoord", 1}},
+        {{"oColor", 0}});
 
-    OpenGL::LinkShaderProgram(screenShaderProgram);
+    glUseProgram(screenShaderProgram);
+    glUniform1i(glGetUniformLocation(screenShaderProgram, "ScreenTex"), 0);
 
-    glUseProgram(pid);
-    glUniform1i(glGetUniformLocation(pid, "ScreenTex"), 0);
-
-    screenShaderScreenSizeULoc = glGetUniformLocation(pid, "uScreenSize");
-    screenShaderTransformULoc = glGetUniformLocation(pid, "uTransform");
+    screenShaderScreenSizeULoc = glGetUniformLocation(screenShaderProgram, "uScreenSize");
+    screenShaderTransformULoc = glGetUniformLocation(screenShaderProgram, "uTransform");
 
     // to prevent bleeding between both parts of the screen
     // with bilinear filtering enabled
@@ -300,7 +298,7 @@ void EmuThread::deinitOpenGL()
     glDeleteVertexArrays(1, &screenVertexArray);
     glDeleteBuffers(1, &screenVertexBuffer);
 
-    OpenGL::DeleteShaderProgram(screenShaderProgram);
+    glDeleteProgram(screenShaderProgram);
 
     OSD::DeInit();
 
@@ -325,6 +323,7 @@ void EmuThread::run()
     videoSettings.Soft_Threaded = Config::Threaded3D != 0;
     videoSettings.GL_ScaleFactor = Config::GL_ScaleFactor;
     videoSettings.GL_BetterPolygons = Config::GL_BetterPolygons;
+    videoSettings.GL_HiresCoordinates = Config::GL_HiresCoordinates;
 
     if (mainWindow->hasOGL)
     {
@@ -446,16 +445,17 @@ void EmuThread::run()
                 else
 #endif
                 {
-                    videoRenderer = 0;
+                    videoRenderer = GPU::renderer3D_Software;
                 }
 
-                videoRenderer = oglContext ? Config::_3DRenderer : 0;
+                videoRenderer = oglContext ? Config::_3DRenderer : GPU::renderer3D_Software;
 
                 videoSettingsDirty = false;
 
                 videoSettings.Soft_Threaded = Config::Threaded3D != 0;
                 videoSettings.GL_ScaleFactor = Config::GL_ScaleFactor;
                 videoSettings.GL_BetterPolygons = Config::GL_BetterPolygons;
+                videoSettings.GL_HiresCoordinates = Config::GL_HiresCoordinates;
 
                 GPU::SetRenderSettings(videoRenderer, videoSettings);
             }
@@ -746,7 +746,7 @@ void EmuThread::drawScreenGL()
 
     glViewport(0, 0, w, h);
 
-    glUseProgram(screenShaderProgram[2]);
+    glUseProgram(screenShaderProgram);
     glUniform2f(screenShaderScreenSizeULoc, w / factor, h / factor);
 
     int frontbuf = FrontBuffer;
@@ -1859,7 +1859,7 @@ void MainWindow::closeEvent(QCloseEvent* event)
 
 void MainWindow::createScreenPanel()
 {
-    hasOGL = (Config::ScreenUseGL != 0) || (Config::_3DRenderer != 0);
+    hasOGL = (Config::ScreenUseGL != 0) || (Config::_3DRenderer != GPU::renderer3D_Software);
 
     if (hasOGL)
     {
@@ -3272,13 +3272,7 @@ int main(int argc, char** argv)
 
 #define SANITIZE(var, min, max)  { var = std::clamp(var, min, max); }
     SANITIZE(Config::ConsoleType, 0, 1);
-    SANITIZE(Config::_3DRenderer,
-    0,
-    0 // Minimum, Software renderer
-    #ifdef OGLRENDERER_ENABLED
-    + 1 // OpenGL Renderer
-    #endif
-    );
+    SANITIZE(Config::_3DRenderer, (int)GPU::renderer3D_Software, (int)GPU::renderer3D_Max);
     SANITIZE(Config::ScreenVSyncInterval, 1, 20);
     SANITIZE(Config::GL_ScaleFactor, 1, 16);
     SANITIZE(Config::AudioInterp, 0, 3);
diff --git a/src/frontend/qt_sdl/main.cpp.orig b/src/frontend/qt_sdl/main.cpp.orig
new file mode 100644
index 0000000..7f0c0ef
--- /dev/null
+++ b/src/frontend/qt_sdl/main.cpp.orig
@@ -0,0 +1,3373 @@
+/*
+    Copyright 2016-2022 melonDS team
+
+    This file is part of melonDS.
+
+    melonDS is free software: you can redistribute it and/or modify it under
+    the terms of the GNU General Public License as published by the Free
+    Software Foundation, either version 3 of the License, or (at your option)
+    any later version.
+
+    melonDS is distributed in the hope that it will be useful, but WITHOUT ANY
+    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+    FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with melonDS. If not, see http://www.gnu.org/licenses/.
+*/
+
+#include <stdlib.h>
+#include <time.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <optional>
+#include <vector>
+#include <string>
+#include <algorithm>
+
+#include <QProcess>
+#include <QApplication>
+#include <QMessageBox>
+#include <QMenuBar>
+#include <QMimeDatabase>
+#include <QFileDialog>
+#include <QInputDialog>
+#include <QPaintEvent>
+#include <QPainter>
+#include <QKeyEvent>
+#include <QMimeData>
+#include <QVector>
+#include <QCommandLineParser>
+#ifndef _WIN32
+#include <QGuiApplication>
+#include <QSocketNotifier>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <signal.h>
+#ifndef APPLE
+#include <qpa/qplatformnativeinterface.h>
+#endif
+#endif
+
+#include <SDL2/SDL.h>
+
+#include "OpenGLSupport.h"
+#include "duckstation/gl/context.h"
+
+#include "main.h"
+#include "Input.h"
+#include "CheatsDialog.h"
+#include "EmuSettingsDialog.h"
+#include "InputConfig/InputConfigDialog.h"
+#include "VideoSettingsDialog.h"
+#include "CameraSettingsDialog.h"
+#include "AudioSettingsDialog.h"
+#include "FirmwareSettingsDialog.h"
+#include "PathSettingsDialog.h"
+#include "MPSettingsDialog.h"
+#include "WifiSettingsDialog.h"
+#include "InterfaceSettingsDialog.h"
+#include "ROMInfoDialog.h"
+#include "RAMInfoDialog.h"
+#include "TitleManagerDialog.h"
+#include "PowerManagement/PowerManagementDialog.h"
+#include "AudioInOut.h"
+
+#include "types.h"
+#include "version.h"
+
+#include "FrontendUtil.h"
+#include "OSD.h"
+
+#include "NDS.h"
+#include "NDSCart.h"
+#include "GBACart.h"
+#include "GPU.h"
+#include "SPU.h"
+#include "Wifi.h"
+#include "Platform.h"
+#include "LocalMP.h"
+#include "Config.h"
+#include "DSi_I2C.h"
+
+#include "Savestate.h"
+
+#include "main_shaders.h"
+
+#include "ROMManager.h"
+#include "ArchiveUtil.h"
+#include "CameraManager.h"
+
+#include "CLI.h"
+
+// TODO: uniform variable spelling
+
+const QString NdsRomMimeType = "application/x-nintendo-ds-rom";
+const QStringList NdsRomExtensions { ".nds", ".srl", ".dsi", ".ids" };
+
+const QString GbaRomMimeType = "application/x-gba-rom";
+const QStringList GbaRomExtensions { ".gba", ".agb" };
+
+// This list of supported archive formats is based on libarchive(3) version 3.6.2 (2022-12-09).
+const QStringList ArchiveMimeTypes
+{
+#ifdef ARCHIVE_SUPPORT_ENABLED
+    "application/zip",
+    "application/x-7z-compressed",
+    "application/vnd.rar", // *.rar
+    "application/x-tar",
+
+    "application/x-compressed-tar", // *.tar.gz
+    "application/x-xz-compressed-tar",
+    "application/x-bzip-compressed-tar",
+    "application/x-lz4-compressed-tar",
+    "application/x-zstd-compressed-tar",
+
+    "application/x-tarz", // *.tar.Z
+    "application/x-lzip-compressed-tar",
+    "application/x-lzma-compressed-tar",
+    "application/x-lrzip-compressed-tar",
+    "application/x-tzo", // *.tar.lzo
+#endif
+};
+
+const QStringList ArchiveExtensions
+{
+#ifdef ARCHIVE_SUPPORT_ENABLED
+    ".zip", ".7z", ".rar", ".tar",
+
+    ".tar.gz", ".tgz",
+    ".tar.xz", ".txz",
+    ".tar.bz2", ".tbz2",
+    ".tar.lz4", ".tlz4",
+    ".tar.zst", ".tzst",
+
+    ".tar.Z", ".taz",
+    ".tar.lz",
+    ".tar.lzma", ".tlz",
+    ".tar.lrz", ".tlrz",
+    ".tar.lzo", ".tzo"
+#endif
+};
+
+
+bool RunningSomething;
+
+MainWindow* mainWindow;
+EmuThread* emuThread;
+
+int autoScreenSizing = 0;
+
+int videoRenderer;
+GPU::RenderSettings videoSettings;
+bool videoSettingsDirty;
+
+CameraManager* camManager[2];
+bool camStarted[2];
+
+const struct { int id; float ratio; const char* label; } aspectRatios[] =
+{
+    { 0, 1,                       "4:3 (native)" },
+    { 4, (5.f  / 3) / (4.f / 3), "5:3 (3DS)"},
+    { 1, (16.f / 9) / (4.f / 3),  "16:9" },
+    { 2, (21.f / 9) / (4.f / 3),  "21:9" },
+    { 3, 0,                       "window" }
+};
+constexpr int AspectRatiosNum = sizeof(aspectRatios) / sizeof(aspectRatios[0]);
+
+
+EmuThread::EmuThread(QObject* parent) : QThread(parent)
+{
+    EmuStatus = emuStatus_Exit;
+    EmuRunning = emuStatus_Paused;
+    EmuPauseStack = EmuPauseStackRunning;
+    RunningSomething = false;
+
+    connect(this, SIGNAL(windowUpdate()), mainWindow->panelWidget, SLOT(repaint()));
+    connect(this, SIGNAL(windowTitleChange(QString)), mainWindow, SLOT(onTitleUpdate(QString)));
+    connect(this, SIGNAL(windowEmuStart()), mainWindow, SLOT(onEmuStart()));
+    connect(this, SIGNAL(windowEmuStop()), mainWindow, SLOT(onEmuStop()));
+    connect(this, SIGNAL(windowEmuPause()), mainWindow->actPause, SLOT(trigger()));
+    connect(this, SIGNAL(windowEmuReset()), mainWindow->actReset, SLOT(trigger()));
+    connect(this, SIGNAL(windowEmuFrameStep()), mainWindow->actFrameStep, SLOT(trigger()));
+    connect(this, SIGNAL(windowLimitFPSChange()), mainWindow->actLimitFramerate, SLOT(trigger()));
+    connect(this, SIGNAL(screenLayoutChange()), mainWindow->panelWidget, SLOT(onScreenLayoutChanged()));
+    connect(this, SIGNAL(windowFullscreenToggle()), mainWindow, SLOT(onFullscreenToggled()));
+    connect(this, SIGNAL(swapScreensToggle()), mainWindow->actScreenSwap, SLOT(trigger()));
+    connect(this, SIGNAL(screenEmphasisToggle()), mainWindow, SLOT(onScreenEmphasisToggled()));
+
+    static_cast<ScreenPanelGL*>(mainWindow->panel)->transferLayout(this);
+}
+
+void EmuThread::updateScreenSettings(bool filter, const WindowInfo& windowInfo, int numScreens, int* screenKind, float* screenMatrix)
+{
+    screenSettingsLock.lock();
+
+    if (lastScreenWidth != windowInfo.surface_width || lastScreenHeight != windowInfo.surface_height)
+    {
+        if (oglContext)
+            oglContext->ResizeSurface(windowInfo.surface_width, windowInfo.surface_height);
+        lastScreenWidth = windowInfo.surface_width;
+        lastScreenHeight = windowInfo.surface_height;
+    }
+
+    this->filter = filter;
+    this->windowInfo = windowInfo;
+    this->numScreens = numScreens;
+    memcpy(this->screenKind, screenKind, sizeof(int)*numScreens);
+    memcpy(this->screenMatrix, screenMatrix, sizeof(float)*numScreens*6);
+
+    screenSettingsLock.unlock();
+}
+
+void EmuThread::initOpenGL()
+{
+    GL::Context* windowctx = mainWindow->getOGLContext();
+
+    oglContext = windowctx;
+    oglContext->MakeCurrent();
+
+    OpenGL::BuildShaderProgram(kScreenVS, kScreenFS, screenShaderProgram, "ScreenShader");
+    GLuint pid = screenShaderProgram[2];
+    glBindAttribLocation(pid, 0, "vPosition");
+    glBindAttribLocation(pid, 1, "vTexcoord");
+    glBindFragDataLocation(pid, 0, "oColor");
+
+    OpenGL::LinkShaderProgram(screenShaderProgram);
+
+    glUseProgram(pid);
+    glUniform1i(glGetUniformLocation(pid, "ScreenTex"), 0);
+
+    screenShaderScreenSizeULoc = glGetUniformLocation(pid, "uScreenSize");
+    screenShaderTransformULoc = glGetUniformLocation(pid, "uTransform");
+
+    // to prevent bleeding between both parts of the screen
+    // with bilinear filtering enabled
+    const int paddedHeight = 192*2+2;
+    const float padPixels = 1.f / paddedHeight;
+
+    const float vertices[] =
+    {
+        0.f,   0.f,    0.f, 0.f,
+        0.f,   192.f,  0.f, 0.5f - padPixels,
+        256.f, 192.f,  1.f, 0.5f - padPixels,
+        0.f,   0.f,    0.f, 0.f,
+        256.f, 192.f,  1.f, 0.5f - padPixels,
+        256.f, 0.f,    1.f, 0.f,
+
+        0.f,   0.f,    0.f, 0.5f + padPixels,
+        0.f,   192.f,  0.f, 1.f,
+        256.f, 192.f,  1.f, 1.f,
+        0.f,   0.f,    0.f, 0.5f + padPixels,
+        256.f, 192.f,  1.f, 1.f,
+        256.f, 0.f,    1.f, 0.5f + padPixels
+    };
+
+    glGenBuffers(1, &screenVertexBuffer);
+    glBindBuffer(GL_ARRAY_BUFFER, screenVertexBuffer);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+
+    glGenVertexArrays(1, &screenVertexArray);
+    glBindVertexArray(screenVertexArray);
+    glEnableVertexAttribArray(0); // position
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4*4, (void*)(0));
+    glEnableVertexAttribArray(1); // texcoord
+    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4*4, (void*)(2*4));
+
+    glGenTextures(1, &screenTexture);
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, screenTexture);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, paddedHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+    // fill the padding
+    u8 zeroData[256*4*4];
+    memset(zeroData, 0, sizeof(zeroData));
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 192, 256, 2, GL_RGBA, GL_UNSIGNED_BYTE, zeroData);
+
+    OSD::Init(true);
+
+    oglContext->SetSwapInterval(Config::ScreenVSync ? Config::ScreenVSyncInterval : 0);
+}
+
+void EmuThread::deinitOpenGL()
+{
+    glDeleteTextures(1, &screenTexture);
+
+    glDeleteVertexArrays(1, &screenVertexArray);
+    glDeleteBuffers(1, &screenVertexBuffer);
+
+    OpenGL::DeleteShaderProgram(screenShaderProgram);
+
+    OSD::DeInit();
+
+    oglContext->DoneCurrent();
+    oglContext = nullptr;
+
+    lastScreenWidth = lastScreenHeight = -1;
+}
+
+void EmuThread::run()
+{
+    u32 mainScreenPos[3];
+
+    NDS::Init();
+
+    mainScreenPos[0] = 0;
+    mainScreenPos[1] = 0;
+    mainScreenPos[2] = 0;
+    autoScreenSizing = 0;
+
+    videoSettingsDirty = false;
+    videoSettings.Soft_Threaded = Config::Threaded3D != 0;
+    videoSettings.GL_ScaleFactor = Config::GL_ScaleFactor;
+    videoSettings.GL_BetterPolygons = Config::GL_BetterPolygons;
+
+    if (mainWindow->hasOGL)
+    {
+        initOpenGL();
+        videoRenderer = Config::_3DRenderer;
+    }
+    else
+    {
+        videoRenderer = 0;
+    }
+
+    GPU::InitRenderer(videoRenderer);
+    GPU::SetRenderSettings(videoRenderer, videoSettings);
+
+    SPU::SetInterpolation(Config::AudioInterp);
+
+    Input::Init();
+
+    u32 nframes = 0;
+    double perfCountsSec = 1.0 / SDL_GetPerformanceFrequency();
+    double lastTime = SDL_GetPerformanceCounter() * perfCountsSec;
+    double frameLimitError = 0.0;
+    double lastMeasureTime = lastTime;
+
+    u32 winUpdateCount = 0, winUpdateFreq = 1;
+    u8 dsiVolumeLevel = 0x1F;
+
+    char melontitle[100];
+
+    while (EmuRunning != emuStatus_Exit)
+    {
+        Input::Process();
+
+        if (Input::HotkeyPressed(HK_FastForwardToggle)) emit windowLimitFPSChange();
+
+        if (Input::HotkeyPressed(HK_Pause)) emit windowEmuPause();
+        if (Input::HotkeyPressed(HK_Reset)) emit windowEmuReset();
+        if (Input::HotkeyPressed(HK_FrameStep)) emit windowEmuFrameStep();
+
+        if (Input::HotkeyPressed(HK_FullscreenToggle)) emit windowFullscreenToggle();
+
+        if (Input::HotkeyPressed(HK_SwapScreens)) emit swapScreensToggle();
+        if (Input::HotkeyPressed(HK_SwapScreenEmphasis)) emit screenEmphasisToggle();
+
+        if (Input::HotkeyPressed(HK_SolarSensorDecrease))
+        {
+            int level = GBACart::SetInput(GBACart::Input_SolarSensorDown, true);
+            if (level != -1)
+            {
+                char msg[64];
+                sprintf(msg, "Solar sensor level: %d", level);
+                OSD::AddMessage(0, msg);
+            }
+        }
+        if (Input::HotkeyPressed(HK_SolarSensorIncrease))
+        {
+            int level = GBACart::SetInput(GBACart::Input_SolarSensorUp, true);
+            if (level != -1)
+            {
+                char msg[64];
+                sprintf(msg, "Solar sensor level: %d", level);
+                OSD::AddMessage(0, msg);
+            }
+        }
+
+        if (NDS::ConsoleType == 1)
+        {
+            double currentTime = SDL_GetPerformanceCounter() * perfCountsSec;
+
+            // Handle power button
+            if (Input::HotkeyDown(HK_PowerButton))
+            {
+                DSi_BPTWL::SetPowerButtonHeld(currentTime);
+            }
+            else if (Input::HotkeyReleased(HK_PowerButton))
+            {
+                DSi_BPTWL::SetPowerButtonReleased(currentTime);
+            }
+
+            // Handle volume buttons
+            if (Input::HotkeyDown(HK_VolumeUp))
+            {
+                DSi_BPTWL::SetVolumeSwitchHeld(DSi_BPTWL::volumeKey_Up);
+            }
+            else if (Input::HotkeyReleased(HK_VolumeUp))
+            {
+                DSi_BPTWL::SetVolumeSwitchReleased(DSi_BPTWL::volumeKey_Up);
+            }
+
+            if (Input::HotkeyDown(HK_VolumeDown))
+            {
+                DSi_BPTWL::SetVolumeSwitchHeld(DSi_BPTWL::volumeKey_Down);
+            }
+            else if (Input::HotkeyReleased(HK_VolumeDown))
+            {
+                DSi_BPTWL::SetVolumeSwitchReleased(DSi_BPTWL::volumeKey_Down);
+            }
+
+            DSi_BPTWL::ProcessVolumeSwitchInput(currentTime);
+        }
+
+        if (EmuRunning == emuStatus_Running || EmuRunning == emuStatus_FrameStep)
+        {
+            EmuStatus = emuStatus_Running;
+            if (EmuRunning == emuStatus_FrameStep) EmuRunning = emuStatus_Paused;
+
+            // update render settings if needed
+            // HACK:
+            // once the fast forward hotkey is released, we need to update vsync
+            // to the old setting again
+            if (videoSettingsDirty || Input::HotkeyReleased(HK_FastForward))
+            {
+                if (oglContext)
+                {
+                    oglContext->SetSwapInterval(Config::ScreenVSync ? Config::ScreenVSyncInterval : 0);
+                    videoRenderer = Config::_3DRenderer;
+                }
+#ifdef OGLRENDERER_ENABLED
+                else
+#endif
+                {
+                    videoRenderer = 0;
+                }
+
+                videoRenderer = oglContext ? Config::_3DRenderer : 0;
+
+                videoSettingsDirty = false;
+
+                videoSettings.Soft_Threaded = Config::Threaded3D != 0;
+                videoSettings.GL_ScaleFactor = Config::GL_ScaleFactor;
+                videoSettings.GL_BetterPolygons = Config::GL_BetterPolygons;
+
+                GPU::SetRenderSettings(videoRenderer, videoSettings);
+            }
+
+            // process input and hotkeys
+            NDS::SetKeyMask(Input::InputMask);
+
+            if (Input::HotkeyPressed(HK_Lid))
+            {
+                bool lid = !NDS::IsLidClosed();
+                NDS::SetLidClosed(lid);
+                OSD::AddMessage(0, lid ? "Lid closed" : "Lid opened");
+            }
+
+            // microphone input
+            AudioInOut::MicProcess();
+
+            // auto screen layout
+            if (Config::ScreenSizing == Frontend::screenSizing_Auto)
+            {
+                mainScreenPos[2] = mainScreenPos[1];
+                mainScreenPos[1] = mainScreenPos[0];
+                mainScreenPos[0] = NDS::PowerControl9 >> 15;
+
+                int guess;
+                if (mainScreenPos[0] == mainScreenPos[2] &&
+                    mainScreenPos[0] != mainScreenPos[1])
+                {
+                    // constant flickering, likely displaying 3D on both screens
+                    // TODO: when both screens are used for 2D only...???
+                    guess = Frontend::screenSizing_Even;
+                }
+                else
+                {
+                    if (mainScreenPos[0] == 1)
+                        guess = Frontend::screenSizing_EmphTop;
+                    else
+                        guess = Frontend::screenSizing_EmphBot;
+                }
+
+                if (guess != autoScreenSizing)
+                {
+                    autoScreenSizing = guess;
+                    emit screenLayoutChange();
+                }
+            }
+
+
+            // emulate
+            u32 nlines = NDS::RunFrame();
+
+            if (ROMManager::NDSSave)
+                ROMManager::NDSSave->CheckFlush();
+
+            if (ROMManager::GBASave)
+                ROMManager::GBASave->CheckFlush();
+
+            if (!oglContext)
+            {
+                FrontBufferLock.lock();
+                FrontBuffer = GPU::FrontBuffer;
+                FrontBufferLock.unlock();
+            }
+            else
+            {
+                FrontBuffer = GPU::FrontBuffer;
+                drawScreenGL();
+            }
+
+#ifdef MELONCAP
+            MelonCap::Update();
+#endif // MELONCAP
+
+            if (EmuRunning == emuStatus_Exit) break;
+
+            winUpdateCount++;
+            if (winUpdateCount >= winUpdateFreq && !oglContext)
+            {
+                emit windowUpdate();
+                winUpdateCount = 0;
+            }
+
+            bool fastforward = Input::HotkeyDown(HK_FastForward);
+
+            if (fastforward && oglContext && Config::ScreenVSync)
+            {
+                oglContext->SetSwapInterval(0);
+            }
+
+            if (Config::DSiVolumeSync && NDS::ConsoleType == 1)
+            {
+                u8 volumeLevel = DSi_BPTWL::GetVolumeLevel();
+                if (volumeLevel != dsiVolumeLevel)
+                {
+                    dsiVolumeLevel = volumeLevel;
+                    emit syncVolumeLevel();
+                }
+
+                Config::AudioVolume = volumeLevel * (256.0 / 31.0);
+            }
+
+            if (Config::AudioSync && !fastforward)
+                AudioInOut::AudioSync();
+
+            double frametimeStep = nlines / (60.0 * 263.0);
+
+            {
+                bool limitfps = Config::LimitFPS && !fastforward;
+
+                double practicalFramelimit = limitfps ? frametimeStep : 1.0 / 1000.0;
+
+                double curtime = SDL_GetPerformanceCounter() * perfCountsSec;
+
+                frameLimitError += practicalFramelimit - (curtime - lastTime);
+                if (frameLimitError < -practicalFramelimit)
+                    frameLimitError = -practicalFramelimit;
+                if (frameLimitError > practicalFramelimit)
+                    frameLimitError = practicalFramelimit;
+
+                if (round(frameLimitError * 1000.0) > 0.0)
+                {
+                    SDL_Delay(round(frameLimitError * 1000.0));
+                    double timeBeforeSleep = curtime;
+                    curtime = SDL_GetPerformanceCounter() * perfCountsSec;
+                    frameLimitError -= curtime - timeBeforeSleep;
+                }
+
+                lastTime = curtime;
+            }
+
+            nframes++;
+            if (nframes >= 30)
+            {
+                double time = SDL_GetPerformanceCounter() * perfCountsSec;
+                double dt = time - lastMeasureTime;
+                lastMeasureTime = time;
+
+                u32 fps = round(nframes / dt);
+                nframes = 0;
+
+                float fpstarget = 1.0/frametimeStep;
+
+                winUpdateFreq = fps / (u32)round(fpstarget);
+                if (winUpdateFreq < 1)
+                    winUpdateFreq = 1;
+
+                int inst = Platform::InstanceID();
+                if (inst == 0)
+                    sprintf(melontitle, "[%d/%.0f] melonDS " MELONDS_VERSION, fps, fpstarget);
+                else
+                    sprintf(melontitle, "[%d/%.0f] melonDS (%d)", fps, fpstarget, inst+1);
+                changeWindowTitle(melontitle);
+            }
+        }
+        else
+        {
+            // paused
+            nframes = 0;
+            lastTime = SDL_GetPerformanceCounter() * perfCountsSec;
+            lastMeasureTime = lastTime;
+
+            emit windowUpdate();
+
+            EmuStatus = EmuRunning;
+
+            int inst = Platform::InstanceID();
+            if (inst == 0)
+                sprintf(melontitle, "melonDS " MELONDS_VERSION);
+            else
+                sprintf(melontitle, "melonDS (%d)", inst+1);
+            changeWindowTitle(melontitle);
+
+            SDL_Delay(75);
+
+            if (oglContext)
+                drawScreenGL();
+
+            ContextRequestKind contextRequest = ContextRequest;
+            if (contextRequest == contextRequest_InitGL)
+            {
+                initOpenGL();
+                ContextRequest = contextRequest_None;
+            }
+            else if (contextRequest == contextRequest_DeInitGL)
+            {
+                deinitOpenGL();
+                ContextRequest = contextRequest_None;
+            }
+        }
+    }
+
+    EmuStatus = emuStatus_Exit;
+
+    GPU::DeInitRenderer();
+    NDS::DeInit();
+    //Platform::LAN_DeInit();
+}
+
+void EmuThread::changeWindowTitle(char* title)
+{
+    emit windowTitleChange(QString(title));
+}
+
+void EmuThread::emuRun()
+{
+    EmuRunning = emuStatus_Running;
+    EmuPauseStack = EmuPauseStackRunning;
+    RunningSomething = true;
+
+    // checkme
+    emit windowEmuStart();
+    AudioInOut::Enable();
+}
+
+void EmuThread::initContext()
+{
+    ContextRequest = contextRequest_InitGL;
+    while (ContextRequest != contextRequest_None);
+}
+
+void EmuThread::deinitContext()
+{
+    ContextRequest = contextRequest_DeInitGL;
+    while (ContextRequest != contextRequest_None);
+}
+
+void EmuThread::emuPause()
+{
+    EmuPauseStack++;
+    if (EmuPauseStack > EmuPauseStackPauseThreshold) return;
+
+    PrevEmuStatus = EmuRunning;
+    EmuRunning = emuStatus_Paused;
+    while (EmuStatus != emuStatus_Paused);
+
+    AudioInOut::Disable();
+}
+
+void EmuThread::emuUnpause()
+{
+    if (EmuPauseStack < EmuPauseStackPauseThreshold) return;
+
+    EmuPauseStack--;
+    if (EmuPauseStack >= EmuPauseStackPauseThreshold) return;
+
+    EmuRunning = PrevEmuStatus;
+
+    AudioInOut::Enable();
+}
+
+void EmuThread::emuStop()
+{
+    EmuRunning = emuStatus_Exit;
+    EmuPauseStack = EmuPauseStackRunning;
+
+    AudioInOut::Disable();
+}
+
+void EmuThread::emuFrameStep()
+{
+    if (EmuPauseStack < EmuPauseStackPauseThreshold) emit windowEmuPause();
+    EmuRunning = emuStatus_FrameStep;
+}
+
+bool EmuThread::emuIsRunning()
+{
+    return EmuRunning == emuStatus_Running;
+}
+
+bool EmuThread::emuIsActive()
+{
+    return (RunningSomething == 1);
+}
+
+void EmuThread::drawScreenGL()
+{
+    int w = windowInfo.surface_width;
+    int h = windowInfo.surface_height;
+    float factor = windowInfo.surface_scale;
+
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    glDisable(GL_DEPTH_TEST);
+    glDepthMask(false);
+    glDisable(GL_BLEND);
+    glDisable(GL_SCISSOR_TEST);
+    glDisable(GL_STENCIL_TEST);
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    glViewport(0, 0, w, h);
+
+    glUseProgram(screenShaderProgram[2]);
+    glUniform2f(screenShaderScreenSizeULoc, w / factor, h / factor);
+
+    int frontbuf = FrontBuffer;
+    glActiveTexture(GL_TEXTURE0);
+
+#ifdef OGLRENDERER_ENABLED
+    if (GPU::Renderer != 0)
+    {
+        // hardware-accelerated render
+        GPU::CurGLCompositor->BindOutputTexture(frontbuf);
+    }
+    else
+#endif
+    {
+        // regular render
+        glBindTexture(GL_TEXTURE_2D, screenTexture);
+
+        if (GPU::Framebuffer[frontbuf][0] && GPU::Framebuffer[frontbuf][1])
+        {
+            glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 256, 192, GL_RGBA,
+                            GL_UNSIGNED_BYTE, GPU::Framebuffer[frontbuf][0]);
+            glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 192+2, 256, 192, GL_RGBA,
+                            GL_UNSIGNED_BYTE, GPU::Framebuffer[frontbuf][1]);
+        }
+    }
+
+    screenSettingsLock.lock();
+
+    GLint filter = this->filter ? GL_LINEAR : GL_NEAREST;
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
+
+    glBindBuffer(GL_ARRAY_BUFFER, screenVertexBuffer);
+    glBindVertexArray(screenVertexArray);
+
+    for (int i = 0; i < numScreens; i++)
+    {
+        glUniformMatrix2x3fv(screenShaderTransformULoc, 1, GL_TRUE, screenMatrix[i]);
+        glDrawArrays(GL_TRIANGLES, screenKind[i] == 0 ? 0 : 2*3, 2*3);
+    }
+
+    screenSettingsLock.unlock();
+
+    OSD::Update();
+    OSD::DrawGL(w, h);
+
+    oglContext->SwapBuffers();
+}
+
+ScreenHandler::ScreenHandler(QWidget* widget)
+{
+    widget->setMouseTracking(true);
+    widget->setAttribute(Qt::WA_AcceptTouchEvents);
+    QTimer* mouseTimer = setupMouseTimer();
+    widget->connect(mouseTimer, &QTimer::timeout, [=] { if (Config::MouseHide) widget->setCursor(Qt::BlankCursor);});
+}
+
+ScreenHandler::~ScreenHandler()
+{
+    mouseTimer->stop();
+}
+
+void ScreenHandler::screenSetupLayout(int w, int h)
+{
+    int sizing = Config::ScreenSizing;
+    if (sizing == 3) sizing = autoScreenSizing;
+
+    float aspectTop, aspectBot;
+
+    for (auto ratio : aspectRatios)
+    {
+        if (ratio.id == Config::ScreenAspectTop)
+            aspectTop = ratio.ratio;
+        if (ratio.id == Config::ScreenAspectBot)
+            aspectBot = ratio.ratio;
+    }
+
+    if (aspectTop == 0)
+        aspectTop = ((float) w / h) / (4.f / 3.f);
+
+    if (aspectBot == 0)
+        aspectBot = ((float) w / h) / (4.f / 3.f);
+
+    Frontend::SetupScreenLayout(w, h,
+                                static_cast<Frontend::ScreenLayout>(Config::ScreenLayout),
+                                static_cast<Frontend::ScreenRotation>(Config::ScreenRotation),
+                                static_cast<Frontend::ScreenSizing>(sizing),
+                                Config::ScreenGap,
+                                Config::IntegerScaling != 0,
+                                Config::ScreenSwap != 0,
+                                aspectTop,
+                                aspectBot);
+
+    numScreens = Frontend::GetScreenTransforms(screenMatrix[0], screenKind);
+}
+
+QSize ScreenHandler::screenGetMinSize(int factor = 1)
+{
+    bool isHori = (Config::ScreenRotation == Frontend::screenRot_90Deg
+        || Config::ScreenRotation == Frontend::screenRot_270Deg);
+    int gap = Config::ScreenGap * factor;
+
+    int w = 256 * factor;
+    int h = 192 * factor;
+
+    if (Config::ScreenSizing == Frontend::screenSizing_TopOnly
+        || Config::ScreenSizing == Frontend::screenSizing_BotOnly)
+    {
+        return QSize(w, h);
+    }
+
+    if (Config::ScreenLayout == Frontend::screenLayout_Natural)
+    {
+        if (isHori)
+            return QSize(h+gap+h, w);
+        else
+            return QSize(w, h+gap+h);
+    }
+    else if (Config::ScreenLayout == Frontend::screenLayout_Vertical)
+    {
+        if (isHori)
+            return QSize(h, w+gap+w);
+        else
+            return QSize(w, h+gap+h);
+    }
+    else if (Config::ScreenLayout == Frontend::screenLayout_Horizontal)
+    {
+        if (isHori)
+            return QSize(h+gap+h, w);
+        else
+            return QSize(w+gap+w, h);
+    }
+    else // hybrid
+    {
+        if (isHori)
+            return QSize(h+gap+h, 3*w + (int)ceil((4*gap) / 3.0));
+        else
+            return QSize(3*w + (int)ceil((4*gap) / 3.0), h+gap+h);
+    }
+}
+
+void ScreenHandler::screenOnMousePress(QMouseEvent* event)
+{
+    event->accept();
+    if (event->button() != Qt::LeftButton) return;
+
+    int x = event->pos().x();
+    int y = event->pos().y();
+
+    if (Frontend::GetTouchCoords(x, y, false))
+    {
+        touching = true;
+        NDS::TouchScreen(x, y);
+    }
+}
+
+void ScreenHandler::screenOnMouseRelease(QMouseEvent* event)
+{
+    event->accept();
+    if (event->button() != Qt::LeftButton) return;
+
+    if (touching)
+    {
+        touching = false;
+        NDS::ReleaseScreen();
+    }
+}
+
+void ScreenHandler::screenOnMouseMove(QMouseEvent* event)
+{
+    event->accept();
+
+    showCursor();
+
+    if (!(event->buttons() & Qt::LeftButton)) return;
+    if (!touching) return;
+
+    int x = event->pos().x();
+    int y = event->pos().y();
+
+    if (Frontend::GetTouchCoords(x, y, true))
+        NDS::TouchScreen(x, y);
+}
+
+void ScreenHandler::screenHandleTablet(QTabletEvent* event)
+{
+    event->accept();
+
+    switch(event->type())
+    {
+    case QEvent::TabletPress:
+    case QEvent::TabletMove:
+        {
+            int x = event->x();
+            int y = event->y();
+
+            if (Frontend::GetTouchCoords(x, y, event->type()==QEvent::TabletMove))
+            {
+                touching = true;
+                NDS::TouchScreen(x, y);
+            }
+        }
+        break;
+    case QEvent::TabletRelease:
+        if (touching)
+        {
+            NDS::ReleaseScreen();
+            touching = false;
+        }
+        break;
+    default:
+        break;
+    }
+}
+
+void ScreenHandler::screenHandleTouch(QTouchEvent* event)
+{
+    event->accept();
+
+    switch(event->type())
+    {
+    case QEvent::TouchBegin:
+    case QEvent::TouchUpdate:
+        if (event->touchPoints().length() > 0)
+        {
+            QPointF lastPosition = event->touchPoints().first().lastPos();
+            int x = (int)lastPosition.x();
+            int y = (int)lastPosition.y();
+
+            if (Frontend::GetTouchCoords(x, y, event->type()==QEvent::TouchUpdate))
+            {
+                touching = true;
+                NDS::TouchScreen(x, y);
+            }
+        }
+        break;
+    case QEvent::TouchEnd:
+        if (touching)
+        {
+            NDS::ReleaseScreen();
+            touching = false;
+        }
+        break;
+    default:
+        break;
+    }
+}
+
+void ScreenHandler::showCursor()
+{
+    mainWindow->panelWidget->setCursor(Qt::ArrowCursor);
+    mouseTimer->start();
+}
+
+QTimer* ScreenHandler::setupMouseTimer()
+{
+    mouseTimer = new QTimer();
+    mouseTimer->setSingleShot(true);
+    mouseTimer->setInterval(Config::MouseHideSeconds*1000);
+    mouseTimer->start();
+
+    return mouseTimer;
+}
+
+ScreenPanelNative::ScreenPanelNative(QWidget* parent) : QWidget(parent), ScreenHandler(this)
+{
+    screen[0] = QImage(256, 192, QImage::Format_RGB32);
+    screen[1] = QImage(256, 192, QImage::Format_RGB32);
+
+    screenTrans[0].reset();
+    screenTrans[1].reset();
+
+    OSD::Init(false);
+}
+
+ScreenPanelNative::~ScreenPanelNative()
+{
+    OSD::DeInit();
+}
+
+void ScreenPanelNative::setupScreenLayout()
+{
+    int w = width();
+    int h = height();
+
+    screenSetupLayout(w, h);
+
+    for (int i = 0; i < numScreens; i++)
+    {
+        float* mtx = screenMatrix[i];
+        screenTrans[i].setMatrix(mtx[0], mtx[1], 0.f,
+                                mtx[2], mtx[3], 0.f,
+                                mtx[4], mtx[5], 1.f);
+    }
+}
+
+void ScreenPanelNative::paintEvent(QPaintEvent* event)
+{
+    QPainter painter(this);
+
+    // fill background
+    painter.fillRect(event->rect(), QColor::fromRgb(0, 0, 0));
+
+    if (emuThread->emuIsActive())
+    {
+        emuThread->FrontBufferLock.lock();
+        int frontbuf = emuThread->FrontBuffer;
+        if (!GPU::Framebuffer[frontbuf][0] || !GPU::Framebuffer[frontbuf][1])
+        {
+            emuThread->FrontBufferLock.unlock();
+            return;
+        }
+
+        memcpy(screen[0].scanLine(0), GPU::Framebuffer[frontbuf][0], 256 * 192 * 4);
+        memcpy(screen[1].scanLine(0), GPU::Framebuffer[frontbuf][1], 256 * 192 * 4);
+        emuThread->FrontBufferLock.unlock();
+
+        QRect screenrc(0, 0, 256, 192);
+
+        for (int i = 0; i < numScreens; i++)
+        {
+            painter.setTransform(screenTrans[i]);
+            painter.drawImage(screenrc, screen[screenKind[i]]);
+        }
+    }
+
+    OSD::Update();
+    OSD::DrawNative(painter);
+}
+
+void ScreenPanelNative::resizeEvent(QResizeEvent* event)
+{
+    setupScreenLayout();
+}
+
+void ScreenPanelNative::mousePressEvent(QMouseEvent* event)
+{
+    screenOnMousePress(event);
+}
+
+void ScreenPanelNative::mouseReleaseEvent(QMouseEvent* event)
+{
+    screenOnMouseRelease(event);
+}
+
+void ScreenPanelNative::mouseMoveEvent(QMouseEvent* event)
+{
+    screenOnMouseMove(event);
+}
+
+void ScreenPanelNative::tabletEvent(QTabletEvent* event)
+{
+    screenHandleTablet(event);
+}
+
+bool ScreenPanelNative::event(QEvent* event)
+{
+    if (event->type() == QEvent::TouchBegin
+        || event->type() == QEvent::TouchEnd
+        || event->type() == QEvent::TouchUpdate)
+    {
+        screenHandleTouch((QTouchEvent*)event);
+        return true;
+    }
+    return QWidget::event(event);
+}
+
+void ScreenPanelNative::onScreenLayoutChanged()
+{
+    setMinimumSize(screenGetMinSize());
+    setupScreenLayout();
+}
+
+
+ScreenPanelGL::ScreenPanelGL(QWidget* parent) : QWidget(parent), ScreenHandler(this)
+{
+    setAutoFillBackground(false);
+    setAttribute(Qt::WA_NativeWindow, true);
+    setAttribute(Qt::WA_NoSystemBackground, true);
+    setAttribute(Qt::WA_PaintOnScreen, true);
+    setAttribute(Qt::WA_KeyCompression, false);
+    setFocusPolicy(Qt::StrongFocus);
+    setMinimumSize(screenGetMinSize());
+}
+
+ScreenPanelGL::~ScreenPanelGL()
+{}
+
+bool ScreenPanelGL::createContext()
+{
+    std::optional<WindowInfo> windowInfo = getWindowInfo();
+    std::array<GL::Context::Version, 2> versionsToTry = {
+        GL::Context::Version{GL::Context::Profile::Core, 4, 3},
+        GL::Context::Version{GL::Context::Profile::Core, 3, 2}};
+    if (windowInfo.has_value())
+    {
+        glContext = GL::Context::Create(*getWindowInfo(), versionsToTry);
+        glContext->DoneCurrent();
+    }
+
+    return glContext != nullptr;
+}
+
+qreal ScreenPanelGL::devicePixelRatioFromScreen() const
+{
+    const QScreen* screen_for_ratio = window()->windowHandle()->screen();
+    if (!screen_for_ratio)
+        screen_for_ratio = QGuiApplication::primaryScreen();
+
+    return screen_for_ratio ? screen_for_ratio->devicePixelRatio() : static_cast<qreal>(1);
+}
+
+int ScreenPanelGL::scaledWindowWidth() const
+{
+  return std::max(static_cast<int>(std::ceil(static_cast<qreal>(width()) * devicePixelRatioFromScreen())), 1);
+}
+
+int ScreenPanelGL::scaledWindowHeight() const
+{
+  return std::max(static_cast<int>(std::ceil(static_cast<qreal>(height()) * devicePixelRatioFromScreen())), 1);
+}
+
+std::optional<WindowInfo> ScreenPanelGL::getWindowInfo()
+{
+    WindowInfo wi;
+
+    // Windows and Apple are easy here since there's no display connection.
+    #if defined(_WIN32)
+    wi.type = WindowInfo::Type::Win32;
+    wi.window_handle = reinterpret_cast<void*>(winId());
+    #elif defined(__APPLE__)
+    wi.type = WindowInfo::Type::MacOS;
+    wi.window_handle = reinterpret_cast<void*>(winId());
+    #else
+    QPlatformNativeInterface* pni = QGuiApplication::platformNativeInterface();
+    const QString platform_name = QGuiApplication::platformName();
+    if (platform_name == QStringLiteral("xcb"))
+    {
+        wi.type = WindowInfo::Type::X11;
+        wi.display_connection = pni->nativeResourceForWindow("display", windowHandle());
+        wi.window_handle = reinterpret_cast<void*>(winId());
+    }
+    else if (platform_name == QStringLiteral("wayland"))
+    {
+        wi.type = WindowInfo::Type::Wayland;
+        QWindow* handle = windowHandle();
+        if (handle == nullptr)
+            return std::nullopt;
+
+        wi.display_connection = pni->nativeResourceForWindow("display", handle);
+        wi.window_handle = pni->nativeResourceForWindow("surface", handle);
+    }
+    else
+    {
+        qCritical() << "Unknown PNI platform " << platform_name;
+        return std::nullopt;
+    }
+    #endif
+
+    wi.surface_width = static_cast<u32>(scaledWindowWidth());
+    wi.surface_height = static_cast<u32>(scaledWindowHeight());
+    wi.surface_scale = static_cast<float>(devicePixelRatioFromScreen());
+
+    return wi;
+}
+
+
+QPaintEngine* ScreenPanelGL::paintEngine() const
+{
+  return nullptr;
+}
+
+void ScreenPanelGL::setupScreenLayout()
+{
+    int w = width();
+    int h = height();
+
+    screenSetupLayout(w, h);
+    if (emuThread)
+        transferLayout(emuThread);
+}
+
+void ScreenPanelGL::resizeEvent(QResizeEvent* event)
+{
+    setupScreenLayout();
+
+    QWidget::resizeEvent(event);
+}
+
+void ScreenPanelGL::mousePressEvent(QMouseEvent* event)
+{
+    screenOnMousePress(event);
+}
+
+void ScreenPanelGL::mouseReleaseEvent(QMouseEvent* event)
+{
+    screenOnMouseRelease(event);
+}
+
+void ScreenPanelGL::mouseMoveEvent(QMouseEvent* event)
+{
+    screenOnMouseMove(event);
+}
+
+void ScreenPanelGL::tabletEvent(QTabletEvent* event)
+{
+    screenHandleTablet(event);
+}
+
+bool ScreenPanelGL::event(QEvent* event)
+{
+    if (event->type() == QEvent::TouchBegin
+        || event->type() == QEvent::TouchEnd
+        || event->type() == QEvent::TouchUpdate)
+    {
+        screenHandleTouch((QTouchEvent*)event);
+        return true;
+    }
+    return QWidget::event(event);
+}
+
+void ScreenPanelGL::transferLayout(EmuThread* thread)
+{
+    std::optional<WindowInfo> windowInfo = getWindowInfo();
+    if (windowInfo.has_value())
+        thread->updateScreenSettings(Config::ScreenFilter, *windowInfo, numScreens, screenKind, &screenMatrix[0][0]);
+}
+
+void ScreenPanelGL::onScreenLayoutChanged()
+{
+    setMinimumSize(screenGetMinSize());
+    setupScreenLayout();
+}
+
+
+static bool FileExtensionInList(const QString& filename, const QStringList& extensions, Qt::CaseSensitivity cs = Qt::CaseInsensitive)
+{
+    return std::any_of(extensions.cbegin(), extensions.cend(), [&](const auto& ext) {
+        return filename.endsWith(ext, cs);
+    });
+}
+
+static bool MimeTypeInList(const QMimeType& mimetype, const QStringList& superTypeNames)
+{
+    return std::any_of(superTypeNames.cbegin(), superTypeNames.cend(), [&](const auto& superTypeName) {
+        return mimetype.inherits(superTypeName);
+    });
+}
+
+
+static bool NdsRomByExtension(const QString& filename)
+{
+    return FileExtensionInList(filename, NdsRomExtensions);
+}
+
+static bool GbaRomByExtension(const QString& filename)
+{
+    return FileExtensionInList(filename, GbaRomExtensions);
+}
+
+static bool SupportedArchiveByExtension(const QString& filename)
+{
+    return FileExtensionInList(filename, ArchiveExtensions);
+}
+
+
+static bool NdsRomByMimetype(const QMimeType& mimetype)
+{
+    return mimetype.inherits(NdsRomMimeType);
+}
+
+static bool GbaRomByMimetype(const QMimeType& mimetype)
+{
+    return mimetype.inherits(GbaRomMimeType);
+}
+
+static bool SupportedArchiveByMimetype(const QMimeType& mimetype)
+{
+    return MimeTypeInList(mimetype, ArchiveMimeTypes);
+}
+
+static bool ZstdNdsRomByExtension(const QString& filename)
+{
+    return filename.endsWith(".zst", Qt::CaseInsensitive) &&
+        NdsRomByExtension(filename.left(filename.size() - 4));
+}
+
+static bool ZstdGbaRomByExtension(const QString& filename)
+{
+    return filename.endsWith(".zst", Qt::CaseInsensitive) &&
+        GbaRomByExtension(filename.left(filename.size() - 4));
+}
+
+static bool FileIsSupportedFiletype(const QString& filename, bool insideArchive = false)
+{
+    if (ZstdNdsRomByExtension(filename) || ZstdGbaRomByExtension(filename))
+        return true;
+
+    if (NdsRomByExtension(filename) || GbaRomByExtension(filename) || SupportedArchiveByExtension(filename))
+        return true;
+
+    const auto matchmode = insideArchive ? QMimeDatabase::MatchExtension : QMimeDatabase::MatchDefault;
+    const QMimeType mimetype = QMimeDatabase().mimeTypeForFile(filename, matchmode);
+    return NdsRomByMimetype(mimetype) || GbaRomByMimetype(mimetype) || SupportedArchiveByMimetype(mimetype);
+}
+
+
+#ifndef _WIN32
+static int signalFd[2];
+QSocketNotifier *signalSn;
+
+static void signalHandler(int)
+{
+    char a = 1;
+    write(signalFd[0], &a, sizeof(a));
+}
+#endif
+
+MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent)
+{
+#ifndef _WIN32
+    if (socketpair(AF_UNIX, SOCK_STREAM, 0, signalFd))
+    {
+       qFatal("Couldn't create socketpair");
+    }
+
+    signalSn = new QSocketNotifier(signalFd[1], QSocketNotifier::Read, this);
+    connect(signalSn, SIGNAL(activated(int)), this, SLOT(onQuit()));
+
+    struct sigaction sa;
+
+    sa.sa_handler = signalHandler;
+    sigemptyset(&sa.sa_mask);
+    sa.sa_flags = 0;
+    sa.sa_flags |= SA_RESTART;
+    sigaction(SIGINT, &sa, 0);
+#endif
+
+    oldW = Config::WindowWidth;
+    oldH = Config::WindowHeight;
+    oldMax = Config::WindowMaximized;
+
+    setWindowTitle("melonDS " MELONDS_VERSION);
+    setAttribute(Qt::WA_DeleteOnClose);
+    setAcceptDrops(true);
+    setFocusPolicy(Qt::ClickFocus);
+
+    int inst = Platform::InstanceID();
+
+    QMenuBar* menubar = new QMenuBar();
+    {
+        QMenu* menu = menubar->addMenu("File");
+
+        actOpenROM = menu->addAction("Open ROM...");
+        connect(actOpenROM, &QAction::triggered, this, &MainWindow::onOpenFile);
+        actOpenROM->setShortcut(QKeySequence(QKeySequence::StandardKey::Open));
+
+        /*actOpenROMArchive = menu->addAction("Open ROM inside archive...");
+        connect(actOpenROMArchive, &QAction::triggered, this, &MainWindow::onOpenFileArchive);
+        actOpenROMArchive->setShortcut(QKeySequence(Qt::Key_O | Qt::CTRL | Qt::SHIFT));*/
+
+        recentMenu = menu->addMenu("Open recent");
+        for (int i = 0; i < 10; ++i)
+        {
+            std::string item = Config::RecentROMList[i];
+            if (!item.empty())
+                recentFileList.push_back(QString::fromStdString(item));
+        }
+        updateRecentFilesMenu();
+
+        //actBootFirmware = menu->addAction("Launch DS menu");
+        actBootFirmware = menu->addAction("Boot firmware");
+        connect(actBootFirmware, &QAction::triggered, this, &MainWindow::onBootFirmware);
+
+        menu->addSeparator();
+
+        actCurrentCart = menu->addAction("DS slot: " + ROMManager::CartLabel());
+        actCurrentCart->setEnabled(false);
+
+        actInsertCart = menu->addAction("Insert cart...");
+        connect(actInsertCart, &QAction::triggered, this, &MainWindow::onInsertCart);
+
+        actEjectCart = menu->addAction("Eject cart");
+        connect(actEjectCart, &QAction::triggered, this, &MainWindow::onEjectCart);
+
+        menu->addSeparator();
+
+        actCurrentGBACart = menu->addAction("GBA slot: " + ROMManager::GBACartLabel());
+        actCurrentGBACart->setEnabled(false);
+
+        actInsertGBACart = menu->addAction("Insert ROM cart...");
+        connect(actInsertGBACart, &QAction::triggered, this, &MainWindow::onInsertGBACart);
+
+        {
+            QMenu* submenu = menu->addMenu("Insert add-on cart");
+
+            actInsertGBAAddon[0] = submenu->addAction("Memory expansion");
+            actInsertGBAAddon[0]->setData(QVariant(NDS::GBAAddon_RAMExpansion));
+            connect(actInsertGBAAddon[0], &QAction::triggered, this, &MainWindow::onInsertGBAAddon);
+        }
+
+        actEjectGBACart = menu->addAction("Eject cart");
+        connect(actEjectGBACart, &QAction::triggered, this, &MainWindow::onEjectGBACart);
+
+        menu->addSeparator();
+
+        actImportSavefile = menu->addAction("Import savefile");
+        connect(actImportSavefile, &QAction::triggered, this, &MainWindow::onImportSavefile);
+
+        menu->addSeparator();
+
+        {
+            QMenu* submenu = menu->addMenu("Save state");
+
+            for (int i = 1; i < 9; i++)
+            {
+                actSaveState[i] = submenu->addAction(QString("%1").arg(i));
+                actSaveState[i]->setShortcut(QKeySequence(Qt::ShiftModifier | (Qt::Key_F1+i-1)));
+                actSaveState[i]->setData(QVariant(i));
+                connect(actSaveState[i], &QAction::triggered, this, &MainWindow::onSaveState);
+            }
+
+            actSaveState[0] = submenu->addAction("File...");
+            actSaveState[0]->setShortcut(QKeySequence(Qt::ShiftModifier | Qt::Key_F9));
+            actSaveState[0]->setData(QVariant(0));
+            connect(actSaveState[0], &QAction::triggered, this, &MainWindow::onSaveState);
+        }
+        {
+            QMenu* submenu = menu->addMenu("Load state");
+
+            for (int i = 1; i < 9; i++)
+            {
+                actLoadState[i] = submenu->addAction(QString("%1").arg(i));
+                actLoadState[i]->setShortcut(QKeySequence(Qt::Key_F1+i-1));
+                actLoadState[i]->setData(QVariant(i));
+                connect(actLoadState[i], &QAction::triggered, this, &MainWindow::onLoadState);
+            }
+
+            actLoadState[0] = submenu->addAction("File...");
+            actLoadState[0]->setShortcut(QKeySequence(Qt::Key_F9));
+            actLoadState[0]->setData(QVariant(0));
+            connect(actLoadState[0], &QAction::triggered, this, &MainWindow::onLoadState);
+        }
+
+        actUndoStateLoad = menu->addAction("Undo state load");
+        actUndoStateLoad->setShortcut(QKeySequence(Qt::Key_F12));
+        connect(actUndoStateLoad, &QAction::triggered, this, &MainWindow::onUndoStateLoad);
+
+        menu->addSeparator();
+
+        actQuit = menu->addAction("Quit");
+        connect(actQuit, &QAction::triggered, this, &MainWindow::onQuit);
+        actQuit->setShortcut(QKeySequence(QKeySequence::StandardKey::Quit));
+    }
+    {
+        QMenu* menu = menubar->addMenu("System");
+
+        actPause = menu->addAction("Pause");
+        actPause->setCheckable(true);
+        connect(actPause, &QAction::triggered, this, &MainWindow::onPause);
+
+        actReset = menu->addAction("Reset");
+        connect(actReset, &QAction::triggered, this, &MainWindow::onReset);
+
+        actStop = menu->addAction("Stop");
+        connect(actStop, &QAction::triggered, this, &MainWindow::onStop);
+
+        actFrameStep = menu->addAction("Frame step");
+        connect(actFrameStep, &QAction::triggered, this, &MainWindow::onFrameStep);
+
+        menu->addSeparator();
+
+        actPowerManagement = menu->addAction("Power management");
+        connect(actPowerManagement, &QAction::triggered, this, &MainWindow::onOpenPowerManagement);
+
+        menu->addSeparator();
+
+        actEnableCheats = menu->addAction("Enable cheats");
+        actEnableCheats->setCheckable(true);
+        connect(actEnableCheats, &QAction::triggered, this, &MainWindow::onEnableCheats);
+
+        //if (inst == 0)
+        {
+            actSetupCheats = menu->addAction("Setup cheat codes");
+            actSetupCheats->setMenuRole(QAction::NoRole);
+            connect(actSetupCheats, &QAction::triggered, this, &MainWindow::onSetupCheats);
+
+            menu->addSeparator();
+            actROMInfo = menu->addAction("ROM info");
+            connect(actROMInfo, &QAction::triggered, this, &MainWindow::onROMInfo);
+
+            actRAMInfo = menu->addAction("RAM search");
+            connect(actRAMInfo, &QAction::triggered, this, &MainWindow::onRAMInfo);
+
+            actTitleManager = menu->addAction("Manage DSi titles");
+            connect(actTitleManager, &QAction::triggered, this, &MainWindow::onOpenTitleManager);
+        }
+
+        {
+            menu->addSeparator();
+            QMenu* submenu = menu->addMenu("Multiplayer");
+
+            actMPNewInstance = submenu->addAction("Launch new instance");
+            connect(actMPNewInstance, &QAction::triggered, this, &MainWindow::onMPNewInstance);
+        }
+    }
+    {
+        QMenu* menu = menubar->addMenu("Config");
+
+        actEmuSettings = menu->addAction("Emu settings");
+        connect(actEmuSettings, &QAction::triggered, this, &MainWindow::onOpenEmuSettings);
+
+#ifdef __APPLE__
+        actPreferences = menu->addAction("Preferences...");
+        connect(actPreferences, &QAction::triggered, this, &MainWindow::onOpenEmuSettings);
+        actPreferences->setMenuRole(QAction::PreferencesRole);
+#endif
+
+        actInputConfig = menu->addAction("Input and hotkeys");
+        connect(actInputConfig, &QAction::triggered, this, &MainWindow::onOpenInputConfig);
+
+        actVideoSettings = menu->addAction("Video settings");
+        connect(actVideoSettings, &QAction::triggered, this, &MainWindow::onOpenVideoSettings);
+
+        actCameraSettings = menu->addAction("Camera settings");
+        connect(actCameraSettings, &QAction::triggered, this, &MainWindow::onOpenCameraSettings);
+
+        actAudioSettings = menu->addAction("Audio settings");
+        connect(actAudioSettings, &QAction::triggered, this, &MainWindow::onOpenAudioSettings);
+
+        actMPSettings = menu->addAction("Multiplayer settings");
+        connect(actMPSettings, &QAction::triggered, this, &MainWindow::onOpenMPSettings);
+
+        actWifiSettings = menu->addAction("Wifi settings");
+        connect(actWifiSettings, &QAction::triggered, this, &MainWindow::onOpenWifiSettings);
+
+        actFirmwareSettings = menu->addAction("Firmware settings");
+        connect(actFirmwareSettings, &QAction::triggered, this, &MainWindow::onOpenFirmwareSettings);
+
+        actInterfaceSettings = menu->addAction("Interface settings");
+        connect(actInterfaceSettings, &QAction::triggered, this, &MainWindow::onOpenInterfaceSettings);
+
+        actPathSettings = menu->addAction("Path settings");
+        connect(actPathSettings, &QAction::triggered, this, &MainWindow::onOpenPathSettings);
+
+        {
+            QMenu* submenu = menu->addMenu("Savestate settings");
+
+            actSavestateSRAMReloc = submenu->addAction("Separate savefiles");
+            actSavestateSRAMReloc->setCheckable(true);
+            connect(actSavestateSRAMReloc, &QAction::triggered, this, &MainWindow::onChangeSavestateSRAMReloc);
+        }
+
+        menu->addSeparator();
+
+        {
+            QMenu* submenu = menu->addMenu("Screen size");
+
+            for (int i = 0; i < 4; i++)
+            {
+                int data = i+1;
+                actScreenSize[i] = submenu->addAction(QString("%1x").arg(data));
+                actScreenSize[i]->setData(QVariant(data));
+                connect(actScreenSize[i], &QAction::triggered, this, &MainWindow::onChangeScreenSize);
+            }
+        }
+        {
+            QMenu* submenu = menu->addMenu("Screen rotation");
+            grpScreenRotation = new QActionGroup(submenu);
+
+            for (int i = 0; i < Frontend::screenRot_MAX; i++)
+            {
+                int data = i*90;
+                actScreenRotation[i] = submenu->addAction(QString("%1°").arg(data));
+                actScreenRotation[i]->setActionGroup(grpScreenRotation);
+                actScreenRotation[i]->setData(QVariant(i));
+                actScreenRotation[i]->setCheckable(true);
+            }
+
+            connect(grpScreenRotation, &QActionGroup::triggered, this, &MainWindow::onChangeScreenRotation);
+        }
+        {
+            QMenu* submenu = menu->addMenu("Screen gap");
+            grpScreenGap = new QActionGroup(submenu);
+
+            const int screengap[] = {0, 1, 8, 64, 90, 128};
+
+            for (int i = 0; i < 6; i++)
+            {
+                int data = screengap[i];
+                actScreenGap[i] = submenu->addAction(QString("%1 px").arg(data));
+                actScreenGap[i]->setActionGroup(grpScreenGap);
+                actScreenGap[i]->setData(QVariant(data));
+                actScreenGap[i]->setCheckable(true);
+            }
+
+            connect(grpScreenGap, &QActionGroup::triggered, this, &MainWindow::onChangeScreenGap);
+        }
+        {
+            QMenu* submenu = menu->addMenu("Screen layout");
+            grpScreenLayout = new QActionGroup(submenu);
+
+            const char* screenlayout[] = {"Natural", "Vertical", "Horizontal", "Hybrid"};
+
+            for (int i = 0; i < Frontend::screenLayout_MAX; i++)
+            {
+                actScreenLayout[i] = submenu->addAction(QString(screenlayout[i]));
+                actScreenLayout[i]->setActionGroup(grpScreenLayout);
+                actScreenLayout[i]->setData(QVariant(i));
+                actScreenLayout[i]->setCheckable(true);
+            }
+
+            connect(grpScreenLayout, &QActionGroup::triggered, this, &MainWindow::onChangeScreenLayout);
+
+            submenu->addSeparator();
+
+            actScreenSwap = submenu->addAction("Swap screens");
+            actScreenSwap->setCheckable(true);
+            connect(actScreenSwap, &QAction::triggered, this, &MainWindow::onChangeScreenSwap);
+        }
+        {
+            QMenu* submenu = menu->addMenu("Screen sizing");
+            grpScreenSizing = new QActionGroup(submenu);
+
+            const char* screensizing[] = {"Even", "Emphasize top", "Emphasize bottom", "Auto", "Top only", "Bottom only"};
+
+            for (int i = 0; i < Frontend::screenSizing_MAX; i++)
+            {
+                actScreenSizing[i] = submenu->addAction(QString(screensizing[i]));
+                actScreenSizing[i]->setActionGroup(grpScreenSizing);
+                actScreenSizing[i]->setData(QVariant(i));
+                actScreenSizing[i]->setCheckable(true);
+            }
+
+            connect(grpScreenSizing, &QActionGroup::triggered, this, &MainWindow::onChangeScreenSizing);
+
+            submenu->addSeparator();
+
+            actIntegerScaling = submenu->addAction("Force integer scaling");
+            actIntegerScaling->setCheckable(true);
+            connect(actIntegerScaling, &QAction::triggered, this, &MainWindow::onChangeIntegerScaling);
+        }
+        {
+            QMenu* submenu = menu->addMenu("Aspect ratio");
+            grpScreenAspectTop = new QActionGroup(submenu);
+            grpScreenAspectBot = new QActionGroup(submenu);
+            actScreenAspectTop = new QAction*[AspectRatiosNum];
+            actScreenAspectBot = new QAction*[AspectRatiosNum];
+
+            for (int i = 0; i < 2; i++)
+            {
+                QActionGroup* group = grpScreenAspectTop;
+                QAction** actions = actScreenAspectTop;
+
+                if (i == 1)
+                {
+                    group = grpScreenAspectBot;
+                    submenu->addSeparator();
+                    actions = actScreenAspectBot;
+                }
+
+                for (int j = 0; j < AspectRatiosNum; j++)
+                {
+                    auto ratio = aspectRatios[j];
+                    QString label = QString("%1 %2").arg(i ? "Bottom" : "Top", ratio.label);
+                    actions[j] = submenu->addAction(label);
+                    actions[j]->setActionGroup(group);
+                    actions[j]->setData(QVariant(ratio.id));
+                    actions[j]->setCheckable(true);
+                }
+
+                connect(group, &QActionGroup::triggered, this, &MainWindow::onChangeScreenAspect);
+            }
+        }
+
+        actScreenFiltering = menu->addAction("Screen filtering");
+        actScreenFiltering->setCheckable(true);
+        connect(actScreenFiltering, &QAction::triggered, this, &MainWindow::onChangeScreenFiltering);
+
+        actShowOSD = menu->addAction("Show OSD");
+        actShowOSD->setCheckable(true);
+        connect(actShowOSD, &QAction::triggered, this, &MainWindow::onChangeShowOSD);
+
+        menu->addSeparator();
+
+        actLimitFramerate = menu->addAction("Limit framerate");
+        actLimitFramerate->setCheckable(true);
+        connect(actLimitFramerate, &QAction::triggered, this, &MainWindow::onChangeLimitFramerate);
+
+        actAudioSync = menu->addAction("Audio sync");
+        actAudioSync->setCheckable(true);
+        connect(actAudioSync, &QAction::triggered, this, &MainWindow::onChangeAudioSync);
+    }
+    setMenuBar(menubar);
+
+    resize(Config::WindowWidth, Config::WindowHeight);
+
+    if (Config::FirmwareUsername == "Arisotura")
+        actMPNewInstance->setText("Fart");
+
+#ifdef Q_OS_MAC
+    QPoint screenCenter = screen()->availableGeometry().center();
+    QRect frameGeo = frameGeometry();
+    frameGeo.moveCenter(screenCenter);
+    move(frameGeo.topLeft());
+#endif
+
+    if (oldMax)
+        showMaximized();
+    else
+        show();
+
+    createScreenPanel();
+
+    actEjectCart->setEnabled(false);
+    actEjectGBACart->setEnabled(false);
+
+    if (Config::ConsoleType == 1)
+    {
+        actInsertGBACart->setEnabled(false);
+        for (int i = 0; i < 1; i++)
+            actInsertGBAAddon[i]->setEnabled(false);
+    }
+
+    for (int i = 0; i < 9; i++)
+    {
+        actSaveState[i]->setEnabled(false);
+        actLoadState[i]->setEnabled(false);
+    }
+    actUndoStateLoad->setEnabled(false);
+    actImportSavefile->setEnabled(false);
+
+    actPause->setEnabled(false);
+    actReset->setEnabled(false);
+    actStop->setEnabled(false);
+    actFrameStep->setEnabled(false);
+
+    actPowerManagement->setEnabled(false);
+
+    actSetupCheats->setEnabled(false);
+    actTitleManager->setEnabled(!Config::DSiNANDPath.empty());
+
+    actEnableCheats->setChecked(Config::EnableCheats);
+
+    actROMInfo->setEnabled(false);
+    actRAMInfo->setEnabled(false);
+
+    actSavestateSRAMReloc->setChecked(Config::SavestateRelocSRAM);
+
+    actScreenRotation[Config::ScreenRotation]->setChecked(true);
+
+    for (int i = 0; i < 6; i++)
+    {
+        if (actScreenGap[i]->data().toInt() == Config::ScreenGap)
+        {
+            actScreenGap[i]->setChecked(true);
+            break;
+        }
+    }
+
+    actScreenLayout[Config::ScreenLayout]->setChecked(true);
+    actScreenSizing[Config::ScreenSizing]->setChecked(true);
+    actIntegerScaling->setChecked(Config::IntegerScaling);
+
+    actScreenSwap->setChecked(Config::ScreenSwap);
+
+    for (int i = 0; i < AspectRatiosNum; i++)
+    {
+        if (Config::ScreenAspectTop == aspectRatios[i].id)
+            actScreenAspectTop[i]->setChecked(true);
+        if (Config::ScreenAspectBot == aspectRatios[i].id)
+            actScreenAspectBot[i]->setChecked(true);
+    }
+
+    actScreenFiltering->setChecked(Config::ScreenFilter);
+    actShowOSD->setChecked(Config::ShowOSD);
+
+    actLimitFramerate->setChecked(Config::LimitFPS);
+    actAudioSync->setChecked(Config::AudioSync);
+
+    if (inst > 0)
+    {
+        actEmuSettings->setEnabled(false);
+        actVideoSettings->setEnabled(false);
+        actMPSettings->setEnabled(false);
+        actWifiSettings->setEnabled(false);
+        actInterfaceSettings->setEnabled(false);
+
+#ifdef __APPLE__
+        actPreferences->setEnabled(false);
+#endif // __APPLE__
+    }
+}
+
+MainWindow::~MainWindow()
+{
+}
+
+void MainWindow::closeEvent(QCloseEvent* event)
+{
+    if (hasOGL)
+    {
+        // we intentionally don't unpause here
+        emuThread->emuPause();
+        emuThread->deinitContext();
+    }
+
+    QMainWindow::closeEvent(event);
+}
+
+void MainWindow::createScreenPanel()
+{
+    hasOGL = (Config::ScreenUseGL != 0) || (Config::_3DRenderer != 0);
+
+    if (hasOGL)
+    {
+        ScreenPanelGL* panelGL = new ScreenPanelGL(this);
+        panelGL->show();
+
+        panel = panelGL;
+        panelWidget = panelGL;
+
+        panelGL->createContext();
+    }
+
+    if (!hasOGL)
+    {
+        ScreenPanelNative* panelNative = new ScreenPanelNative(this);
+        panel = panelNative;
+        panelWidget = panelNative;
+        panelWidget->show();
+    }
+    setCentralWidget(panelWidget);
+
+    actScreenFiltering->setEnabled(hasOGL);
+
+    connect(this, SIGNAL(screenLayoutChange()), panelWidget, SLOT(onScreenLayoutChanged()));
+    emit screenLayoutChange();
+}
+
+GL::Context* MainWindow::getOGLContext()
+{
+    if (!hasOGL) return nullptr;
+
+    ScreenPanelGL* glpanel = static_cast<ScreenPanelGL*>(panel);
+    return glpanel->getContext();
+}
+
+void MainWindow::resizeEvent(QResizeEvent* event)
+{
+    int w = event->size().width();
+    int h = event->size().height();
+
+    if (!isFullScreen())
+    {
+        // this is ugly
+        // thing is, when maximizing the window, we first receive the resizeEvent
+        // with a new size matching the screen, then the changeEvent telling us that
+        // the maximized flag was updated
+        oldW = Config::WindowWidth;
+        oldH = Config::WindowHeight;
+        oldMax = isMaximized();
+
+        Config::WindowWidth = w;
+        Config::WindowHeight = h;
+    }
+}
+
+void MainWindow::changeEvent(QEvent* event)
+{
+    if (isMaximized() && !oldMax)
+    {
+        Config::WindowWidth = oldW;
+        Config::WindowHeight = oldH;
+    }
+
+    Config::WindowMaximized = isMaximized() ? 1:0;
+}
+
+void MainWindow::keyPressEvent(QKeyEvent* event)
+{
+    if (event->isAutoRepeat()) return;
+
+    // TODO!! REMOVE ME IN RELEASE BUILDS!!
+    //if (event->key() == Qt::Key_F11) NDS::debug(0);
+
+    Input::KeyPress(event);
+}
+
+void MainWindow::keyReleaseEvent(QKeyEvent* event)
+{
+    if (event->isAutoRepeat()) return;
+
+    Input::KeyRelease(event);
+}
+
+
+void MainWindow::dragEnterEvent(QDragEnterEvent* event)
+{
+    if (!event->mimeData()->hasUrls()) return;
+
+    QList<QUrl> urls = event->mimeData()->urls();
+    if (urls.count() > 1) return; // not handling more than one file at once
+
+    QString filename = urls.at(0).toLocalFile();
+
+    if (FileIsSupportedFiletype(filename))
+        event->acceptProposedAction();
+}
+
+void MainWindow::dropEvent(QDropEvent* event)
+{
+    if (!event->mimeData()->hasUrls()) return;
+
+    QList<QUrl> urls = event->mimeData()->urls();
+    if (urls.count() > 1) return; // not handling more than one file at once
+
+    emuThread->emuPause();
+
+    if (!verifySetup())
+    {
+        emuThread->emuUnpause();
+        return;
+    }
+
+    const QStringList file = splitArchivePath(urls.at(0).toLocalFile(), false);
+    if (file.isEmpty())
+    {
+        emuThread->emuUnpause();
+        return;
+    }
+
+    const QString filename = file.last();
+    const bool romInsideArchive = file.size() > 1;
+    const auto matchMode = romInsideArchive ? QMimeDatabase::MatchExtension : QMimeDatabase::MatchDefault;
+    const QMimeType mimetype = QMimeDatabase().mimeTypeForFile(filename, matchMode);
+
+    bool isNdsRom = NdsRomByExtension(filename) || NdsRomByMimetype(mimetype);
+    bool isGbaRom = GbaRomByExtension(filename) || GbaRomByMimetype(mimetype);
+    isNdsRom |= ZstdNdsRomByExtension(filename);
+    isGbaRom |= ZstdGbaRomByExtension(filename);
+
+    if (isNdsRom)
+    {
+        if (!ROMManager::LoadROM(file, true))
+        {
+            // TODO: better error reporting?
+            QMessageBox::critical(this, "melonDS", "Failed to load the DS ROM.");
+            emuThread->emuUnpause();
+            return;
+        }
+
+        const QString barredFilename = file.join('|');
+        recentFileList.removeAll(barredFilename);
+        recentFileList.prepend(barredFilename);
+        updateRecentFilesMenu();
+
+        NDS::Start();
+        emuThread->emuRun();
+
+        updateCartInserted(false);
+    }
+    else if (isGbaRom)
+    {
+        if (!ROMManager::LoadGBAROM(file))
+        {
+            // TODO: better error reporting?
+            QMessageBox::critical(this, "melonDS", "Failed to load the GBA ROM.");
+            emuThread->emuUnpause();
+            return;
+        }
+
+        emuThread->emuUnpause();
+
+        updateCartInserted(true);
+    }
+    else
+    {
+        QMessageBox::critical(this, "melonDS", "The file could not be recognized as a DS or GBA ROM.");
+        emuThread->emuUnpause();
+        return;
+    }
+}
+
+void MainWindow::focusInEvent(QFocusEvent* event)
+{
+    AudioInOut::AudioMute(mainWindow);
+}
+
+void MainWindow::focusOutEvent(QFocusEvent* event)
+{
+    AudioInOut::AudioMute(mainWindow);
+}
+
+void MainWindow::onAppStateChanged(Qt::ApplicationState state)
+{
+    if (state == Qt::ApplicationInactive)
+    {
+        if (Config::PauseLostFocus && emuThread->emuIsRunning())
+            emuThread->emuPause();
+    }
+    else if (state == Qt::ApplicationActive)
+    {
+        if (Config::PauseLostFocus && !pausedManually)
+            emuThread->emuUnpause();
+    }
+}
+
+bool MainWindow::verifySetup()
+{
+    QString res = ROMManager::VerifySetup();
+    if (!res.isEmpty())
+    {
+         QMessageBox::critical(this, "melonDS", res);
+         return false;
+    }
+
+    return true;
+}
+
+bool MainWindow::preloadROMs(QStringList file, QStringList gbafile, bool boot)
+{
+    if (!verifySetup())
+    {
+        return false;
+    }
+
+    bool gbaloaded = false;
+    if (!gbafile.isEmpty())
+    {
+        if (!ROMManager::LoadGBAROM(gbafile))
+        {
+            // TODO: better error reporting?
+            QMessageBox::critical(this, "melonDS", "Failed to load the GBA ROM.");
+            return false;
+        }
+
+        gbaloaded = true;
+    }
+
+    bool ndsloaded = false;
+    if (!file.isEmpty())
+    {
+        if (!ROMManager::LoadROM(file, true))
+        {
+            // TODO: better error reporting?
+            QMessageBox::critical(this, "melonDS", "Failed to load the ROM.");
+            return false;
+        }
+        recentFileList.removeAll(file.join("|"));
+        recentFileList.prepend(file.join("|"));
+        updateRecentFilesMenu();
+        ndsloaded = true;
+    }
+
+    if (boot)
+    {
+        if (ndsloaded)
+        {
+            NDS::Start();
+            emuThread->emuRun();
+        }
+        else
+        {
+            onBootFirmware();
+        }
+    }
+
+    updateCartInserted(false);
+
+    if (gbaloaded)
+    {
+        updateCartInserted(true);
+    }
+
+    return true;
+}
+
+QStringList MainWindow::splitArchivePath(const QString& filename, bool useMemberSyntax)
+{
+    if (filename.isEmpty()) return {};
+
+#ifdef ARCHIVE_SUPPORT_ENABLED
+    if (useMemberSyntax)
+    {
+        const QStringList filenameParts = filename.split('|');
+        if (filenameParts.size() > 2)
+        {
+            QMessageBox::warning(this, "melonDS", "This path contains too many '|'.");
+            return {};
+        }
+
+        if (filenameParts.size() == 2)
+        {
+            const QString archive = filenameParts.at(0);
+            if (!QFileInfo(archive).exists())
+            {
+                QMessageBox::warning(this, "melonDS", "This archive does not exist.");
+                return {};
+            }
+
+            const QString subfile = filenameParts.at(1);
+            if (!Archive::ListArchive(archive).contains(subfile))
+            {
+                QMessageBox::warning(this, "melonDS", "This archive does not contain the desired file.");
+                return {};
+            }
+
+            return filenameParts;
+        }
+    }
+#endif
+
+    if (!QFileInfo(filename).exists())
+    {
+        QMessageBox::warning(this, "melonDS", "This ROM file does not exist.");
+        return {};
+    }
+
+#ifdef ARCHIVE_SUPPORT_ENABLED
+    if (SupportedArchiveByExtension(filename)
+        || SupportedArchiveByMimetype(QMimeDatabase().mimeTypeForFile(filename)))
+    {
+        const QString subfile = pickFileFromArchive(filename);
+        if (subfile.isEmpty())
+            return {};
+
+        return { filename, subfile };
+    }
+#endif
+
+    return { filename };
+}
+
+QString MainWindow::pickFileFromArchive(QString archiveFileName)
+{
+    QVector<QString> archiveROMList = Archive::ListArchive(archiveFileName);
+
+    if (archiveROMList.size() <= 1)
+    {
+        if (!archiveROMList.isEmpty() && archiveROMList.at(0) == "OK")
+            QMessageBox::warning(this, "melonDS", "This archive is empty.");
+        else
+            QMessageBox::critical(this, "melonDS", "This archive could not be read. It may be corrupt or you don't have the permissions.");
+        return QString();
+    }
+
+    archiveROMList.removeFirst();
+
+    const auto notSupportedRom = [&](const auto& filename){
+        if (NdsRomByExtension(filename) || GbaRomByExtension(filename))
+            return false;
+        const QMimeType mimetype = QMimeDatabase().mimeTypeForFile(filename, QMimeDatabase::MatchExtension);
+        return !(NdsRomByMimetype(mimetype) || GbaRomByMimetype(mimetype));
+    };
+
+    archiveROMList.erase(std::remove_if(archiveROMList.begin(), archiveROMList.end(), notSupportedRom),
+                         archiveROMList.end());
+
+    if (archiveROMList.isEmpty())
+    {
+        QMessageBox::warning(this, "melonDS", "This archive does not contain any supported ROMs.");
+        return QString();
+    }
+
+    if (archiveROMList.size() == 1)
+        return archiveROMList.first();
+
+    bool ok;
+    const QString toLoad = QInputDialog::getItem(
+        this, "melonDS",
+        "This archive contains multiple files. Select which ROM you want to load.",
+        archiveROMList.toList(), 0, false, &ok
+    );
+
+    if (ok) return toLoad;
+
+    // User clicked on cancel
+
+    return QString();
+}
+
+QStringList MainWindow::pickROM(bool gba)
+{
+    const QString console = gba ? "GBA" : "DS";
+    const QStringList& romexts = gba ? GbaRomExtensions : NdsRomExtensions;
+
+    QString rawROMs = romexts.join(" *");
+    QString extraFilters = ";;" + console + " ROMs (*" + rawROMs;
+    QString allROMs = rawROMs;
+
+    QString zstdROMs = "*" + romexts.join(".zst *") + ".zst";
+    extraFilters += ");;Zstandard-compressed " + console + " ROMs (" + zstdROMs + ")";
+    allROMs += " " + zstdROMs;
+
+#ifdef ARCHIVE_SUPPORT_ENABLED
+    QString archives = "*" + ArchiveExtensions.join(" *");
+    extraFilters += ";;Archives (" + archives + ")";
+    allROMs += " " + archives;
+#endif
+    extraFilters += ";;All files (*.*)";
+
+    const QString filename = QFileDialog::getOpenFileName(
+        this, "Open " + console + " ROM",
+        QString::fromStdString(Config::LastROMFolder),
+        "All supported files (*" + allROMs + ")" + extraFilters
+    );
+
+    if (filename.isEmpty()) return {};
+
+    Config::LastROMFolder = QFileInfo(filename).dir().path().toStdString();
+    return splitArchivePath(filename, false);
+}
+
+void MainWindow::updateCartInserted(bool gba)
+{
+    bool inserted;
+    if (gba)
+    {
+        inserted = ROMManager::GBACartInserted() && (Config::ConsoleType == 0);
+        actCurrentGBACart->setText("GBA slot: " + ROMManager::GBACartLabel());
+        actEjectGBACart->setEnabled(inserted);
+    }
+    else
+    {
+        inserted = ROMManager::CartInserted();
+        actCurrentCart->setText("DS slot: " + ROMManager::CartLabel());
+        actEjectCart->setEnabled(inserted);
+        actImportSavefile->setEnabled(inserted);
+        actSetupCheats->setEnabled(inserted);
+        actROMInfo->setEnabled(inserted);
+        actRAMInfo->setEnabled(inserted);
+    }
+}
+
+void MainWindow::onOpenFile()
+{
+    emuThread->emuPause();
+
+    if (!verifySetup())
+    {
+        emuThread->emuUnpause();
+        return;
+    }
+
+    QStringList file = pickROM(false);
+    if (file.isEmpty())
+    {
+        emuThread->emuUnpause();
+        return;
+    }
+
+    if (!ROMManager::LoadROM(file, true))
+    {
+        // TODO: better error reporting?
+        QMessageBox::critical(this, "melonDS", "Failed to load the ROM.");
+        emuThread->emuUnpause();
+        return;
+    }
+
+    QString filename = file.join('|');
+    recentFileList.removeAll(filename);
+    recentFileList.prepend(filename);
+    updateRecentFilesMenu();
+
+    NDS::Start();
+    emuThread->emuRun();
+
+    updateCartInserted(false);
+}
+
+void MainWindow::onClearRecentFiles()
+{
+    recentFileList.clear();
+    for (int i = 0; i < 10; i++)
+        Config::RecentROMList[i] = "";
+    updateRecentFilesMenu();
+}
+
+void MainWindow::updateRecentFilesMenu()
+{
+    recentMenu->clear();
+
+    for (int i = 0; i < recentFileList.size(); ++i)
+    {
+        if (i >= 10) break;
+
+        QString item_full = recentFileList.at(i);
+        QString item_display = item_full;
+        int itemlen = item_full.length();
+        const int maxlen = 100;
+        if (itemlen > maxlen)
+        {
+            int cut_start = 0;
+            while (item_full[cut_start] != '/' && item_full[cut_start] != '\\' &&
+                   cut_start < itemlen)
+                cut_start++;
+
+            int cut_end = itemlen-1;
+            while (((item_full[cut_end] != '/' && item_full[cut_end] != '\\') ||
+                    (cut_start+4+(itemlen-cut_end) < maxlen)) &&
+                   cut_end > 0)
+                cut_end--;
+
+            item_display.truncate(cut_start+1);
+            item_display += "...";
+            item_display += QString(item_full).remove(0, cut_end);
+        }
+
+        QAction *actRecentFile_i = recentMenu->addAction(QString("%1.  %2").arg(i+1).arg(item_display));
+        actRecentFile_i->setData(item_full);
+        connect(actRecentFile_i, &QAction::triggered, this, &MainWindow::onClickRecentFile);
+
+        Config::RecentROMList[i] = recentFileList.at(i).toStdString();
+    }
+
+    while (recentFileList.size() > 10)
+        recentFileList.removeLast();
+
+    recentMenu->addSeparator();
+
+    QAction *actClearRecentList = recentMenu->addAction("Clear");
+    connect(actClearRecentList, &QAction::triggered, this, &MainWindow::onClearRecentFiles);
+
+    if (recentFileList.empty())
+        actClearRecentList->setEnabled(false);
+
+    Config::Save();
+}
+
+void MainWindow::onClickRecentFile()
+{
+    QAction *act = (QAction *)sender();
+    QString filename = act->data().toString();
+
+    emuThread->emuPause();
+
+    if (!verifySetup())
+    {
+        emuThread->emuUnpause();
+        return;
+    }
+
+    const QStringList file = splitArchivePath(filename, true);
+    if (file.isEmpty())
+    {
+        emuThread->emuUnpause();
+        return;
+    }
+
+    if (!ROMManager::LoadROM(file, true))
+    {
+        // TODO: better error reporting?
+        QMessageBox::critical(this, "melonDS", "Failed to load the ROM.");
+        emuThread->emuUnpause();
+        return;
+    }
+
+    recentFileList.removeAll(filename);
+    recentFileList.prepend(filename);
+    updateRecentFilesMenu();
+
+    NDS::Start();
+    emuThread->emuRun();
+
+    updateCartInserted(false);
+}
+
+void MainWindow::onBootFirmware()
+{
+    emuThread->emuPause();
+
+    if (!verifySetup())
+    {
+        emuThread->emuUnpause();
+        return;
+    }
+
+    if (!ROMManager::LoadBIOS())
+    {
+        // TODO: better error reporting?
+        QMessageBox::critical(this, "melonDS", "This firmware is not bootable.");
+        emuThread->emuUnpause();
+        return;
+    }
+
+    NDS::Start();
+    emuThread->emuRun();
+}
+
+void MainWindow::onInsertCart()
+{
+    emuThread->emuPause();
+
+    QStringList file = pickROM(false);
+    if (file.isEmpty())
+    {
+        emuThread->emuUnpause();
+        return;
+    }
+
+    if (!ROMManager::LoadROM(file, false))
+    {
+        // TODO: better error reporting?
+        QMessageBox::critical(this, "melonDS", "Failed to load the ROM.");
+        emuThread->emuUnpause();
+        return;
+    }
+
+    emuThread->emuUnpause();
+
+    updateCartInserted(false);
+}
+
+void MainWindow::onEjectCart()
+{
+    emuThread->emuPause();
+
+    ROMManager::EjectCart();
+
+    emuThread->emuUnpause();
+
+    updateCartInserted(false);
+}
+
+void MainWindow::onInsertGBACart()
+{
+    emuThread->emuPause();
+
+    QStringList file = pickROM(true);
+    if (file.isEmpty())
+    {
+        emuThread->emuUnpause();
+        return;
+    }
+
+    if (!ROMManager::LoadGBAROM(file))
+    {
+        // TODO: better error reporting?
+        QMessageBox::critical(this, "melonDS", "Failed to load the ROM.");
+        emuThread->emuUnpause();
+        return;
+    }
+
+    emuThread->emuUnpause();
+
+    updateCartInserted(true);
+}
+
+void MainWindow::onInsertGBAAddon()
+{
+    QAction* act = (QAction*)sender();
+    int type = act->data().toInt();
+
+    emuThread->emuPause();
+
+    ROMManager::LoadGBAAddon(type);
+
+    emuThread->emuUnpause();
+
+    updateCartInserted(true);
+}
+
+void MainWindow::onEjectGBACart()
+{
+    emuThread->emuPause();
+
+    ROMManager::EjectGBACart();
+
+    emuThread->emuUnpause();
+
+    updateCartInserted(true);
+}
+
+void MainWindow::onSaveState()
+{
+    int slot = ((QAction*)sender())->data().toInt();
+
+    emuThread->emuPause();
+
+    std::string filename;
+    if (slot > 0)
+    {
+        filename = ROMManager::GetSavestateName(slot);
+    }
+    else
+    {
+        // TODO: specific 'last directory' for savestate files?
+        QString qfilename = QFileDialog::getSaveFileName(this,
+                                                         "Save state",
+                                                         QString::fromStdString(Config::LastROMFolder),
+                                                         "melonDS savestates (*.mln);;Any file (*.*)");
+        if (qfilename.isEmpty())
+        {
+            emuThread->emuUnpause();
+            return;
+        }
+
+        filename = qfilename.toStdString();
+    }
+
+    if (ROMManager::SaveState(filename))
+    {
+        char msg[64];
+        if (slot > 0) sprintf(msg, "State saved to slot %d", slot);
+        else          sprintf(msg, "State saved to file");
+        OSD::AddMessage(0, msg);
+
+        actLoadState[slot]->setEnabled(true);
+    }
+    else
+    {
+        OSD::AddMessage(0xFFA0A0, "State save failed");
+    }
+
+    emuThread->emuUnpause();
+}
+
+void MainWindow::onLoadState()
+{
+    int slot = ((QAction*)sender())->data().toInt();
+
+    emuThread->emuPause();
+
+    std::string filename;
+    if (slot > 0)
+    {
+        filename = ROMManager::GetSavestateName(slot);
+    }
+    else
+    {
+        // TODO: specific 'last directory' for savestate files?
+        QString qfilename = QFileDialog::getOpenFileName(this,
+                                                         "Load state",
+                                                         QString::fromStdString(Config::LastROMFolder),
+                                                         "melonDS savestates (*.ml*);;Any file (*.*)");
+        if (qfilename.isEmpty())
+        {
+            emuThread->emuUnpause();
+            return;
+        }
+
+        filename = qfilename.toStdString();
+    }
+
+    if (!Platform::FileExists(filename))
+    {
+        char msg[64];
+        if (slot > 0) sprintf(msg, "State slot %d is empty", slot);
+        else          sprintf(msg, "State file does not exist");
+        OSD::AddMessage(0xFFA0A0, msg);
+
+        emuThread->emuUnpause();
+        return;
+    }
+
+    if (ROMManager::LoadState(filename))
+    {
+        char msg[64];
+        if (slot > 0) sprintf(msg, "State loaded from slot %d", slot);
+        else          sprintf(msg, "State loaded from file");
+        OSD::AddMessage(0, msg);
+
+        actUndoStateLoad->setEnabled(true);
+    }
+    else
+    {
+        OSD::AddMessage(0xFFA0A0, "State load failed");
+    }
+
+    emuThread->emuUnpause();
+}
+
+void MainWindow::onUndoStateLoad()
+{
+    emuThread->emuPause();
+    ROMManager::UndoStateLoad();
+    emuThread->emuUnpause();
+
+    OSD::AddMessage(0, "State load undone");
+}
+
+void MainWindow::onImportSavefile()
+{
+    emuThread->emuPause();
+    QString path = QFileDialog::getOpenFileName(this,
+                                            "Select savefile",
+                                            QString::fromStdString(Config::LastROMFolder),
+                                            "Savefiles (*.sav *.bin *.dsv);;Any file (*.*)");
+
+    if (path.isEmpty())
+    {
+        emuThread->emuUnpause();
+        return;
+    }
+
+    Platform::FileHandle* f = Platform::OpenFile(path.toStdString(), Platform::FileMode::Read);
+    if (!f)
+    {
+        QMessageBox::critical(this, "melonDS", "Could not open the given savefile.");
+        emuThread->emuUnpause();
+        return;
+    }
+
+    if (RunningSomething)
+    {
+        if (QMessageBox::warning(this,
+                        "melonDS",
+                        "The emulation will be reset and the current savefile overwritten.",
+                        QMessageBox::Ok, QMessageBox::Cancel) != QMessageBox::Ok)
+        {
+            emuThread->emuUnpause();
+            return;
+        }
+
+        ROMManager::Reset();
+    }
+
+    u32 len = FileLength(f);
+
+    u8* data = new u8[len];
+    Platform::FileRewind(f);
+    Platform::FileRead(data, len, 1, f);
+
+    NDS::LoadSave(data, len);
+    delete[] data;
+
+    CloseFile(f);
+    emuThread->emuUnpause();
+}
+
+void MainWindow::onQuit()
+{
+#ifndef _WIN32
+    signalSn->setEnabled(false);
+#endif
+    QApplication::quit();
+}
+
+
+void MainWindow::onPause(bool checked)
+{
+    if (!RunningSomething) return;
+
+    if (checked)
+    {
+        emuThread->emuPause();
+        OSD::AddMessage(0, "Paused");
+        pausedManually = true;
+    }
+    else
+    {
+        emuThread->emuUnpause();
+        OSD::AddMessage(0, "Resumed");
+        pausedManually = false;
+    }
+}
+
+void MainWindow::onReset()
+{
+    if (!RunningSomething) return;
+
+    emuThread->emuPause();
+
+    actUndoStateLoad->setEnabled(false);
+
+    ROMManager::Reset();
+
+    OSD::AddMessage(0, "Reset");
+    emuThread->emuRun();
+}
+
+void MainWindow::onStop()
+{
+    if (!RunningSomething) return;
+
+    emuThread->emuPause();
+    NDS::Stop();
+}
+
+void MainWindow::onFrameStep()
+{
+    if (!RunningSomething) return;
+
+    emuThread->emuFrameStep();
+}
+
+void MainWindow::onEnableCheats(bool checked)
+{
+    Config::EnableCheats = checked?1:0;
+    ROMManager::EnableCheats(Config::EnableCheats != 0);
+}
+
+void MainWindow::onSetupCheats()
+{
+    emuThread->emuPause();
+
+    CheatsDialog* dlg = CheatsDialog::openDlg(this);
+    connect(dlg, &CheatsDialog::finished, this, &MainWindow::onCheatsDialogFinished);
+}
+
+void MainWindow::onCheatsDialogFinished(int res)
+{
+    emuThread->emuUnpause();
+}
+
+void MainWindow::onROMInfo()
+{
+    ROMInfoDialog* dlg = ROMInfoDialog::openDlg(this);
+}
+
+void MainWindow::onRAMInfo()
+{
+    RAMInfoDialog* dlg = RAMInfoDialog::openDlg(this);
+}
+
+void MainWindow::onOpenTitleManager()
+{
+    TitleManagerDialog* dlg = TitleManagerDialog::openDlg(this);
+}
+
+void MainWindow::onMPNewInstance()
+{
+    //QProcess::startDetached(QApplication::applicationFilePath());
+    QProcess newinst;
+    newinst.setProgram(QApplication::applicationFilePath());
+    newinst.setArguments(QApplication::arguments().mid(1, QApplication::arguments().length()-1));
+
+#ifdef __WIN32__
+    newinst.setCreateProcessArgumentsModifier([] (QProcess::CreateProcessArguments *args)
+    {
+        args->flags |= CREATE_NEW_CONSOLE;
+    });
+#endif
+
+    newinst.startDetached();
+}
+
+void MainWindow::onOpenEmuSettings()
+{
+    emuThread->emuPause();
+
+    EmuSettingsDialog* dlg = EmuSettingsDialog::openDlg(this);
+    connect(dlg, &EmuSettingsDialog::finished, this, &MainWindow::onEmuSettingsDialogFinished);
+}
+
+void MainWindow::onEmuSettingsDialogFinished(int res)
+{
+    emuThread->emuUnpause();
+
+    if (Config::ConsoleType == 1)
+    {
+        actInsertGBACart->setEnabled(false);
+        for (int i = 0; i < 1; i++)
+            actInsertGBAAddon[i]->setEnabled(false);
+        actEjectGBACart->setEnabled(false);
+    }
+    else
+    {
+        actInsertGBACart->setEnabled(true);
+        for (int i = 0; i < 1; i++)
+            actInsertGBAAddon[i]->setEnabled(true);
+        actEjectGBACart->setEnabled(ROMManager::GBACartInserted());
+    }
+
+    if (EmuSettingsDialog::needsReset)
+        onReset();
+
+    actCurrentGBACart->setText("GBA slot: " + ROMManager::GBACartLabel());
+
+    if (!RunningSomething)
+        actTitleManager->setEnabled(!Config::DSiNANDPath.empty());
+}
+
+void MainWindow::onOpenPowerManagement()
+{
+    PowerManagementDialog* dlg = PowerManagementDialog::openDlg(this);
+}
+
+void MainWindow::onOpenInputConfig()
+{
+    emuThread->emuPause();
+
+    InputConfigDialog* dlg = InputConfigDialog::openDlg(this);
+    connect(dlg, &InputConfigDialog::finished, this, &MainWindow::onInputConfigFinished);
+}
+
+void MainWindow::onInputConfigFinished(int res)
+{
+    emuThread->emuUnpause();
+}
+
+void MainWindow::onOpenVideoSettings()
+{
+    VideoSettingsDialog* dlg = VideoSettingsDialog::openDlg(this);
+    connect(dlg, &VideoSettingsDialog::updateVideoSettings, this, &MainWindow::onUpdateVideoSettings);
+}
+
+void MainWindow::onOpenCameraSettings()
+{
+    emuThread->emuPause();
+
+    camStarted[0] = camManager[0]->isStarted();
+    camStarted[1] = camManager[1]->isStarted();
+    if (camStarted[0]) camManager[0]->stop();
+    if (camStarted[1]) camManager[1]->stop();
+
+    CameraSettingsDialog* dlg = CameraSettingsDialog::openDlg(this);
+    connect(dlg, &CameraSettingsDialog::finished, this, &MainWindow::onCameraSettingsFinished);
+}
+
+void MainWindow::onCameraSettingsFinished(int res)
+{
+    if (camStarted[0]) camManager[0]->start();
+    if (camStarted[1]) camManager[1]->start();
+
+    emuThread->emuUnpause();
+}
+
+void MainWindow::onOpenAudioSettings()
+{
+    AudioSettingsDialog* dlg = AudioSettingsDialog::openDlg(this, emuThread->emuIsActive());
+    connect(emuThread, &EmuThread::syncVolumeLevel, dlg, &AudioSettingsDialog::onSyncVolumeLevel);
+    connect(emuThread, &EmuThread::windowEmuStart, dlg, &AudioSettingsDialog::onConsoleReset);
+    connect(dlg, &AudioSettingsDialog::updateAudioSettings, this, &MainWindow::onUpdateAudioSettings);
+    connect(dlg, &AudioSettingsDialog::finished, this, &MainWindow::onAudioSettingsFinished);
+}
+
+void MainWindow::onOpenFirmwareSettings()
+{
+    emuThread->emuPause();
+
+    FirmwareSettingsDialog* dlg = FirmwareSettingsDialog::openDlg(this);
+    connect(dlg, &FirmwareSettingsDialog::finished, this, &MainWindow::onFirmwareSettingsFinished);
+}
+
+void MainWindow::onFirmwareSettingsFinished(int res)
+{
+    if (FirmwareSettingsDialog::needsReset)
+        onReset();
+
+    emuThread->emuUnpause();
+}
+
+void MainWindow::onOpenPathSettings()
+{
+    emuThread->emuPause();
+
+    PathSettingsDialog* dlg = PathSettingsDialog::openDlg(this);
+    connect(dlg, &PathSettingsDialog::finished, this, &MainWindow::onPathSettingsFinished);
+}
+
+void MainWindow::onPathSettingsFinished(int res)
+{
+    if (PathSettingsDialog::needsReset)
+        onReset();
+
+    emuThread->emuUnpause();
+}
+
+void MainWindow::onUpdateAudioSettings()
+{
+    SPU::SetInterpolation(Config::AudioInterp);
+
+    if (Config::AudioBitDepth == 0)
+        SPU::SetDegrade10Bit(NDS::ConsoleType == 0);
+    else
+        SPU::SetDegrade10Bit(Config::AudioBitDepth == 1);
+}
+
+void MainWindow::onAudioSettingsFinished(int res)
+{
+    AudioInOut::UpdateSettings();
+}
+
+void MainWindow::onOpenMPSettings()
+{
+    emuThread->emuPause();
+
+    MPSettingsDialog* dlg = MPSettingsDialog::openDlg(this);
+    connect(dlg, &MPSettingsDialog::finished, this, &MainWindow::onMPSettingsFinished);
+}
+
+void MainWindow::onMPSettingsFinished(int res)
+{
+    AudioInOut::AudioMute(mainWindow);
+    LocalMP::SetRecvTimeout(Config::MPRecvTimeout);
+
+    emuThread->emuUnpause();
+}
+
+void MainWindow::onOpenWifiSettings()
+{
+    emuThread->emuPause();
+
+    WifiSettingsDialog* dlg = WifiSettingsDialog::openDlg(this);
+    connect(dlg, &WifiSettingsDialog::finished, this, &MainWindow::onWifiSettingsFinished);
+}
+
+void MainWindow::onWifiSettingsFinished(int res)
+{
+    Platform::LAN_DeInit();
+    Platform::LAN_Init();
+
+    if (WifiSettingsDialog::needsReset)
+        onReset();
+
+    emuThread->emuUnpause();
+}
+
+void MainWindow::onOpenInterfaceSettings()
+{
+    emuThread->emuPause();
+    InterfaceSettingsDialog* dlg = InterfaceSettingsDialog::openDlg(this);
+    connect(dlg, &InterfaceSettingsDialog::finished, this, &MainWindow::onInterfaceSettingsFinished);
+    connect(dlg, &InterfaceSettingsDialog::updateMouseTimer, this, &MainWindow::onUpdateMouseTimer);
+}
+
+void MainWindow::onUpdateMouseTimer()
+{
+    panel->mouseTimer->setInterval(Config::MouseHideSeconds*1000);
+}
+
+void MainWindow::onInterfaceSettingsFinished(int res)
+{
+    emuThread->emuUnpause();
+}
+
+void MainWindow::onChangeSavestateSRAMReloc(bool checked)
+{
+    Config::SavestateRelocSRAM = checked?1:0;
+}
+
+void MainWindow::onChangeScreenSize()
+{
+    int factor = ((QAction*)sender())->data().toInt();
+    QSize diff = size() - panelWidget->size();
+    resize(panel->screenGetMinSize(factor) + diff);
+}
+
+void MainWindow::onChangeScreenRotation(QAction* act)
+{
+    int rot = act->data().toInt();
+    Config::ScreenRotation = rot;
+
+    emit screenLayoutChange();
+}
+
+void MainWindow::onChangeScreenGap(QAction* act)
+{
+    int gap = act->data().toInt();
+    Config::ScreenGap = gap;
+
+    emit screenLayoutChange();
+}
+
+void MainWindow::onChangeScreenLayout(QAction* act)
+{
+    int layout = act->data().toInt();
+    Config::ScreenLayout = layout;
+
+    emit screenLayoutChange();
+}
+
+void MainWindow::onChangeScreenSwap(bool checked)
+{
+    Config::ScreenSwap = checked?1:0;
+
+    // Swap between top and bottom screen when displaying one screen.
+    if (Config::ScreenSizing == Frontend::screenSizing_TopOnly)
+    {
+        // Bottom Screen.
+        Config::ScreenSizing = Frontend::screenSizing_BotOnly;
+        actScreenSizing[Frontend::screenSizing_TopOnly]->setChecked(false);
+        actScreenSizing[Config::ScreenSizing]->setChecked(true);
+    }
+    else if (Config::ScreenSizing == Frontend::screenSizing_BotOnly)
+    {
+        // Top Screen.
+        Config::ScreenSizing = Frontend::screenSizing_TopOnly;
+        actScreenSizing[Frontend::screenSizing_BotOnly]->setChecked(false);
+        actScreenSizing[Config::ScreenSizing]->setChecked(true);
+    }
+
+    emit screenLayoutChange();
+}
+
+void MainWindow::onChangeScreenSizing(QAction* act)
+{
+    int sizing = act->data().toInt();
+    Config::ScreenSizing = sizing;
+
+    emit screenLayoutChange();
+}
+
+void MainWindow::onChangeScreenAspect(QAction* act)
+{
+    int aspect = act->data().toInt();
+    QActionGroup* group = act->actionGroup();
+
+    if (group == grpScreenAspectTop)
+    {
+        Config::ScreenAspectTop = aspect;
+    }
+    else
+    {
+        Config::ScreenAspectBot = aspect;
+    }
+
+    emit screenLayoutChange();
+}
+
+void MainWindow::onChangeIntegerScaling(bool checked)
+{
+    Config::IntegerScaling = checked?1:0;
+
+    emit screenLayoutChange();
+}
+
+void MainWindow::onChangeScreenFiltering(bool checked)
+{
+    Config::ScreenFilter = checked?1:0;
+
+    emit screenLayoutChange();
+}
+
+void MainWindow::onChangeShowOSD(bool checked)
+{
+    Config::ShowOSD = checked?1:0;
+}
+void MainWindow::onChangeLimitFramerate(bool checked)
+{
+    Config::LimitFPS = checked?1:0;
+}
+
+void MainWindow::onChangeAudioSync(bool checked)
+{
+    Config::AudioSync = checked?1:0;
+}
+
+
+void MainWindow::onTitleUpdate(QString title)
+{
+    setWindowTitle(title);
+}
+
+void ToggleFullscreen(MainWindow* mainWindow)
+{
+    if (!mainWindow->isFullScreen())
+    {
+        mainWindow->showFullScreen();
+        mainWindow->menuBar()->setFixedHeight(0); // Don't use hide() as menubar actions stop working
+    }
+    else
+    {
+        mainWindow->showNormal();
+        int menuBarHeight = mainWindow->menuBar()->sizeHint().height();
+        mainWindow->menuBar()->setFixedHeight(menuBarHeight);
+    }
+}
+
+void MainWindow::onFullscreenToggled()
+{
+    ToggleFullscreen(this);
+}
+
+void MainWindow::onScreenEmphasisToggled()
+{
+    int currentSizing = Config::ScreenSizing;
+    if (currentSizing == Frontend::screenSizing_EmphTop)
+    {
+        Config::ScreenSizing = Frontend::screenSizing_EmphBot;
+    }
+    else if (currentSizing == Frontend::screenSizing_EmphBot)
+    {
+        Config::ScreenSizing = Frontend::screenSizing_EmphTop;
+    }
+
+    emit screenLayoutChange();
+}
+
+void MainWindow::onEmuStart()
+{
+    for (int i = 1; i < 9; i++)
+    {
+        actSaveState[i]->setEnabled(true);
+        actLoadState[i]->setEnabled(ROMManager::SavestateExists(i));
+    }
+    actSaveState[0]->setEnabled(true);
+    actLoadState[0]->setEnabled(true);
+    actUndoStateLoad->setEnabled(false);
+
+    actPause->setEnabled(true);
+    actPause->setChecked(false);
+    actReset->setEnabled(true);
+    actStop->setEnabled(true);
+    actFrameStep->setEnabled(true);
+
+    actPowerManagement->setEnabled(true);
+
+    actTitleManager->setEnabled(false);
+}
+
+void MainWindow::onEmuStop()
+{
+    emuThread->emuPause();
+
+    for (int i = 0; i < 9; i++)
+    {
+        actSaveState[i]->setEnabled(false);
+        actLoadState[i]->setEnabled(false);
+    }
+    actUndoStateLoad->setEnabled(false);
+
+    actPause->setEnabled(false);
+    actReset->setEnabled(false);
+    actStop->setEnabled(false);
+    actFrameStep->setEnabled(false);
+
+    actPowerManagement->setEnabled(false);
+
+    actTitleManager->setEnabled(!Config::DSiNANDPath.empty());
+}
+
+void MainWindow::onUpdateVideoSettings(bool glchange)
+{
+    if (glchange)
+    {
+        emuThread->emuPause();
+        if (hasOGL) emuThread->deinitContext();
+
+        delete panel;
+        createScreenPanel();
+        connect(emuThread, SIGNAL(windowUpdate()), panelWidget, SLOT(repaint()));
+    }
+
+    videoSettingsDirty = true;
+
+    if (glchange)
+    {
+        if (hasOGL) emuThread->initContext();
+        emuThread->emuUnpause();
+    }
+}
+
+
+void emuStop()
+{
+    RunningSomething = false;
+
+    emit emuThread->windowEmuStop();
+}
+
+MelonApplication::MelonApplication(int& argc, char** argv)
+    : QApplication(argc, argv)
+{
+#ifndef __APPLE__
+    setWindowIcon(QIcon(":/melon-icon"));
+#endif
+}
+
+bool MelonApplication::event(QEvent *event)
+{
+    if (event->type() == QEvent::FileOpen)
+    {
+        QFileOpenEvent *openEvent = static_cast<QFileOpenEvent*>(event);
+
+        emuThread->emuPause();
+        const QStringList file = mainWindow->splitArchivePath(openEvent->file(), true);
+        if (!mainWindow->preloadROMs(file, {}, true))
+            emuThread->emuUnpause();
+    }
+
+    return QApplication::event(event);
+}
+
+int main(int argc, char** argv)
+{
+    srand(time(nullptr));
+
+    qputenv("QT_SCALE_FACTOR", "1");
+
+    printf("melonDS " MELONDS_VERSION "\n");
+    printf(MELONDS_URL "\n");
+
+    // easter egg - not worth checking other cases for something so dumb
+    if (argc != 0 && (!strcasecmp(argv[0], "derpDS") || !strcasecmp(argv[0], "./derpDS")))
+        printf("did you just call me a derp???\n");
+
+    Platform::Init(argc, argv);
+
+    MelonApplication melon(argc, argv);
+
+    CLI::CommandLineOptions* options = CLI::ManageArgs(melon);
+
+    // http://stackoverflow.com/questions/14543333/joystick-wont-work-using-sdl
+    SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, "1");
+
+    if (SDL_Init(SDL_INIT_HAPTIC) < 0)
+    {
+        printf("SDL couldn't init rumble\n");
+    }
+    if (SDL_Init(SDL_INIT_JOYSTICK) < 0)
+    {
+        printf("SDL couldn't init joystick\n");
+    }
+    if (SDL_Init(SDL_INIT_AUDIO) < 0)
+    {
+        const char* err = SDL_GetError();
+        QString errorStr = "Failed to initialize SDL. This could indicate an issue with your audio driver.\n\nThe error was: ";
+        errorStr += err;
+
+        QMessageBox::critical(NULL, "melonDS", errorStr);
+        return 1;
+    }
+
+    SDL_JoystickEventState(SDL_ENABLE);
+
+    SDL_InitSubSystem(SDL_INIT_VIDEO);
+    SDL_EnableScreenSaver(); SDL_DisableScreenSaver();
+
+    Config::Load();
+
+#define SANITIZE(var, min, max)  { var = std::clamp(var, min, max); }
+    SANITIZE(Config::ConsoleType, 0, 1);
+    SANITIZE(Config::_3DRenderer,
+    0,
+    0 // Minimum, Software renderer
+    #ifdef OGLRENDERER_ENABLED
+    + 1 // OpenGL Renderer
+    #endif
+    );
+    SANITIZE(Config::ScreenVSyncInterval, 1, 20);
+    SANITIZE(Config::GL_ScaleFactor, 1, 16);
+    SANITIZE(Config::AudioInterp, 0, 3);
+    SANITIZE(Config::AudioVolume, 0, 256);
+    SANITIZE(Config::MicInputType, 0, (int)micInputType_MAX);
+    SANITIZE(Config::ScreenRotation, 0, (int)Frontend::screenRot_MAX);
+    SANITIZE(Config::ScreenGap, 0, 500);
+    SANITIZE(Config::ScreenLayout, 0, (int)Frontend::screenLayout_MAX);
+    SANITIZE(Config::ScreenSizing, 0, (int)Frontend::screenSizing_MAX);
+    SANITIZE(Config::ScreenAspectTop, 0, AspectRatiosNum);
+    SANITIZE(Config::ScreenAspectBot, 0, AspectRatiosNum);
+#undef SANITIZE
+
+    AudioInOut::Init();
+    camStarted[0] = false;
+    camStarted[1] = false;
+    camManager[0] = new CameraManager(0, 640, 480, true);
+    camManager[1] = new CameraManager(1, 640, 480, true);
+    camManager[0]->setXFlip(Config::Camera[0].XFlip);
+    camManager[1]->setXFlip(Config::Camera[1].XFlip);
+
+    ROMManager::EnableCheats(Config::EnableCheats != 0);
+
+    Input::JoystickID = Config::JoystickID;
+    Input::OpenJoystick();
+
+    mainWindow = new MainWindow();
+    if (options->fullscreen)
+        ToggleFullscreen(mainWindow);
+
+    emuThread = new EmuThread();
+    emuThread->start();
+    emuThread->emuPause();
+
+    AudioInOut::AudioMute(mainWindow);
+
+    QObject::connect(&melon, &QApplication::applicationStateChanged, mainWindow, &MainWindow::onAppStateChanged);
+
+    bool memberSyntaxUsed = false;
+    const auto prepareRomPath = [&](const std::optional<QString>& romPath, const std::optional<QString>& romArchivePath) -> QStringList
+    {
+        if (!romPath.has_value())
+            return {};
+
+        if (romArchivePath.has_value())
+            return { *romPath, *romArchivePath };
+
+        const QStringList path = mainWindow->splitArchivePath(*romPath, true);
+        if (path.size() > 1) memberSyntaxUsed = true;
+        return path;
+    };
+
+    const QStringList dsfile = prepareRomPath(options->dsRomPath, options->dsRomArchivePath);
+    const QStringList gbafile = prepareRomPath(options->gbaRomPath, options->gbaRomArchivePath);
+
+    if (memberSyntaxUsed) printf("Warning: use the a.zip|b.nds format at your own risk!\n");
+
+    mainWindow->preloadROMs(dsfile, gbafile, options->boot);
+
+    int ret = melon.exec();
+
+    emuThread->emuStop();
+    emuThread->wait();
+    delete emuThread;
+
+    Input::CloseJoystick();
+
+    AudioInOut::DeInit();
+    delete camManager[0];
+    delete camManager[1];
+
+    Config::Save();
+
+    SDL_Quit();
+    Platform::DeInit();
+    return ret;
+}
+
+#ifdef __WIN32__
+
+#include <windows.h>
+
+int CALLBACK WinMain(HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int cmdshow)
+{
+    int ret = main(__argc, __argv);
+
+    printf("\n\n>");
+
+    return ret;
+}
+
+#endif
diff --git a/src/frontend/qt_sdl/main.h b/src/frontend/qt_sdl/main.h
index 073a4da..aa94a62 100644
--- a/src/frontend/qt_sdl/main.h
+++ b/src/frontend/qt_sdl/main.h
@@ -121,7 +121,7 @@ private:
     GL::Context* oglContext = nullptr;
     GLuint screenVertexBuffer, screenVertexArray;
     GLuint screenTexture;
-    GLuint screenShaderProgram[3];
+    GLuint screenShaderProgram;
     GLuint screenShaderTransformULoc, screenShaderScreenSizeULoc;
 
     QMutex screenSettingsLock;

From 673f2c96d8d46b8bbe9a3c3d58ea85627b888779 Mon Sep 17 00:00:00 2001
From: v-fox <virtuousfox@gmail.com>
Date: Tue, 29 Aug 2023 14:42:25 +0500
Subject: [PATCH] replacement of FileMode to fix regression due to
 https://github.com/melonDS-emu/melonDS/pull/1800/

---
 src/OpenGLSupport.cpp | 43 +++++++++++++++++++++----------------------
 1 file changed, 21 insertions(+), 22 deletions(-)

diff --git a/src/OpenGLSupport.cpp b/src/OpenGLSupport.cpp
index 4cb0e97..7130c7d 100644
--- a/src/OpenGLSupport.cpp
+++ b/src/OpenGLSupport.cpp
@@ -26,8 +26,7 @@
 #define XXH_STATIC_LINKING_ONLY
 #include "xxhash/xxhash.h"
 
-using Platform::Log;
-using Platform::LogLevel;
+using namespace Platform;
 
 namespace OpenGL
 {
@@ -73,7 +72,7 @@ void LoadShaderCache()
 {
     // for now the shader cache only contains only compute shaders
     // because they take the longest to compile
-    FILE* file = Platform::OpenLocalFile("shadercache", "rb");
+    FileHandle* file = OpenLocalFile("shadercache", FileMode::Read);
     if (file == nullptr)
     {
         Log(LogLevel::Error, "Could not find shader cache\n");
@@ -81,19 +80,19 @@ void LoadShaderCache()
     }
 
     u32 magic, version, numPrograms;
-    if (fread(&magic, 4, 1, file) != 1 || magic != ShaderCacheMagic)
+    if (FileRead(&magic, 4, 1, file) != 1 || magic != ShaderCacheMagic)
     {
         Log(LogLevel::Error, "Shader cache file has invalid magic\n");
         goto fileInvalid;
     }
 
-    if (fread(&version, 4, 1, file) != 1 || version != ShaderCacheVersion)
+    if (FileRead(&version, 4, 1, file) != 1 || version != ShaderCacheVersion)
     {
         Log(LogLevel::Error, "Shader cache file has bad version\n");
         goto fileInvalid;
     }
 
-    if (fread(&numPrograms, 4, 1, file) != 1)
+    if (FileRead(&numPrograms, 4, 1, file) != 1)
     {
         Log(LogLevel::Error, "Shader cache file invalid program count\n");
         goto fileInvalid;
@@ -107,9 +106,9 @@ void LoadShaderCache()
 
         u32 length, binaryFormat;
         u64 sourceHash;
-        error -= fread(&sourceHash, 8, 1, file);
-        error -= fread(&length, 4, 1, file);
-        error -= fread(&binaryFormat, 4, 1, file);
+        error -= FileRead(&sourceHash, 8, 1, file);
+        error -= FileRead(&length, 4, 1, file);
+        error -= FileRead(&binaryFormat, 4, 1, file);
 
         if (error != 0)
         {
@@ -118,7 +117,7 @@ void LoadShaderCache()
         }
 
         u8* data = new u8[length];
-        if (fread(data, length, 1, file) != 1)
+        if (FileRead(data, length, 1, file) != 1)
         {
             Log(LogLevel::Error, "Could not read shader cache entry data\n");
             delete[] data;
@@ -130,14 +129,14 @@ void LoadShaderCache()
     }
 
 fileInvalid:
-    fclose(file);
+    CloseFile(file);
 }
 
 void SaveShaderCache()
 {
-    FILE* file = Platform::OpenLocalFile("shadercache", "rb+");
+    FileHandle* file = OpenLocalFile("shadercache", FileMode::ReadWriteExisting);
     if (file == nullptr)
-        file = Platform::OpenLocalFile("shadercache", "wb");
+        file = OpenLocalFile("shadercache", FileMode::Write);
 
     if (file == nullptr)
     {
@@ -147,9 +146,9 @@ void SaveShaderCache()
 
     int written = 3;
     u32 magic = ShaderCacheMagic, version = ShaderCacheVersion, numPrograms = ShaderCache.size();
-    written -= fwrite(&magic, 4, 1, file);
-    written -= fwrite(&version, 4, 1, file);
-    written -= fwrite(&numPrograms, 4, 1, file);
+    written -= FileWrite(&magic, 4, 1, file);
+    written -= FileWrite(&version, 4, 1, file);
+    written -= FileWrite(&numPrograms, 4, 1, file);
 
     if (written != 0)
     {
@@ -157,7 +156,7 @@ void SaveShaderCache()
         goto writeError;
     }
 
-    fseek(file, 0, SEEK_END);
+    FileRewind(file);
 
     printf("new shaders %d\n", NewShaders.size());
 
@@ -166,10 +165,10 @@ void SaveShaderCache()
         int error = 4;
         auto it = ShaderCache.find(newShader);
 
-        error -= fwrite(&it->first, 8, 1, file);
-        error -= fwrite(&it->second.Length, 4, 1, file);
-        error -= fwrite(&it->second.BinaryFormat, 4, 1, file);
-        error -= fwrite(it->second.Data, it->second.Length, 1, file);
+        error -= FileWrite(&it->first, 8, 1, file);
+        error -= FileWrite(&it->second.Length, 4, 1, file);
+        error -= FileWrite(&it->second.BinaryFormat, 4, 1, file);
+        error -= FileWrite(it->second.Data, it->second.Length, 1, file);
 
         if (error != 0)
         {
@@ -179,7 +178,7 @@ void SaveShaderCache()
     }
 
 writeError:
-    fclose(file);
+    CloseFile(file);
 
     NewShaders.clear();
 }

From c32c30a4f7339a2587d53757067fa90d4c58d42d Mon Sep 17 00:00:00 2001
From: v-fox <virtuousfox@gmail.com>
Date: Tue, 5 Sep 2023 14:07:54 +0500
Subject: [PATCH] Merge branch 'master' of https://github.com/Arisotura/melonDS
 into csr

---
 src/DSi_AES.h    |  4 ++--
 src/DSi_NAND.cpp | 17 +++++++++++++----
 2 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/src/DSi_AES.h b/src/DSi_AES.h
index 9baf747..f3aa550 100644
--- a/src/DSi_AES.h
+++ b/src/DSi_AES.h
@@ -28,14 +28,14 @@
 // NOTE: Yes, the compiler does *not* recognize this code pattern, so it is indeed an optimization.
 __attribute((always_inline)) static void Bswap128(void* Dst, void* Src)
 {
-    *(__int128*)&Dst = __builtin_bswap128(*(__int128*)&Src);
+    *(__int128*)Dst = __builtin_bswap128(*(__int128*)Src);
 }
 #else
 __attribute((always_inline)) static void Bswap128(void* Dst, void* Src)
 {
     for (int i = 0; i < 16; ++i) 
     { 
-        ((char*)Src)[i] = ((char*)Src)[15 - i]; 
+        ((u8*)Dst)[i] = ((u8*)Src)[15 - i]; 
     }
 }
 #endif
diff --git a/src/DSi_NAND.cpp b/src/DSi_NAND.cpp
index 21da7ed..df9cdd2 100644
--- a/src/DSi_NAND.cpp
+++ b/src/DSi_NAND.cpp
@@ -337,13 +337,16 @@ bool ESEncrypt(u8* data, u32 len)
     {
         u8 rem[16];
 
-        Bswap128(rem, &data[coarselen]);
+        memset(rem, 0, 16);
+        for (int i = 0; i < remlen; i++)
+            rem[15-i] = data[coarselen+i];
 
         for (int i = 0; i < 16; i++) mac[i] ^= rem[i];
         AES_CTR_xcrypt_buffer(&ctx, rem, sizeof(rem));
         AES_ECB_encrypt(&ctx, mac);
 
-        Bswap128(&data[coarselen], rem);
+        for (int i = 0; i < remlen; i++)
+            data[coarselen+i] = rem[15-i];
     }
 
     ctx.Iv[13] = 0x00;
@@ -424,14 +427,20 @@ bool ESDecrypt(u8* data, u32 len)
         iv[14] = (ivnum >> 8) & 0xFF;
         iv[15] = ivnum & 0xFF;
 
-        Bswap128(rem, &data[coarselen]);
+        memset(rem, 0, 16);
+        AES_ctx_set_iv(&ctx, iv);
+        AES_CTR_xcrypt_buffer(&ctx, rem, 16);
+
+        for (int i = 0; i < remlen; i++)
+            rem[15-i] = data[coarselen+i];
 
         AES_ctx_set_iv(&ctx, iv);
         AES_CTR_xcrypt_buffer(&ctx, rem, 16);
         for (int i = 0; i < 16; i++) mac[i] ^= rem[i];
         AES_ECB_encrypt(&ctx, mac);
 
-        Bswap128(&data[coarselen], rem);
+        for (int i = 0; i < remlen; i++)
+            data[coarselen+i] = rem[15-i];
     }
 
     ctx.Iv[13] = 0x00;

From 01275e48e1b34f904e36ec0c1b8fd9fb28eba1cc Mon Sep 17 00:00:00 2001
From: v-fox <virtuousfox@gmail.com>
Date: Sat, 16 Sep 2023 21:09:22 +0500
Subject: [PATCH] Merge branch 'master' of https://github.com/Arisotura/melonDS
 into csr

diff --git a/src/ARMJIT.cpp b/src/ARMJIT.cpp
index 7a4cdc6..77bb50d 100644
--- a/src/ARMJIT.cpp
+++ b/src/ARMJIT.cpp
@@ -330,6 +330,7 @@ void DeInit()
     ARMJIT_Memory::DeInit();
 
     delete JITCompiler;
+    JITCompiler = nullptr;
 }
 
 void Reset()
diff --git a/src/ARMJIT_Memory.cpp b/src/ARMJIT_Memory.cpp
index 8e6a9f6..25652cb 100644
--- a/src/ARMJIT_Memory.cpp
+++ b/src/ARMJIT_Memory.cpp
@@ -308,7 +308,7 @@ HANDLE MemoryFile;
 LPVOID ExceptionHandlerHandle;
 #else
 u8* MemoryBase;
-int MemoryFile;
+int MemoryFile = -1;
 #endif
 
 bool MapIntoRange(u32 addr, u32 num, u32 offset, u32 size)
@@ -811,25 +811,58 @@ void DeInit()
 {
 #if defined(__SWITCH__)
     virtmemLock();
-    virtmemRemoveReservation(FastMem9Reservation);
-    virtmemRemoveReservation(FastMem7Reservation);
+    if (FastMem9Reservation)
+        virtmemRemoveReservation(FastMem9Reservation);
+
+    if (FastMem7Reservation)
+        virtmemRemoveReservation(FastMem7Reservation);
+
+    FastMem9Reservation = nullptr;
+    FastMem7Reservation = nullptr;
     virtmemUnlock();
 
     svcUnmapProcessCodeMemory(envGetOwnProcessHandle(), (u64)MemoryBaseCodeMem, (u64)MemoryBase, MemoryTotalSize);
     free(MemoryBase);
+    MemoryBase = nullptr;
 #elif defined(_WIN32)
-    assert(UnmapViewOfFile(MemoryBase));
-    CloseHandle(MemoryFile);
+    if (MemoryBase)
+    {
+        bool viewUnmapped = UnmapViewOfFile(MemoryBase);
+        assert(viewUnmapped);
+        MemoryBase = nullptr;
+        FastMem9Start = nullptr;
+        FastMem7Start = nullptr;
+    }
+
+    if (MemoryFile)
+    {
+        CloseHandle(MemoryFile);
+        MemoryFile = INVALID_HANDLE_VALUE;
+    }
 
-    RemoveVectoredExceptionHandler(ExceptionHandlerHandle);
+    if (ExceptionHandlerHandle)
+    {
+        RemoveVectoredExceptionHandler(ExceptionHandlerHandle);
+        ExceptionHandlerHandle = nullptr;
+    }
 #else
     sigaction(SIGSEGV, &OldSaSegv, nullptr);
 #ifdef __APPLE__
     sigaction(SIGBUS, &OldSaBus, nullptr);
 #endif
+    if (MemoryBase)
+    {
+        munmap(MemoryBase, MemoryTotalSize);
+        MemoryBase = nullptr;
+        FastMem9Start = nullptr;
+        FastMem7Start = nullptr;
+    }
 
-    munmap(MemoryBase, MemoryTotalSize);
-    close(MemoryFile);
+    if (MemoryFile >= 0)
+    {
+        close(MemoryFile);
+        MemoryFile = -1;
+    }
 
 #if defined(__ANDROID__)
     if (Libandroid)
diff --git a/src/DSi.cpp b/src/DSi.cpp
index dc066a7..5dd8ac9 100644
--- a/src/DSi.cpp
+++ b/src/DSi.cpp
@@ -128,6 +128,10 @@ void DeInit()
     delete[] NWRAM_A;
     delete[] NWRAM_B;
     delete[] NWRAM_C;
+
+    NWRAM_A = nullptr;
+    NWRAM_B = nullptr;
+    NWRAM_C = nullptr;
 #endif
 
     DSi_I2C::DeInit();
@@ -135,10 +139,16 @@ void DeInit()
     DSi_AES::DeInit();
     DSi_DSP::DeInit();
 
-    for (int i = 0; i < 8; i++) delete NDMAs[i];
+    for (int i = 0; i < 8; i++)
+    {
+        delete NDMAs[i];
+        NDMAs[i] = nullptr;
+    }
 
     delete SDMMC;
+    SDMMC = nullptr;
     delete SDIO;
+    SDIO = nullptr;
 }
 
 void Reset()
diff --git a/src/DSi_Camera.cpp b/src/DSi_Camera.cpp
index 9f45a6a..c5fa29d 100644
--- a/src/DSi_Camera.cpp
+++ b/src/DSi_Camera.cpp
@@ -63,6 +63,9 @@ void DeInit()
 {
     delete Camera0;
     delete Camera1;
+
+    Camera0 = nullptr;
+    Camera1 = nullptr;
 }
 
 void Reset()
diff --git a/src/GPU.cpp b/src/GPU.cpp
index af691a9..88782b8 100644
--- a/src/GPU.cpp
+++ b/src/GPU.cpp
@@ -172,6 +172,11 @@ void DeInit()
     if (Framebuffer[0][1]) delete[] Framebuffer[0][1];
     if (Framebuffer[1][0]) delete[] Framebuffer[1][0];
     if (Framebuffer[1][1]) delete[] Framebuffer[1][1];
+
+    Framebuffer[0][0] = nullptr;
+    Framebuffer[0][1] = nullptr;
+    Framebuffer[1][0] = nullptr;
+    Framebuffer[1][1] = nullptr;
 }
 
 void ResetVRAMCache()
@@ -389,23 +394,21 @@ void InitRenderer(int renderer)
 #ifdef OGLRENDERER_ENABLED
     if (renderer != renderer3D_Software)
     {
-        CurGLCompositor = std::make_unique<GLCompositor>();
-        // Create opengl rendrerer
-        if (!CurGLCompositor->Init())
+        CurGLCompositor = GLCompositor::New();
+        // Create opengl renderer
+        if (!CurGLCompositor)
         {
             // Fallback on software renderer
             renderer = 0;
             GPU3D::CurrentRenderer = std::make_unique<GPU3D::SoftRenderer>();
-            GPU3D::CurrentRenderer->Init();
         }
         if (renderer == renderer3D_OpenGL)
-            GPU3D::CurrentRenderer = std::make_unique<GPU3D::GLRenderer>();
+            GPU3D::CurrentRenderer = GPU3D::GLRenderer::New();
         else
-            GPU3D::CurrentRenderer = std::make_unique<GPU3D::ComputeRenderer>();
-        if (!GPU3D::CurrentRenderer->Init())
+            GPU3D::CurrentRenderer = GPU3D::ComputeRenderer::New();
+        if (!GPU3D::CurrentRenderer)
         {
             // Fallback on software renderer
-            CurGLCompositor->DeInit();
             CurGLCompositor.reset();
             renderer = 0;
             GPU3D::CurrentRenderer = std::make_unique<GPU3D::SoftRenderer>();
@@ -415,7 +418,6 @@ void InitRenderer(int renderer)
 #endif
     {
         GPU3D::CurrentRenderer = std::make_unique<GPU3D::SoftRenderer>();
-        GPU3D::CurrentRenderer->Init();
     }
 
     Renderer = renderer;
@@ -423,12 +425,12 @@ void InitRenderer(int renderer)
 
 void DeInitRenderer()
 {
-    GPU3D::CurrentRenderer->DeInit();
+    // Delete the 3D renderer, if it exists
+    GPU3D::CurrentRenderer.reset();
+
 #ifdef OGLRENDERER_ENABLED
-    if (Renderer == 1)
-    {
-        CurGLCompositor->DeInit();
-    }
+    // Delete the compositor, if one exists
+    CurGLCompositor.reset();
 #endif
 }
 
diff --git a/src/GPU3D.h b/src/GPU3D.h
index f229e66..23ec5a8 100644
--- a/src/GPU3D.h
+++ b/src/GPU3D.h
@@ -137,14 +137,11 @@ void Write32(u32 addr, u32 val);
 class Renderer3D
 {
 public:
-    Renderer3D(bool Accelerated);
-    virtual ~Renderer3D() {};
+    virtual ~Renderer3D() = default;
 
     Renderer3D(const Renderer3D&) = delete;
     Renderer3D& operator=(const Renderer3D&) = delete;
 
-    virtual bool Init() = 0;
-    virtual void DeInit() = 0;
     virtual void Reset() = 0;
 
     // This "Accelerated" flag currently communicates if the framebuffer should
@@ -159,9 +156,11 @@ public:
     virtual void RenderFrame() = 0;
     virtual void RestartFrame() {};
     virtual u32* GetLine(int line) = 0;
-
+    // from CSR patch
     virtual void SetupAccelFrame() {}
     virtual void PrepareCaptureFrame() {}
+protected:
+    Renderer3D(bool Accelerated);
 };
 
 extern int Renderer;
diff --git a/src/GPU3D_Compute.cpp b/src/GPU3D_Compute.cpp
index d497277..0e751c0 100644
--- a/src/GPU3D_Compute.cpp
+++ b/src/GPU3D_Compute.cpp
@@ -27,14 +27,12 @@
 namespace GPU3D
 {
 
-ComputeRenderer::ComputeRenderer()
-    : Renderer3D(true), Texcache(TexcacheOpenGLLoader())
-{}
-
-ComputeRenderer::~ComputeRenderer()
-{}
-
-
+ComputeRenderer::ComputeRenderer() noexcept : Renderer3D(true), Texcache(TexcacheOpenGLLoader())
+{
+    // ComputeRenderer::New() will be used to actually initialize the renderer;
+    // The various glDelete* functions silently ignore invalid IDs,
+    // so we can just let the destructor clean up a half-initialized renderer.
+}
 
 bool ComputeRenderer::CompileShader(GLuint& shader, const std::string& source, const std::initializer_list<const char*>& defines)
 {
@@ -67,8 +65,13 @@ void blah(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,con
     printf("%s\n", message);
 }
 
-bool ComputeRenderer::Init()
+std::unique_ptr<ComputeRenderer> ComputeRenderer::New() noexcept
 {
+    //assert(glEnable != nullptr);
+    // Will be returned if the initialization succeeds,
+    // or cleaned up via RAII if it fails.
+    std::unique_ptr<ComputeRenderer> result = std::unique_ptr<ComputeRenderer>(new ComputeRenderer());
+    
     //glDebugMessageCallback(blah, NULL);
     //glEnable(GL_DEBUG_OUTPUT);
     glGenBuffers(1, &YSpanSetupMemory);
@@ -115,10 +118,11 @@ bool ComputeRenderer::Init()
     return true;
 }
 
-void ComputeRenderer::DeInit()
+ComputeRenderer::~ComputeRenderer()
 {
     Texcache.Reset();
 
+    //assert(glDeleteBuffers != nullptr);
     glDeleteBuffers(1, &YSpanSetupMemory);
     glDeleteBuffers(1, &RenderPolygonMemory);
     glDeleteBuffers(1, &XSpanSetupMemory);
@@ -1037,4 +1041,4 @@ void ComputeRenderer::PrepareCaptureFrame()
     glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, nullptr);
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/GPU3D_Compute.h b/src/GPU3D_Compute.h
index 73f840b..950aba5 100644
--- a/src/GPU3D_Compute.h
+++ b/src/GPU3D_Compute.h
@@ -34,23 +34,25 @@ class ComputeRenderer : public Renderer3D
 {
 public:
     ComputeRenderer();
-    ~ComputeRenderer() override;
+    virtual ~ComputeRenderer() override;
+    virtual void Reset() override;
 
-    bool Init() override;
-    void DeInit() override;
-    void Reset() override;
+    virtual void SetRenderSettings(GPU::RenderSettings& settings) override;
 
-    void SetRenderSettings(GPU::RenderSettings& settings) override;
+    virtual void VCount144() override;
 
-    void VCount144() override;
+    virtual void RenderFrame() override;
+    virtual void RestartFrame() override;
+    virtual u32* GetLine(int line) override;
 
-    void RenderFrame() override;
-    void RestartFrame() override;
-    u32* GetLine(int line) override;
-
-    void SetupAccelFrame() override;
-    void PrepareCaptureFrame() override;
+    void SetupAccelFrame();
+    void PrepareCaptureFrame();
+    
+    static std::unique_ptr<ComputeRenderer> New() noexcept;
 private:
+    // Used by New()
+    ComputeRenderer() noexcept;
+    
     GLuint ShaderInterpXSpans[2];
     GLuint ShaderBinCombined;
     GLuint ShaderDepthBlend[2];
@@ -222,4 +224,4 @@ private:
 
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/GPU3D_OpenGL.cpp b/src/GPU3D_OpenGL.cpp
index c67d0f1..aa2ddac 100644
--- a/src/GPU3D_OpenGL.cpp
+++ b/src/GPU3D_OpenGL.cpp
@@ -18,6 +18,7 @@
 
 #include "GPU3D_OpenGL.h"
 
+#include <assert.h>
 #include <stdio.h>
 #include <string.h>
 #include "NDS.h"
@@ -84,14 +85,20 @@ void SetupDefaultTexParams(GLuint tex)
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 }
 
-GLRenderer::GLRenderer()
-    : Renderer3D(true)
+GLRenderer::GLRenderer() noexcept : Renderer3D(true)
 {
+    // GLRenderer::New() will be used to actually initialize the renderer;
+    // The various glDelete* functions silently ignore invalid IDs,
+    // so we can just let the destructor clean up a half-initialized renderer.
 }
 
-bool GLRenderer::Init()
+std::unique_ptr<GLRenderer> GLRenderer::New() noexcept
 {
-    GLint uni_id;
+    assert(glEnable != nullptr);
+
+    // Will be returned if the initialization succeeds,
+    // or cleaned up via RAII if it fails.
+    std::unique_ptr<GLRenderer> result = std::unique_ptr<GLRenderer>(new GLRenderer());
 
     glEnable(GL_DEPTH_TEST);
     glEnable(GL_STENCIL_TEST);
@@ -99,76 +106,94 @@ bool GLRenderer::Init()
     glDepthRange(0, 1);
     glClearDepth(1.0);
 
-    if (!OpenGL::CompileVertexFragmentProgram(ClearShaderPlain,
-            kClearVS, kClearFS,
-            "ClearShader",
-            {{"vPosition", 0}},
-            {{"oColor", 0}, {"oAttr", 1}}))
-        return false;
-
-    ClearUniformLoc[0] = glGetUniformLocation(ClearShaderPlain, "uColor");
-    ClearUniformLoc[1] = glGetUniformLocation(ClearShaderPlain, "uDepth");
-    ClearUniformLoc[2] = glGetUniformLocation(ClearShaderPlain, "uOpaquePolyID");
-    ClearUniformLoc[3] = glGetUniformLocation(ClearShaderPlain, "uFogFlag");
-
-    memset(RenderShader, 0, sizeof(RenderShader));
-
-    if (!BuildRenderShader(0,
-                           kRenderVS_Z, kRenderFS_ZO)) return false;
-    if (!BuildRenderShader(RenderFlag_WBuffer,
-                           kRenderVS_W, kRenderFS_WO)) return false;
-    if (!BuildRenderShader(RenderFlag_Edge,
-                           kRenderVS_Z, kRenderFS_ZE)) return false;
-    if (!BuildRenderShader(RenderFlag_Edge | RenderFlag_WBuffer,
-                           kRenderVS_W, kRenderFS_WE)) return false;
-    if (!BuildRenderShader(RenderFlag_Trans,
-                           kRenderVS_Z, kRenderFS_ZT)) return false;
-    if (!BuildRenderShader(RenderFlag_Trans | RenderFlag_WBuffer,
-                           kRenderVS_W, kRenderFS_WT)) return false;
-    if (!BuildRenderShader(RenderFlag_ShadowMask,
-                           kRenderVS_Z, kRenderFS_ZSM)) return false;
-    if (!BuildRenderShader(RenderFlag_ShadowMask | RenderFlag_WBuffer,
-                           kRenderVS_W, kRenderFS_WSM)) return false;
-
-    if (!OpenGL::CompileVertexFragmentProgram(FinalPassEdgeShader,
-            kFinalPassVS, kFinalPassEdgeFS,
-            "FinalPassEdgeShader",
-            {{"vPosition", 0}},
-            {{"oColor", 0}}))
-        return false;
-    if (!OpenGL::CompileVertexFragmentProgram(FinalPassFogShader,
-            kFinalPassVS, kFinalPassFogFS,
-            "FinalPassFogShader",
-            {{"vPosition", 0}},
-            {{"oColor", 0}}))
-        return false;
-
-    uni_id = glGetUniformBlockIndex(FinalPassEdgeShader, "uConfig");
-    glUniformBlockBinding(FinalPassEdgeShader, uni_id, 0);
-
-    glUseProgram(FinalPassEdgeShader);
-    uni_id = glGetUniformLocation(FinalPassEdgeShader, "DepthBuffer");
+
+    if (!OpenGL::BuildShaderProgram(kClearVS, kClearFS, result->ClearShaderPlain, "ClearShader"))
+        return nullptr;
+
+    glBindAttribLocation(result->ClearShaderPlain[2], 0, "vPosition");
+    glBindFragDataLocation(result->ClearShaderPlain[2], 0, "oColor");
+    glBindFragDataLocation(result->ClearShaderPlain[2], 1, "oAttr");
+
+    if (!OpenGL::LinkShaderProgram(result->ClearShaderPlain))
+        return nullptr;
+
+    result->ClearUniformLoc[0] = glGetUniformLocation(result->ClearShaderPlain[2], "uColor");
+    result->ClearUniformLoc[1] = glGetUniformLocation(result->ClearShaderPlain[2], "uDepth");
+    result->ClearUniformLoc[2] = glGetUniformLocation(result->ClearShaderPlain[2], "uOpaquePolyID");
+    result->ClearUniformLoc[3] = glGetUniformLocation(result->ClearShaderPlain[2], "uFogFlag");
+
+    memset(result->RenderShader, 0, sizeof(RenderShader));
+
+    if (!result->BuildRenderShader(0, kRenderVS_Z, kRenderFS_ZO))
+        return nullptr;
+
+    if (!result->BuildRenderShader(RenderFlag_WBuffer, kRenderVS_W, kRenderFS_WO))
+        return nullptr;
+
+    if (!result->BuildRenderShader(RenderFlag_Edge, kRenderVS_Z, kRenderFS_ZE))
+        return nullptr;
+
+    if (!result->BuildRenderShader(RenderFlag_Edge | RenderFlag_WBuffer, kRenderVS_W, kRenderFS_WE))
+        return nullptr;
+
+    if (!result->BuildRenderShader(RenderFlag_Trans, kRenderVS_Z, kRenderFS_ZT))
+        return nullptr;
+
+    if (!result->BuildRenderShader(RenderFlag_Trans | RenderFlag_WBuffer, kRenderVS_W, kRenderFS_WT))
+        return nullptr;
+
+    if (!result->BuildRenderShader(RenderFlag_ShadowMask, kRenderVS_Z, kRenderFS_ZSM))
+        return nullptr;
+
+    if (!result->BuildRenderShader(RenderFlag_ShadowMask | RenderFlag_WBuffer, kRenderVS_W, kRenderFS_WSM))
+        return nullptr;
+
+    if (!OpenGL::BuildShaderProgram(kFinalPassVS, kFinalPassEdgeFS, result->FinalPassEdgeShader, "FinalPassEdgeShader"))
+        return nullptr;
+
+    if (!OpenGL::BuildShaderProgram(kFinalPassVS, kFinalPassFogFS, result->FinalPassFogShader, "FinalPassFogShader"))
+        return nullptr;
+
+    glBindAttribLocation(result->FinalPassEdgeShader[2], 0, "vPosition");
+    glBindFragDataLocation(result->FinalPassEdgeShader[2], 0, "oColor");
+
+    if (!OpenGL::LinkShaderProgram(result->FinalPassEdgeShader))
+        return nullptr;
+
+    GLint uni_id = glGetUniformBlockIndex(result->FinalPassEdgeShader[2], "uConfig");
+    glUniformBlockBinding(result->FinalPassEdgeShader[2], uni_id, 0);
+
+    glUseProgram(result->FinalPassEdgeShader[2]);
+
+    uni_id = glGetUniformLocation(result->FinalPassEdgeShader[2], "DepthBuffer");
     glUniform1i(uni_id, 0);
-    uni_id = glGetUniformLocation(FinalPassEdgeShader, "AttrBuffer");
+    uni_id = glGetUniformLocation(result->FinalPassEdgeShader[2], "AttrBuffer");
     glUniform1i(uni_id, 1);
 
-    uni_id = glGetUniformBlockIndex(FinalPassFogShader, "uConfig");
-    glUniformBlockBinding(FinalPassFogShader, uni_id, 0);
+    glBindAttribLocation(result->FinalPassFogShader[2], 0, "vPosition");
+    glBindFragDataLocation(result->FinalPassFogShader[2], 0, "oColor");
+
+    if (!OpenGL::LinkShaderProgram(result->FinalPassFogShader))
+        return nullptr;
+
+    uni_id = glGetUniformBlockIndex(result->FinalPassFogShader[2], "uConfig");
+    glUniformBlockBinding(result->FinalPassFogShader[2], uni_id, 0);
+
+    glUseProgram(result->FinalPassFogShader[2]);
 
-    glUseProgram(FinalPassFogShader);
-    uni_id = glGetUniformLocation(FinalPassFogShader, "DepthBuffer");
+    uni_id = glGetUniformLocation(result->FinalPassFogShader[2], "DepthBuffer");
     glUniform1i(uni_id, 0);
-    uni_id = glGetUniformLocation(FinalPassFogShader, "AttrBuffer");
+    uni_id = glGetUniformLocation(result->FinalPassFogShader[2], "AttrBuffer");
     glUniform1i(uni_id, 1);
 
 
-    memset(&ShaderConfig, 0, sizeof(ShaderConfig));
+    memset(&result->ShaderConfig, 0, sizeof(ShaderConfig));
 
-    glGenBuffers(1, &ShaderConfigUBO);
-    glBindBuffer(GL_UNIFORM_BUFFER, ShaderConfigUBO);
-    static_assert((sizeof(ShaderConfig) & 15) == 0, "");
-    glBufferData(GL_UNIFORM_BUFFER, sizeof(ShaderConfig), &ShaderConfig, GL_STATIC_DRAW);
-    glBindBufferBase(GL_UNIFORM_BUFFER, 0, ShaderConfigUBO);
+    glGenBuffers(1, &result->ShaderConfigUBO);
+    glBindBuffer(GL_UNIFORM_BUFFER, result->ShaderConfigUBO);
+    static_assert((sizeof(ShaderConfig) & 15) == 0);
+    glBufferData(GL_UNIFORM_BUFFER, sizeof(ShaderConfig), &result->ShaderConfig, GL_STATIC_DRAW);
+    glBindBufferBase(GL_UNIFORM_BUFFER, 0, result->ShaderConfigUBO);
 
 
     float clearvtx[6*2] =
@@ -182,22 +207,22 @@ bool GLRenderer::Init()
         1.0, 1.0
     };
 
-    glGenBuffers(1, &ClearVertexBufferID);
-    glBindBuffer(GL_ARRAY_BUFFER, ClearVertexBufferID);
+    glGenBuffers(1, &result->ClearVertexBufferID);
+    glBindBuffer(GL_ARRAY_BUFFER, result->ClearVertexBufferID);
     glBufferData(GL_ARRAY_BUFFER, sizeof(clearvtx), clearvtx, GL_STATIC_DRAW);
 
-    glGenVertexArrays(1, &ClearVertexArrayID);
-    glBindVertexArray(ClearVertexArrayID);
+    glGenVertexArrays(1, &result->ClearVertexArrayID);
+    glBindVertexArray(result->ClearVertexArrayID);
     glEnableVertexAttribArray(0); // position
     glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)(0));
 
 
-    glGenBuffers(1, &VertexBufferID);
-    glBindBuffer(GL_ARRAY_BUFFER, VertexBufferID);
-    glBufferData(GL_ARRAY_BUFFER, sizeof(VertexBuffer), NULL, GL_DYNAMIC_DRAW);
+    glGenBuffers(1, &result->VertexBufferID);
+    glBindBuffer(GL_ARRAY_BUFFER, result->VertexBufferID);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(VertexBuffer), nullptr, GL_DYNAMIC_DRAW);
 
-    glGenVertexArrays(1, &VertexArrayID);
-    glBindVertexArray(VertexArrayID);
+    glGenVertexArrays(1, &result->VertexArrayID);
+    glBindVertexArray(result->VertexArrayID);
     glEnableVertexAttribArray(0); // position
     glVertexAttribIPointer(0, 4, GL_UNSIGNED_SHORT, 7*4, (void*)(0));
     glEnableVertexAttribArray(1); // color
@@ -207,40 +232,43 @@ bool GLRenderer::Init()
     glEnableVertexAttribArray(3); // attrib
     glVertexAttribIPointer(3, 3, GL_UNSIGNED_INT, 7*4, (void*)(4*4));
 
-    glGenBuffers(1, &IndexBufferID);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndexBufferID);
-    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(IndexBuffer), NULL, GL_DYNAMIC_DRAW);
+    glGenBuffers(1, &result->IndexBufferID);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, result->IndexBufferID);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(IndexBuffer), nullptr, GL_DYNAMIC_DRAW);
 
-    glGenFramebuffers(1, &MainFramebuffer);
+    glGenFramebuffers(4, &result->FramebufferID[0]);
+    glBindFramebuffer(GL_FRAMEBUFFER, result->FramebufferID[0]);
+
+    glGenTextures(8, &result->FramebufferTex[0]);
+    result->FrontBuffer = 0;
 
     // color buffers
-    glGenTextures(1, &ColorBufferTex);
-    SetupDefaultTexParams(ColorBufferTex);
+    SetupDefaultTexParams(result->FramebufferTex[0]);
+    SetupDefaultTexParams(result->FramebufferTex[1]);
 
     // depth/stencil buffer
-    glGenTextures(1, &DepthBufferTex);
-    SetupDefaultTexParams(DepthBufferTex);
+    SetupDefaultTexParams(result->FramebufferTex[4]);
+    SetupDefaultTexParams(result->FramebufferTex[6]);
 
     // attribute buffer
     // R: opaque polyID (for edgemarking)
     // G: edge flag
     // B: fog flag
-    glGenTextures(1, &AttrBufferTex);
-    SetupDefaultTexParams(AttrBufferTex);
+    SetupDefaultTexParams(result->FramebufferTex[5]);
+    SetupDefaultTexParams(result->FramebufferTex[7]);
 
     // downscale framebuffer for display capture (always 256x192)
-    glGenTextures(1, &DownScaleBufferTex);
-    SetupDefaultTexParams(DownScaleBufferTex);
+    SetupDefaultTexParams(result->FramebufferTex[3]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 192, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 
     glEnable(GL_BLEND);
     glBlendEquationSeparate(GL_FUNC_ADD, GL_MAX);
 
-    glGenBuffers(1, &PixelbufferID);
+    glGenBuffers(1, &result->PixelbufferID);
 
     glActiveTexture(GL_TEXTURE0);
-    glGenTextures(1, &TexMemID);
-    glBindTexture(GL_TEXTURE_2D, TexMemID);
+    glGenTextures(1, &result->TexMemID);
+    glBindTexture(GL_TEXTURE_2D, result->TexMemID);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
@@ -248,8 +276,8 @@ bool GLRenderer::Init()
     glTexImage2D(GL_TEXTURE_2D, 0, GL_R8UI, 1024, 512, 0, GL_RED_INTEGER, GL_UNSIGNED_BYTE, NULL);
 
     glActiveTexture(GL_TEXTURE1);
-    glGenTextures(1, &TexPalMemID);
-    glBindTexture(GL_TEXTURE_2D, TexPalMemID);
+    glGenTextures(1, &result->TexPalMemID);
+    glBindTexture(GL_TEXTURE_2D, result->TexPalMemID);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
@@ -258,11 +286,13 @@ bool GLRenderer::Init()
 
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
-    return true;
+    return result;
 }
 
-void GLRenderer::DeInit()
+GLRenderer::~GLRenderer()
 {
+    assert(glDeleteTextures != nullptr);
+
     glDeleteTextures(1, &TexMemID);
     glDeleteTextures(1, &TexPalMemID);
 
diff --git a/src/GPU3D_OpenGL.h b/src/GPU3D_OpenGL.h
index 21f815c..27451f0 100644
--- a/src/GPU3D_OpenGL.h
+++ b/src/GPU3D_OpenGL.h
@@ -28,10 +28,7 @@ namespace GPU3D
 class GLRenderer : public Renderer3D
 {
 public:
-    GLRenderer();
-    virtual ~GLRenderer() override {};
-    virtual bool Init() override;
-    virtual void DeInit() override;
+    virtual ~GLRenderer() override;
     virtual void Reset() override;
 
     virtual void SetRenderSettings(GPU::RenderSettings& settings) override;
@@ -40,9 +37,13 @@ public:
     virtual void RenderFrame() override;
     virtual u32* GetLine(int line) override;
 
-    void SetupAccelFrame() override;
-    void PrepareCaptureFrame() override;
+    void SetupAccelFrame();
+    void PrepareCaptureFrame();
+
+    static std::unique_ptr<GLRenderer> New() noexcept;
 private:
+    // Used by New()
+    GLRenderer() noexcept;
 
     // GL version requirements
     // * texelFetch: 3.0 (GLSL 1.30)     (3.2/1.50 for MS)
@@ -62,7 +63,7 @@ private:
         u32 RenderKey;
     };
 
-    RendererPolygon PolygonList[2048];
+    RendererPolygon PolygonList[2048] {};
 
     bool BuildRenderShader(u32 flags, const std::string& vs, const std::string& fs);
     void UseRenderShader(u32 flags);
@@ -83,13 +84,13 @@ private:
     };
 
 
-    GLuint ClearShaderPlain;
+    GLuint ClearShaderPlain[3] {};
 
-    GLuint RenderShader[16];
+    GLuint RenderShader[16][3] {};
     GLuint CurShaderID = -1;
 
-    GLuint FinalPassEdgeShader;
-    GLuint FinalPassFogShader;
+    GLuint FinalPassEdgeShader[3] {};
+    GLuint FinalPassFogShader[3] {};
 
     // std140 compliant structure
     struct
@@ -104,13 +105,13 @@ private:
         u32 uFogOffset;             // int        304 / 1
         u32 uFogShift;              // int        305 / 1
         u32 _pad1[2];               // int        306 / 2
-    } ShaderConfig;
+    } ShaderConfig {};
 
-    GLuint ShaderConfigUBO;
-    int NumFinalPolys, NumOpaqueFinalPolys;
+    GLuint ShaderConfigUBO {};
+    int NumFinalPolys {}, NumOpaqueFinalPolys {};
 
-    GLuint ClearVertexBufferID, ClearVertexArrayID;
-    GLint ClearUniformLoc[4];
+    GLuint ClearVertexBufferID = 0, ClearVertexArrayID {};
+    GLint ClearUniformLoc[4] {};
 
     // vertex buffer
     // * XYZW: 4x16bit
@@ -124,29 +125,35 @@ private:
     // * bit8: front-facing (?)
     // * bit9: W-buffering (?)
 
-    GLuint VertexBufferID;
-    u32 VertexBuffer[10240 * 7];
-    u32 NumVertices;
+    GLuint VertexBufferID {};
+    u32 VertexBuffer[10240 * 7] {};
+    u32 NumVertices {};
 
-    GLuint VertexArrayID;
-    GLuint IndexBufferID;
-    u16 IndexBuffer[2048 * 40];
-    u32 NumIndices, NumEdgeIndices;
+    GLuint VertexArrayID {};
+    GLuint IndexBufferID {};
+    u16 IndexBuffer[2048 * 40] {};
+    u32 NumIndices {}, NumEdgeIndices {};
 
     const u32 EdgeIndicesOffset = 2048 * 30;
 
-    GLuint TexMemID;
-    GLuint TexPalMemID;
+    GLuint TexMemID {};
+    GLuint TexPalMemID {};
+
+    int ScaleFactor {};
+    bool BetterPolygons {};
+    int ScreenW {}, ScreenH {};
+
+    // from CSR patch
+    GLuint ColorBufferTex {}, DepthBufferTex {}, AttrBufferTex {};
+    GLuint DownScaleBufferTex {};
+    GLuint MainFramebuffer {}, DownscaleFramebuffer {};
 
-    int ScaleFactor;
-    bool BetterPolygons;
-    int ScreenW, ScreenH;
+    // new crap
+    GLuint FramebufferTex[8] {};
+    int FrontBuffer {};
+    GLuint FramebufferID[4] {}, PixelbufferID {};
+    u32 Framebuffer[256*192] {};
 
-    GLuint ColorBufferTex, DepthBufferTex, AttrBufferTex;
-    GLuint DownScaleBufferTex;
-    GLuint PixelbufferID;
 
-    GLuint MainFramebuffer, DownscaleFramebuffer;
-    u32 Framebuffer[256*192];
 };
-}
\ No newline at end of file
+}
diff --git a/src/GPU3D_Soft.cpp b/src/GPU3D_Soft.cpp
index 98514ab..f7078b5 100644
--- a/src/GPU3D_Soft.cpp
+++ b/src/GPU3D_Soft.cpp
@@ -71,13 +71,8 @@ void SoftRenderer::SetupRenderThread()
 }
 
 
-SoftRenderer::SoftRenderer()
+SoftRenderer::SoftRenderer() noexcept
     : Renderer3D(false)
-{
-
-}
-
-bool SoftRenderer::Init()
 {
     Sema_RenderStart = Platform::Semaphore_Create();
     Sema_RenderDone = Platform::Semaphore_Create();
@@ -86,11 +81,9 @@ bool SoftRenderer::Init()
     Threaded = false;
     RenderThreadRunning = false;
     RenderThreadRendering = false;
-
-    return true;
 }
 
-void SoftRenderer::DeInit()
+SoftRenderer::~SoftRenderer()
 {
     StopRenderThread();
 
diff --git a/src/GPU3D_Soft.h b/src/GPU3D_Soft.h
index 0c6ca43..948832f 100644
--- a/src/GPU3D_Soft.h
+++ b/src/GPU3D_Soft.h
@@ -28,10 +28,8 @@ namespace GPU3D
 class SoftRenderer : public Renderer3D
 {
 public:
-    SoftRenderer();
-    virtual ~SoftRenderer() override {};
-    virtual bool Init() override;
-    virtual void DeInit() override;
+    SoftRenderer() noexcept;
+    virtual ~SoftRenderer() override;
     virtual void Reset() override;
 
     virtual void SetRenderSettings(GPU::RenderSettings& settings) override;
diff --git a/src/GPU_OpenGL.cpp b/src/GPU_OpenGL.cpp
index 55c2c7c..5dd0267 100644
--- a/src/GPU_OpenGL.cpp
+++ b/src/GPU_OpenGL.cpp
@@ -18,6 +18,7 @@
 
 #include "GPU_OpenGL.h"
 
+#include <assert.h>
 #include <cstdio>
 #include <cstring>
 
@@ -32,30 +33,36 @@ namespace GPU
 
 using namespace OpenGL;
 
-bool GLCompositor::Init()
+std::unique_ptr<GLCompositor> GLCompositor::New() noexcept
 {
-    if (!OpenGL::CompileVertexFragmentProgram(CompShader[0],
-            kCompositorVS, kCompositorFS_Nearest, 
-            "CompositorShader",
-            {{"vPosition", 0}, {"vTexcoord", 1}},
-            {{"oColor", 0}}))
-    //if (!OpenGL::BuildShaderProgram(kCompositorVS, kCompositorFS_Linear, CompShader[0], "CompositorShader"))
-    //if (!OpenGL::BuildShaderProgram(kCompositorVS_xBRZ, kCompositorFS_xBRZ, CompShader[0], "CompositorShader"))
-        return false;
-
-    for (int i = 0; i < 1; i++)
-    {
-        GLint uni_id;
+    assert(glBindAttribLocation != nullptr);
 
-        CompScaleLoc[i] = glGetUniformLocation(CompShader[i], "u3DScale");
-        Comp3DXPosLoc[i] = glGetUniformLocation(CompShader[i], "u3DXPos");
+    std::array<GLuint, 3> CompShader {};
+    if (!OpenGL::BuildShaderProgram(kCompositorVS, kCompositorFS_Nearest, &CompShader[0], "CompositorShader"))
+        return nullptr;
 
-        glUseProgram(CompShader[i]);
-        uni_id = glGetUniformLocation(CompShader[i], "ScreenTex");
-        glUniform1i(uni_id, 0);
-        uni_id = glGetUniformLocation(CompShader[i], "_3DTex");
-        glUniform1i(uni_id, 1);
-    }
+    glBindAttribLocation(CompShader[2], 0, "vPosition");
+    glBindAttribLocation(CompShader[2], 1, "vTexcoord");
+    glBindFragDataLocation(CompShader[2], 0, "oColor");
+
+    if (!OpenGL::LinkShaderProgram(CompShader.data()))
+        // OpenGL::LinkShaderProgram already deletes the shader program object
+        // if linking the shaders together failed.
+        return nullptr;
+
+    return std::unique_ptr<GLCompositor>(new GLCompositor(CompShader));
+}
+
+GLCompositor::GLCompositor(std::array<GLuint, 3> compShader) noexcept : CompShader(compShader)
+{
+    CompScaleLoc = glGetUniformLocation(CompShader[2], "u3DScale");
+    Comp3DXPosLoc = glGetUniformLocation(CompShader[2], "u3DXPos");
+
+    glUseProgram(CompShader[2]);
+    GLuint screenTextureUniform = glGetUniformLocation(CompShader[2], "ScreenTex");
+    glUniform1i(screenTextureUniform, 0);
+    GLuint _3dTextureUniform = glGetUniformLocation(CompShader[2], "_3DTex");
+    glUniform1i(_3dTextureUniform, 1);
 
     // all this mess is to prevent bleeding
 #define SETVERTEX(i, x, y, offset) \
@@ -116,12 +123,12 @@ bool GLCompositor::Init()
     }
 
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
-
-    return true;
 }
 
-void GLCompositor::DeInit()
+GLCompositor::~GLCompositor()
 {
+    assert(glDeleteFramebuffers != nullptr);
+
     glDeleteFramebuffers(2, CompScreenOutputFB);
     glDeleteTextures(1, &CompScreenInputTex);
     glDeleteTextures(2, CompScreenOutputTex);
@@ -129,8 +136,7 @@ void GLCompositor::DeInit()
     glDeleteVertexArrays(1, &CompVertexArrayID);
     glDeleteBuffers(1, &CompVertexBufferID);
 
-    for (int i = 0; i < 1; i++)
-        glDeleteProgram(CompShader[i]);
+    OpenGL::DeleteShaderProgram(CompShader.data());
 }
 
 void GLCompositor::Reset()
@@ -194,11 +200,11 @@ void GLCompositor::RenderFrame()
     glClear(GL_COLOR_BUFFER_BIT);
 
     // TODO: select more shaders (filtering, etc)
-    glUseProgram(CompShader[0]);
-    glUniform1ui(CompScaleLoc[0], Scale);
+    OpenGL::UseShaderProgram(CompShader.data());
+    glUniform1ui(CompScaleLoc, Scale);
 
     // TODO: support setting this midframe, if ever needed
-    glUniform1i(Comp3DXPosLoc[0], ((int)GPU3D::RenderXPos << 23) >> 23);
+    glUniform1i(Comp3DXPosLoc, ((int)GPU3D::RenderXPos << 23) >> 23);
 
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, CompScreenInputTex);
diff --git a/src/GPU_OpenGL.h b/src/GPU_OpenGL.h
index 165dd7c..e97afb7 100644
--- a/src/GPU_OpenGL.h
+++ b/src/GPU_OpenGL.h
@@ -20,6 +20,9 @@
 
 #include "OpenGLSupport.h"
 
+#include <array>
+#include <memory>
+
 namespace GPU
 {
 
@@ -28,12 +31,11 @@ struct RenderSettings;
 class GLCompositor
 {
 public:
-    GLCompositor() = default;
+    static std::unique_ptr<GLCompositor> New() noexcept;
     GLCompositor(const GLCompositor&) = delete;
     GLCompositor& operator=(const GLCompositor&) = delete;
+    ~GLCompositor();
 
-    bool Init();
-    void DeInit();
     void Reset();
 
     void SetRenderSettings(RenderSettings& settings);
@@ -42,13 +44,14 @@ public:
     void RenderFrame();
     void BindOutputTexture(int buf);
 private:
+    GLCompositor(std::array<GLuint, 3> CompShader) noexcept;
 
     int Scale;
     int ScreenH, ScreenW;
 
-    GLuint CompShader[1];
-    GLuint CompScaleLoc[1];
-    GLuint Comp3DXPosLoc[1];
+    std::array<GLuint, 3> CompShader;
+    GLuint CompScaleLoc;
+    GLuint Comp3DXPosLoc;
 
     GLuint CompVertexBufferID;
     GLuint CompVertexArrayID;
@@ -65,4 +68,4 @@ private:
     GLuint CompScreenOutputFB[2];
 };
 
-}
\ No newline at end of file
+}
diff --git a/src/NDS.cpp b/src/NDS.cpp
index 2c24c65..63f0b35 100644
--- a/src/NDS.cpp
+++ b/src/NDS.cpp
@@ -227,10 +227,16 @@ void DeInit()
 #endif
 
     delete ARM9;
+    ARM9 = nullptr;
+
     delete ARM7;
+    ARM7 = nullptr;
 
     for (int i = 0; i < 8; i++)
+    {
         delete DMAs[i];
+        DMAs[i] = nullptr;
+    }
 
     NDSCart::DeInit();
     GBACart::DeInit();
diff --git a/src/OpenGLSupport.cpp b/src/OpenGLSupport.cpp
index 7130c7d..8f90f4e 100644
--- a/src/OpenGLSupport.cpp
+++ b/src/OpenGLSupport.cpp
@@ -187,10 +187,16 @@ bool CompilerShader(GLuint& id, const std::string& source, const std::string& na
 {
     int res;
 
-    const char* sourceC = source.c_str();
-    int len = source.length();
-    glShaderSource(id, 1, &sourceC, &len);
-    glCompileShader(id);
+    if (!glCreateShader)
+    {
+        Log(LogLevel::Error, "OpenGL: Cannot build shader program, OpenGL hasn't been loaded\n");
+        return false;
+    }
+
+    ids[0] = glCreateShader(GL_VERTEX_SHADER);
+    len = strlen(vs);
+    glShaderSource(ids[0], 1, &vs, &len);
+    glCompileShader(ids[0]);
 
     glGetShaderiv(id, GL_COMPILE_STATUS, &res);
     if (res != GL_TRUE)
diff --git a/src/SPI.cpp b/src/SPI.cpp
index bbfacbf..3c44964 100644
--- a/src/SPI.cpp
+++ b/src/SPI.cpp
@@ -91,6 +91,7 @@ bool Init()
 void DeInit()
 {
     if (Firmware) delete[] Firmware;
+    Firmware = nullptr;
 }
 
 u32 FixFirmwareLength(u32 originalLength)
diff --git a/src/SPU.cpp b/src/SPU.cpp
index 734590e..e83a0c7 100644
--- a/src/SPU.cpp
+++ b/src/SPU.cpp
@@ -135,12 +135,18 @@ bool Init()
 void DeInit()
 {
     for (int i = 0; i < 16; i++)
+    {
         delete Channels[i];
+        Channels[i] = nullptr;
+    }
 
     delete Capture[0];
     delete Capture[1];
+    Capture[0] = nullptr;
+    Capture[1] = nullptr;
 
     Platform::Mutex_Free(AudioLock);
+    AudioLock = nullptr;
 }
 
 void Reset()
diff --git a/src/frontend/qt_sdl/AudioInOut.cpp b/src/frontend/qt_sdl/AudioInOut.cpp
index d44e92d..48e8a86 100644
--- a/src/frontend/qt_sdl/AudioInOut.cpp
+++ b/src/frontend/qt_sdl/AudioInOut.cpp
@@ -334,12 +334,17 @@ void Init()
 void DeInit()
 {
     if (audioDevice) SDL_CloseAudioDevice(audioDevice);
+    audioDevice = 0;
     MicClose();
 
-    SDL_DestroyCond(audioSync);
-    SDL_DestroyMutex(audioSyncLock);
+    if (audioSync) SDL_DestroyCond(audioSync);
+    audioSync = nullptr;
+
+    if (audioSyncLock) SDL_DestroyMutex(audioSyncLock);
+    audioSyncLock = nullptr;
 
     if (micWavBuffer) delete[] micWavBuffer;
+    micWavBuffer = nullptr;
 }
 
 void AudioSync()
diff --git a/src/frontend/qt_sdl/LocalMP.cpp b/src/frontend/qt_sdl/LocalMP.cpp
index 31801b7..870ea8b 100644
--- a/src/frontend/qt_sdl/LocalMP.cpp
+++ b/src/frontend/qt_sdl/LocalMP.cpp
@@ -297,16 +297,21 @@ bool Init()
 
 void DeInit()
 {
-    MPQueue->lock();
-    MPQueueHeader* header = (MPQueueHeader*)MPQueue->data();
-    header->ConnectedBitmask &= ~(1 << InstanceID);
-    header->InstanceBitmask &= ~(1 << InstanceID);
-    header->NumInstances--;
-    MPQueue->unlock();
+    if (MPQueue)
+    {
+        MPQueue->lock();
+        MPQueueHeader* header = (MPQueueHeader*)MPQueue->data();
+        header->ConnectedBitmask &= ~(1 << InstanceID);
+        header->InstanceBitmask &= ~(1 << InstanceID);
+        header->NumInstances--;
+        MPQueue->unlock();
 
-    SemPoolDeinit();
+        SemPoolDeinit();
+
+        MPQueue->detach();
+    }
 
-    MPQueue->detach();
+    MPQueue = nullptr;
     delete MPQueue;
 }

Places

File melonds_compute-shader-renderer_brokenHEAD.patch of Package melonds (Revision 7ca5d881ec794a7407960d48f0a38550)

Places