File melonds_compute-shader-renderer.patch of Package melonds

Overview Repositories Revisions Requests Users Attributes Meta

File melonds_compute-shader-renderer.patch of Package melonds (Revision 74e33aa9718c16ff82ce093e7db785b8)

Currently displaying revision 74e33aa9718c16ff82ce093e7db785b8 , Show latest

From 18e5687c846f085f3ebdfd6c51202504857095c9 Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Sat, 8 Apr 2023 01:37:32 +0200
Subject: [PATCH 01/20] nothing works yet

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 7f915aded..ec07aa770 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -63,6 +63,7 @@ if (ENABLE_OGLRENDERER)
         GPU_OpenGL.cpp
         GPU_OpenGL_shaders.h
         GPU3D_OpenGL.cpp
+        GPU3D_Compute.cpp
         GPU3D_OpenGL_shaders.h
         OpenGLSupport.cpp)
 
diff --git a/src/GPU.cpp b/src/GPU.cpp
index f51748b67..23db96696 100644
--- a/src/GPU.cpp
+++ b/src/GPU.cpp
@@ -397,7 +397,7 @@ void InitRenderer(int renderer)
             GPU3D::CurrentRenderer = std::make_unique<GPU3D::SoftRenderer>();
             GPU3D::CurrentRenderer->Init();
         }
-        GPU3D::CurrentRenderer = std::make_unique<GPU3D::GLRenderer>();
+        GPU3D::CurrentRenderer = std::make_unique<GPU3D::ComputeRenderer>();
         if (!GPU3D::CurrentRenderer->Init())
         {
             // Fallback on software renderer
diff --git a/src/GPU3D.h b/src/GPU3D.h
index 4a7bfdc6c..a78240120 100644
--- a/src/GPU3D.h
+++ b/src/GPU3D.h
@@ -170,6 +170,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 000000000..de8b33936
--- /dev/null
+++ b/src/GPU3D_Compute.cpp
@@ -0,0 +1,1451 @@
+/*
+    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>
+
+#define XXH_STATIC_LINKING_ONLY
+#include "xxhash/xxhash.h"
+
+#include "OpenGLSupport.h"
+
+#include "GPU3D_Compute_shaders.h"
+
+namespace GPU3D
+{
+
+ComputeRenderer::ComputeRenderer()
+    : Renderer3D(true)
+{}
+
+ComputeRenderer::~ComputeRenderer()
+{}
+
+
+
+bool ComputeRenderer::CompileShader(GLuint& shader, const char* 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 += 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, &TileMemory);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, TileMemory);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(Tiles), nullptr, GL_DYNAMIC_DRAW);
+
+    glGenBuffers(1, &XSpanSetupMemory);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, XSpanSetupMemory);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(SpanSetupX)*MaxYSpanIndices, nullptr, GL_DYNAMIC_DRAW);
+
+    glGenBuffers(1, &BinResultMemory);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, BinResultMemory);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(BinResult), nullptr, GL_DYNAMIC_DRAW);
+
+    glGenBuffers(1, &FinalTileMemory);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, FinalTileMemory);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(FinalTiles), nullptr, GL_DYNAMIC_DRAW);
+
+    glGenBuffers(1, &YSpanIndicesTextureMemory);
+    glBindBuffer(GL_TEXTURE_BUFFER, YSpanIndicesTextureMemory);
+    glBufferData(GL_TEXTURE_BUFFER, MaxYSpanIndices*2*4, nullptr, GL_DYNAMIC_DRAW);
+
+    glGenTextures(1, &YSpanIndicesTexture);
+    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"});
+
+    return true;
+}
+
+void ComputeRenderer::DeInit()
+{
+
+}
+
+void ComputeRenderer::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++)
+                Gfx::TextureHeap->Free(TexArrays[i][j][k].Memory);
+            TexArrays[i][j].clear();
+            FreeTextures[i][j].clear();
+        }
+    }*/
+    TexCache.clear();
+
+    FreeImageDescriptorsCount = TexCacheMaxImages;
+    for (int i = 0; i < TexCacheMaxImages; i++)
+    {
+        FreeImageDescriptors[i] = i;
+    }
+}
+
+void ComputeRenderer::SetRenderSettings(GPU::RenderSettings& settings)
+{
+
+}
+
+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(SpanSetupY* span, Polygon* poly, int vertex, int side)
+{
+    s32 x0 = poly->Vertices[vertex]->FinalPosition[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 = poly->Vertices[vertex]->FinalPosition[1];
+
+    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(int polynum, SpanSetupY* span, Polygon* poly, int from, int to, u32 y, int side)
+{
+    span->X0 = poly->Vertices[from]->FinalPosition[0];
+    span->X1 = poly->Vertices[to]->FinalPosition[0];
+    span->Y0 = poly->Vertices[from]->FinalPosition[1];
+    span->Y1 = poly->Vertices[to]->FinalPosition[1];
+
+    SetupAttrs(span, poly, from, to);
+
+    bool negative = false;
+    if (span->X1 > span->X0)
+    {
+        span->XMin = span->X0;
+        span->XMax = span->X1-1;
+    }
+    else if (span->X1 < span->X0)
+    {
+        span->XMin = span->X1;
+        span->XMax = span->X0-1;
+        negative = true;
+    }
+    else
+    {
+        span->XMin = span->X0;
+        if (side) span->XMin--;
+        span->XMax = span->XMin;
+    }
+
+    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->I1 < span->I0)
+    //    std::swap(span->I0, span->I1);
+
+    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;
+    }
+}
+
+inline u32 TextureWidth(u32 texparam)
+{
+    return 8 << ((texparam >> 20) & 0x7);
+}
+
+inline u32 TextureHeight(u32 texparam)
+{
+    return 8 << ((texparam >> 23) & 0x7);
+}
+
+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 void RGB5ToRGB6(uint8x16_t lo, uint8x16_t hi, uint8x16_t& red, uint8x16_t& green, uint8x16_t& blue)
+{
+    red = vandq_u8(vshlq_n_u8(lo, 1), vdupq_n_u8(0x3E));
+    green = vbslq_u8(vdupq_n_u8(0xCE), vshrq_n_u8(lo, 4), vshlq_n_u8(hi, 4));
+    blue = vandq_u8(vshrq_n_u8(hi, 1), vdupq_n_u8(0x3E));
+    red = vandq_u8(vtstq_u8(red, red), vaddq_u8(red, vdupq_n_u8(1)));
+    green = vandq_u8(vtstq_u8(green, green), vaddq_u8(green, vdupq_n_u8(1)));
+    blue =  vandq_u8(vtstq_u8(blue, blue), vaddq_u8(blue, vdupq_n_u8(1)));
+}
+
+inline void RGB5ToRGB6(uint8x8_t lo, uint8x8_t hi, uint8x8_t& red, uint8x8_t& green, uint8x8_t& blue)
+{
+    red   = vand_u8(vshl_n_u8(lo, 1), vdup_n_u8(0x3E));
+    green = vbsl_u8(vdup_n_u8(0xCE), vshr_n_u8(lo, 4), vshl_n_u8(hi, 4));
+    blue  = vand_u8(vshr_n_u8(hi, 1), vdup_n_u8(0x3E));
+
+    red   = vand_u8(vtst_u8(red, red), vadd_u8(red, vdup_n_u8(1)));
+    green = vand_u8(vtst_u8(green, green), vadd_u8(green, vdup_n_u8(1)));
+    blue  = vand_u8(vtst_u8(blue, blue), vadd_u8(blue, vdup_n_u8(1)));
+}*/
+
+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);
+}
+
+enum
+{
+    outputFmt_RGB6A5,
+    outputFmt_RGBA8,
+    outputFmt_BGRA8
+};
+
+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 <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;
+        }
+    }*/
+}
+
+void Convert16ColorsTexture(u32 width, u32 height, u32* output, u8* texData, u16* palData, bool color0Transparent)
+{
+    /*uint8x16x2_t palette = vld2q_u8((u8*)palData);
+
+    uint8x16_t paletteR, paletteG, paletteB;
+    RGB5ToRGB6(palette.val[0], palette.val[1], paletteR, paletteG, paletteB);
+
+    uint8x16_t firstEntryAlpha = vdupq_n_u8(color0Transparent ? 0 : 0x1F);
+
+    for (int i = 0; i < width*height/2; i += 16)
+    {
+        uint8x16_t packedIndices = vld1q_u8(&texData[i]);
+
+        // unpack indices
+        uint8x16_t oddIndices = vandq_u8(packedIndices, vdupq_n_u8(0xF));
+        uint8x16_t evenIndices = vshrq_n_u8(packedIndices, 4);
+
+        uint8x16_t indices0 = vzip1q_u8(oddIndices, evenIndices);
+        uint8x16_t indices1 = vzip2q_u8(oddIndices, evenIndices);
+
+        // palettise
+        uint8x16x4_t finalPixels0, finalPixels1;
+        finalPixels0.val[0] = vqtbl1q_u8(paletteR, indices0);
+        finalPixels0.val[1] = vqtbl1q_u8(paletteG, indices0);
+        finalPixels0.val[2] = vqtbl1q_u8(paletteB, indices0);
+        finalPixels0.val[3] = vbslq_u8(vceqzq_u8(indices0), firstEntryAlpha, vdupq_n_u8(0x1F));
+        finalPixels1.val[0] = vqtbl1q_u8(paletteR, indices1);
+        finalPixels1.val[1] = vqtbl1q_u8(paletteG, indices1);
+        finalPixels1.val[2] = vqtbl1q_u8(paletteB, indices1);
+        finalPixels1.val[3] = vbslq_u8(vceqzq_u8(indices1), firstEntryAlpha, vdupq_n_u8(0x1F));
+
+        vst4q_u8((u8*)&output[i*2], finalPixels0);
+        vst4q_u8((u8*)&output[i*2+16], finalPixels1);
+    }*/
+}
+
+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;
+            }
+        }
+    }
+}
+
+ComputeRenderer::TexCacheEntry& ComputeRenderer::GetTexture(u32 texParam, u32 palBase)
+{
+    // 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 = TexCache.find(key);
+
+    if (it != TexCache.end())
+        return it->second;
+
+    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;
+
+        /*for (u32 i = 0; i < width*height; i += 16)
+        {
+            uint8x16x2_t pixels = vld2q_u8(&GPU::VRAMFlat_Texture[addr + i * 2]);
+
+            uint8x16_t red, green, blue;
+            RGB5ToRGB6(pixels.val[0], pixels.val[1], red, green, blue);
+            uint8x16_t alpha = vbslq_u8(vtstq_u8(pixels.val[1], vdupq_n_u8(0x80)), vdupq_n_u8(0x1F), vdupq_n_u8(0));
+
+            vst4q_u8((u8*)&TextureDecodingBuffer[i],
+            {
+                red,
+                green,
+                blue,
+                alpha
+            });
+        }*/
+    }
+    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, TextureDecodingBuffer, 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, TextureDecodingBuffer, texData, palData); break;
+        case 6: ConvertAXIYTexture<outputFmt_RGB6A5, 5, 3>(width, height, TextureDecodingBuffer, texData, palData); break;
+        case 2: ConvertNColorsTexture<outputFmt_RGB6A5, 2>(width, height, TextureDecodingBuffer, texData, palData, color0Transparent); break;
+        case 3: Convert16ColorsTexture(width, height, TextureDecodingBuffer, texData, palData, color0Transparent); break;
+        case 4: ConvertNColorsTexture<outputFmt_RGB6A5, 8>(width, height, TextureDecodingBuffer, 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);
+        TexArray& array = texArrays[texArrays.size()-1];
+
+        u32 layers = std::min<u32>((8*1024*1024) / (width*height*4), 64);
+
+        // allocate new array texture
+        dk::ImageLayout imageLayout;
+        dk::ImageLayoutMaker{Gfx::Device}
+            .setType(DkImageType_2DArray)
+            .setFormat(DkImageFormat_RGBA8_Uint)
+            .setDimensions(width, height, layers)
+            .initialize(imageLayout);
+
+        assert(FreeImageDescriptorsCount > 0);
+        array.ImageDescriptor = FreeImageDescriptors[--FreeImageDescriptorsCount];
+
+        array.Memory = Gfx::TextureHeap->Alloc(imageLayout.getSize(), imageLayout.getAlignment());
+        array.Image.initialize(imageLayout, Gfx::TextureHeap->MemBlock, array.Memory.Offset);
+
+        dk::ImageDescriptor descriptor;
+        descriptor.initialize(array.Image);
+        DkGpuAddr descriptors = Gfx::DataHeap->GpuAddr(ImageDescriptors);
+        EmuCmdBuf.pushData(descriptors + (descriptorOffset_TexcacheStart + array.ImageDescriptor) * sizeof(DkImageDescriptor),
+            &descriptor,
+            sizeof(DkImageDescriptor));
+
+        //printf("allocating new layer set for %d %d %d %d\n", width, height, texArrays.size()-1, array.ImageDescriptor);
+
+        for (u16 i = 0; i < layers; i++)
+        {
+            freeTextures.push_back(TexArrayEntry{(u16)(texArrays.size()-1), i});
+        }
+    }*/
+
+    TexArrayEntry storagePlace = freeTextures[freeTextures.size()-1];
+    freeTextures.pop_back();
+
+    TexArray& array = texArrays[storagePlace.TexArrayIdx];
+    //printf("using storage place %d %d | %d %d (%d)\n", width, height, storagePlace.TexArrayIdx, storagePlace.LayerIdx, array.ImageDescriptor);
+
+    /*UploadBuf.UploadAndCopyTexture(Gfx::EmuCmdBuf, array.Image,
+        (u8*)TextureDecodingBuffer,
+        0, 0, width, height,
+        width*4,
+        storagePlace.LayerIdx);*/
+
+    entry.DescriptorIdx = array.ImageDescriptor;
+    entry.Texture = storagePlace;
+
+    return TexCache.emplace(std::make_pair(key, entry)).first->second;
+}
+
+struct Variant
+{
+    s16 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
+    Mit Textur
+    0
+    1, 3
+    2
+    Ohne Textur
+    2
+    0, 1, 3
+
+    => 20 Shader + 1x Shadow Mask
+*/
+
+void ComputeRenderer::RenderFrame()
+{
+    //printf("render frame\n");
+    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 = TexCache.begin(); it != TexCache.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 = TexCache.erase(it);
+        }
+    }
+    else if (RenderFrameIdentical)
+    {
+        return;
+    }
+
+    int numYSpans = 0;
+    int numSetupIndices = 0;
+
+    u32 numVariants = 0, prevVariant, prevTexLayer;
+    Variant variants[MaxVariants];
+
+    int foundviatexcache = 0, foundviaprev = 0, numslow = 0;
+
+    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;
+        s32 ytop = polygon->YTop, ybot = polygon->YBottom;
+
+        u32 curVL = vtop, curVR = vtop;
+        u32 nextVL, nextVR;
+
+        RenderPolygons[i].FirstXSpan = numSetupIndices;
+        RenderPolygons[i].YTop = ytop;
+        RenderPolygons[i].YBot = ybot;
+        RenderPolygons[i].Attr = polygon->Attr;
+
+        bool foundVariant = false;
+        if (i > 0)
+        {
+            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)
+                foundviaprev++;
+        }
+
+        if (!foundVariant)
+        {
+            Variant variant;
+            variant.BlendMode = polygon->IsShadowMask ? 4 : ((polygon->Attr >> 4) & 0x3);
+            variant.Texture = -1;
+            variant.Sampler = -1;
+            TexCacheEntry* texcacheEntry = nullptr;
+            if (enableTextureMaps && (polygon->TexParam >> 26) & 0x7)
+            {
+                texcacheEntry = &GetTexture(polygon->TexParam, polygon->TexPalette);
+                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 = (wrapS ? (mirrorS ? 2 : 1) : 0) + (wrapT ? (mirrorT ? 2 : 1) : 0) * 3;
+                variant.Texture = texcacheEntry->DescriptorIdx;
+                prevTexLayer = texcacheEntry->Texture.LayerIdx;
+                if (texcacheEntry->LastVariant < numVariants && variants[texcacheEntry->LastVariant] == variant)
+                {
+                    foundVariant = true;
+                    prevVariant = texcacheEntry->LastVariant;
+                    foundviatexcache++;
+                }
+            }
+
+            if (!foundVariant)
+            {
+                numslow++;
+                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 (texcacheEntry)
+                    texcacheEntry->LastVariant = 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 minX = polygon->Vertices[vtop]->FinalPosition[0];
+        s32 minXY = polygon->Vertices[vtop]->FinalPosition[1];
+        s32 maxX = polygon->Vertices[vtop]->FinalPosition[0];
+        s32 maxXY = polygon->Vertices[vtop]->FinalPosition[1];
+
+        if (ybot == ytop)
+        {
+            vtop = 0; vbot = 0;
+
+            RenderPolygons[i].YBot++;
+
+            int j = 1;
+            if (polygon->Vertices[j]->FinalPosition[0] < polygon->Vertices[vtop]->FinalPosition[0]) vtop = j;
+            if (polygon->Vertices[j]->FinalPosition[0] > polygon->Vertices[vbot]->FinalPosition[0]) vbot = j;
+
+            j = nverts - 1;
+            if (polygon->Vertices[j]->FinalPosition[0] < polygon->Vertices[vtop]->FinalPosition[0]) vtop = j;
+            if (polygon->Vertices[j]->FinalPosition[0] > polygon->Vertices[vbot]->FinalPosition[0]) vbot = j;
+
+            assert(numYSpans < MaxYSpanSetups);
+            u32 curSpanL = numYSpans;
+            SetupYSpanDummy(&YSpanSetups[numYSpans++], polygon, vtop, 0);
+            assert(numYSpans < MaxYSpanSetups);
+            u32 curSpanR = numYSpans;
+            SetupYSpanDummy(&YSpanSetups[numYSpans++], polygon, vbot, 1);
+
+            minX = YSpanSetups[curSpanL].X0;
+            minXY = YSpanSetups[curSpanL].Y0;
+            maxX = YSpanSetups[curSpanR].X0;
+            maxXY = YSpanSetups[curSpanR].Y0;
+            if (maxX < minX)
+            {
+                std::swap(minX, maxX);
+                std::swap(minXY, maxXY);
+            }
+
+            assert(numSetupIndices < MaxYSpanIndices);
+            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(i, &YSpanSetups[numYSpans++], polygon, curVL, nextVL, ytop, 0);
+            u32 curSpanR = numYSpans;
+            assert(numYSpans < MaxYSpanSetups);
+            SetupYSpan(i, &YSpanSetups[numYSpans++], polygon, curVR, nextVR, ytop, 1);
+
+            for (u32 y = ytop; y < ybot; y++)
+            {
+                if (y >= polygon->Vertices[nextVL]->FinalPosition[1] && curVL != polygon->VBottom)
+                {
+                    while (y >= polygon->Vertices[nextVL]->FinalPosition[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;
+                        }
+                    }
+
+                    if (polygon->Vertices[curVL]->FinalPosition[0] < minX)
+                    {
+                        minX = polygon->Vertices[curVL]->FinalPosition[0];
+                        minXY = polygon->Vertices[curVL]->FinalPosition[1];
+                    }
+                    if (polygon->Vertices[curVL]->FinalPosition[0] > maxX)
+                    {
+                        maxX = polygon->Vertices[curVL]->FinalPosition[0];
+                        maxXY = polygon->Vertices[curVL]->FinalPosition[1];
+                    }
+
+                    assert(numYSpans < MaxYSpanSetups);
+                    curSpanL = numYSpans;
+                    SetupYSpan(i,&YSpanSetups[numYSpans++], polygon, curVL, nextVL, y, 0);
+                }
+                if (y >= polygon->Vertices[nextVR]->FinalPosition[1] && curVR != polygon->VBottom)
+                {
+                    while (y >= polygon->Vertices[nextVR]->FinalPosition[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;
+                        }
+                    }
+
+                    if (polygon->Vertices[curVR]->FinalPosition[0] < minX)
+                    {
+                        minX = polygon->Vertices[curVR]->FinalPosition[0];
+                        minXY = polygon->Vertices[curVR]->FinalPosition[1];
+                    }
+                    if (polygon->Vertices[curVR]->FinalPosition[0] > maxX)
+                    {
+                        maxX = polygon->Vertices[curVR]->FinalPosition[0];
+                        maxXY = polygon->Vertices[curVR]->FinalPosition[1];
+                    }
+
+                    assert(numYSpans < MaxYSpanSetups);
+                    curSpanR = numYSpans;
+                    SetupYSpan(i,&YSpanSetups[numYSpans++], polygon, curVR, nextVR, y, 1);
+                }
+
+                assert(numSetupIndices < MaxYSpanIndices);
+                YSpanIndices[numSetupIndices].PolyIdx = i;
+                YSpanIndices[numSetupIndices].SpanIdxL = curSpanL;
+                YSpanIndices[numSetupIndices].SpanIdxR = curSpanR;
+                YSpanIndices[numSetupIndices].Y = y;
+                numSetupIndices++;
+            }
+        }
+
+        if (polygon->Vertices[nextVL]->FinalPosition[0] < minX)
+        {
+            minX = polygon->Vertices[nextVL]->FinalPosition[0];
+            minXY = polygon->Vertices[nextVL]->FinalPosition[1];
+        }
+        if (polygon->Vertices[nextVL]->FinalPosition[0] > maxX)
+        {
+            maxX = polygon->Vertices[nextVL]->FinalPosition[0];
+            maxXY = polygon->Vertices[nextVL]->FinalPosition[1];
+        }
+        if (polygon->Vertices[nextVR]->FinalPosition[0] < minX)
+        {
+            minX = polygon->Vertices[nextVR]->FinalPosition[0];
+            minXY = polygon->Vertices[nextVR]->FinalPosition[1];
+        }
+        if (polygon->Vertices[nextVR]->FinalPosition[0] > maxX)
+        {
+            maxX = polygon->Vertices[nextVR]->FinalPosition[0];
+            maxXY = polygon->Vertices[nextVR]->FinalPosition[1];
+        }
+
+        RenderPolygons[i].XMin = minX;
+        RenderPolygons[i].XMinY = minXY;
+        RenderPolygons[i].XMax = maxX;
+        RenderPolygons[i].XMaxY = maxXY;
+
+        //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);
+
+        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, YSpanSetupMemory);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, XSpanSetupMemory);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, RenderPolygonMemory);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, BinResultMemory);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, TileMemory);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 5, FinalTileMemory);
+
+    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);
+    }
+    meta.XScroll = RenderXPos;
+
+    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), 256/CoarseTileW, 192/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(BinResult, SortWorkWorkCount));
+        glMemoryBarrier(GL_SHADER_STORAGE_BUFFER);
+
+        // 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 = -1, prevSampler = -1;
+            for (int i = 0; i < numVariants; i++)
+            {
+                GLuint shader = 0;
+                if (variants[i].Texture == -1)
+                {
+                    shader = shadersNoTexture[variants[i].BlendMode];
+                }
+                else
+                {
+                    shader = shadersUseTexture[variants[i].BlendMode];
+                    if (variants[i].Texture != prevTexture || variants[i].Sampler != prevSampler)
+                    {
+                        assert(variants[i].Sampler < 9);
+                        glBindTexture(GL_TEXTURE_2D, variants[i].Texture);
+                        prevTexture = variants[i].Texture;
+                        prevSampler = variants[i].Sampler;
+                    }
+                }
+                assert(shader != 0);
+                if (shader != prevShader)
+                {
+                    glUseProgram(shader);
+                    prevShader = shader;
+                }
+
+                glUniform1i(UniformIdxCurVariant, i);
+                glUniform2f(UniformIdxTextureSize, 1.f / variants[i].Width, 1.f / variants[i].Height);
+                glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, BinResultMemory);
+                glDispatchComputeIndirect(offsetof(BinResult, VariantWorkCount) + i*4*4);
+            }
+        }
+    }
+    glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
+
+    // compose final image
+    glUseProgram(ShaderDepthBlend[wbuffer]);
+    glDispatchCompute(256/8, 192/8, 1);
+    glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
+
+    //glBindTexture(GL_TEXTURE_2D, )
+    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(256/32, 192, 1);
+    glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
+
+    /*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)
+{
+    return DummyLine;
+}
+
+}
\ No newline at end of file
diff --git a/src/GPU3D_Compute.h b/src/GPU3D_Compute.h
new file mode 100644
index 000000000..5278c76ca
--- /dev/null
+++ b/src/GPU3D_Compute.h
@@ -0,0 +1,263 @@
+/*
+    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 "NonStupidBitfield.h"
+
+#include <unordered_map>
+
+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;
+
+    //dk::Fence FrameReady = {};
+    //dk::Fence FrameReserveFence = {};
+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 TileMemory;
+    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, __pad1;
+    };
+    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;
+        u32 __pad0, __pad1;
+    };
+
+    static const int TileSize = 8;
+    static const int CoarseTileCountX = 8;
+    static const int CoarseTileCountY = 4;
+    static const int CoarseTileW = CoarseTileCountX * TileSize;
+    static const int CoarseTileH = CoarseTileCountY * TileSize;
+
+    static const int TilesPerLine = 256/TileSize;
+    static const int TileLines = 192/TileSize;
+
+    static const int BinStride = 2048/32;
+    static const int CoarseBinStride = BinStride/32;
+
+    static const int MaxWorkTiles = TilesPerLine*TileLines*48;
+    static const int MaxVariants = 256;
+
+    static const int UniformIdxCurVariant = 0;
+    static const int UniformIdxTextureSize = 1;
+
+    struct BinResult
+    {
+        u32 VariantWorkCount[MaxVariants*4];
+        u32 SortedWorkOffset[MaxVariants];
+
+        u32 SortWorkWorkCount[4];
+        u32 UnsortedWorkDescs[MaxWorkTiles*2];
+        u32 SortedWork[MaxWorkTiles*2];
+
+        u32 BinnedMaskCoarse[TilesPerLine*TileLines*CoarseBinStride];
+        u32 BinnedMask[TilesPerLine*TileLines*BinStride];
+        u32 WorkOffsets[TilesPerLine*TileLines*BinStride];
+    };
+
+    struct Tiles
+    {
+        u32 ColorTiles[MaxWorkTiles*TileSize*TileSize];
+        u32 DepthTiles[MaxWorkTiles*TileSize*TileSize];
+        u32 AttrStencilTiles[MaxWorkTiles*TileSize*TileSize];
+    };
+
+    struct FinalTiles
+    {
+        u32 ColorResult[256*192*2];
+        u32 DepthResult[256*192*2];
+        u32 AttrResult[256*192*2];
+    };
+
+    // eh those are pretty bad guesses
+    // though real hw shouldn't be eable to render all 2048 polygons on every line either
+    static const int MaxYSpanIndices = 64*2048;
+    static const int MaxYSpanSetups = 6144*2;
+    SetupIndices YSpanIndices[MaxYSpanIndices];
+    SpanSetupY YSpanSetups[MaxYSpanSetups];
+    RenderPolygon RenderPolygons[2048];
+
+    struct TexArrayEntry
+    {
+        u16 TexArrayIdx;
+        u16 LayerIdx;
+    };
+    struct TexArray
+    {
+        GLuint Image;
+        u32 ImageDescriptor;
+    };
+
+    struct TexCacheEntry
+    {
+        u32 DescriptorIdx;
+        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> TexCache;
+
+    struct MetaUniform
+    {
+        u32 NumPolygons;
+        u32 NumVariants;
+
+        u32 AlphaRef;
+        u32 DispCnt;
+
+        u32 ToonTable[4*34];
+
+        u32 ClearColor, ClearDepth, ClearAttr;
+
+        u32 FogOffset, FogShift, FogColor;
+
+        u32 XScroll;
+    };
+    GLuint MetaUniformMemory;
+
+    static const u32 TexCacheMaxImages = 4096;
+
+    u32 FreeImageDescriptorsCount = 0;
+    u32 FreeImageDescriptors[TexCacheMaxImages];
+
+    std::vector<TexArrayEntry> FreeTextures[8][8];
+    std::vector<TexArray> TexArrays[8][8];
+
+    u32 TextureDecodingBuffer[1024*1024];
+
+    TexCacheEntry& GetTexture(u32 textureParam, u32 paletteParam);
+
+    void SetupAttrs(SpanSetupY* span, Polygon* poly, int from, int to);
+    void SetupYSpan(int polynum, SpanSetupY* span, Polygon* poly, int from, int to, u32 y, int side);
+    void SetupYSpanDummy(SpanSetupY* span, Polygon* poly, int vertex, int side);
+
+    bool CompileShader(GLuint& shader, const char* 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 000000000..d770658cf
--- /dev/null
+++ b/src/GPU3D_Compute_shaders.h
@@ -0,0 +1,1502 @@
+/*
+    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
+
+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
+
+const char* Common = R"(
+struct Polygon
+{
+    int FirstXSpan;
+    int YTop, YBot;
+
+    int XMin, XMax;
+    int XMinY, XMaxY;
+
+    int Variant;
+
+    uint Attr;
+
+    float TextureLayer;
+};
+
+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;
+};
+
+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;
+};
+
+layout (std140, binding = 0) readonly buffer YSpanSetupsBuffer
+{
+    YSpanSetup YSpanSetups[];
+};
+
+#if defined(InterpSpans) || defined(BinCombined) || defined(Rasterise)
+layout (std140, binding = 1)
+#ifdef InterpSpans
+writeonly
+#endif
+#if defined(BinCombined) || defined(Rasterise)
+readonly
+#endif
+buffer XSpanSetupsBuffer
+{
+    XSpanSetup XSpanSetups[];
+};
+#endif
+
+layout (std140, binding = 2) readonly buffer PolygonBuffer
+{
+    Polygon Polygons[];
+};
+
+#define TileSize 8
+const int CoarseTileCountX = 8;
+const int CoarseTileCountY = 4;
+const int CoarseTileW = (CoarseTileCountX * TileSize);
+const int CoarseTileH = (CoarseTileCountY * TileSize);
+
+const int FramebufferStride = 256*192;
+const int TilesPerLine = 256/TileSize;
+const int TileLines = 192/TileSize;
+
+const int BinStride = 2048/32;
+const int CoarseBinStride = BinStride/32;
+
+const int MaxWorkTiles = TilesPerLine*TileLines*48;
+const int MaxVariants = 256;
+
+layout (std430, binding = 3)
+buffer BinResultBuffer
+{
+    uvec4 VariantWorkCount[MaxVariants];
+    uint SortedWorkOffset[MaxVariants];
+
+    uvec4 SortWorkWorkCount;
+    uvec2 UnsortedWorkDescs[MaxWorkTiles];
+    uvec2 SortedWork[MaxWorkTiles];
+
+    uint BinnedMaskCoarse[TilesPerLine*TileLines*CoarseBinStride];
+    uint BinnedMask[TilesPerLine*TileLines*BinStride];
+    uint WorkOffsets[TilesPerLine*TileLines*BinStride];
+};
+
+#if defined(Rasterise) || defined(DepthBlend)
+layout (std430, binding = 4)
+#ifdef Rasterise
+writeonly
+#endif
+#ifdef DepthBlend
+readonly
+#endif
+buffer TilesBuffer
+{
+    uint ColorTiles[MaxWorkTiles*TileSize*TileSize];
+    uint DepthTiles[MaxWorkTiles*TileSize*TileSize];
+    uint AttrTiles[MaxWorkTiles*TileSize*TileSize];
+};
+#endif
+
+layout (std430, binding = 5)
+#ifdef DepthBlend
+writeonly
+#endif
+#ifdef FinalPass
+readonly
+#endif
+buffer RasterResult
+{
+    uint ColorResult[256*192*2];
+    uint DepthResult[256*192*2];
+    uint AttrResult[256*192*2];
+};
+
+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;
+
+    int XScroll;
+
+    // only used/updated for rasteriation
+    uint CurVariant;
+    vec2 InvTextureSize;
+};
+
+
+#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)
+{
+    // 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);
+    uint r = x - y * q;
+    if(r >= y)
+    {
+        r = r - y;
+        q = q + 1;
+        if(r >= y)
+        {
+            r = r - y;
+            q = q + 1;
+        }
+    }
+
+    return q;
+}
+
+#ifdef InterpSpans
+const int Shift = 9;
+#else
+const int Shift = 8;
+#endif
+
+int CalcYFactorY(YSpanSetup span, int i)
+{
+    int num = abs((i) * span.W0n) << Shift;
+    int den = abs(((i) * span.W0d) + (((span.I1 - span.I0 - i) * span.W1d)));
+
+    if (den == 0)
+    {
+        return 0;
+    }
+    else
+    {
+        int q = int(Div(num, den));
+        //if ((num < 0) != (den < 0))
+        //    return -q;
+        return q;
+    }
+}
+
+int CalcYFactorX(XSpanSetup span, int x)
+{
+    x -= span.X0;
+
+    if (span.X0 != span.X1)
+    {
+        uint num = (uint(x) * span.W0) << Shift;
+        uint den = (uint(x) * span.W0) + (uint(span.X1 - span.X0 - x) * span.W1);
+
+        if (den == 0)
+            return 0;
+        else
+            return int(Div(num, den));
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+int InterpolateAttrPersp(int y0, int y1, int ifactor)
+{
+    if (y0 == y1)
+        return y0;
+
+    if (y0 < y1)
+        return y0 + (((y1-y0) * ifactor) >> Shift);
+    else
+        return y1 + (((y0-y1) * ((1<<Shift)-ifactor)) >> Shift);
+}
+
+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) >> Shift);
+    }
+    else
+    {
+        return uint(z1) + (((z0-z1) * ((1<<Shift)-ifactor)) >> Shift);
+    }
+#else
+    uint mulLo, mulHi;
+    if (z0 < z1)
+    {
+        umulExtended(z1-z0, ifactor, mulHi, mulLo);
+        // 64-bit shift
+        return uint(z0) + ((mulLo >> Shift) | (mulHi << (32-Shift)));
+    }
+    else
+    {
+        umulExtended(z0-z1, (1<<Shift)-ifactor, mulHi, mulLo);
+        return uint(z1) + ((mulLo >> Shift) | (mulHi << (32-Shift)));
+    }
+#endif
+    /*if (z0 < z1)
+    {
+        return uint(z0) + uint((int64_t(z1-z0) * int64_t(ifactor)) >> Shift);
+    }
+    else
+    {
+        return uint(z1) + uint((int64_t(z0-z1) * int64_t((1<<Shift)-ifactor)) >> Shift);
+    }*/
+}
+
+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;
+
+    int startcov = int(Div(uint(((startx << 10) + 0x1FF) * (span.Y1 - span.Y0)), uint(xlen)));
+    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
+
+)";
+
+const char* InterpSpans = 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*/true;
+
+    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
+        xspan.XRecip = int(Div(1U<<30, uint(xspan.X1 - xspan.X0)));
+    }
+
+    XSpanSetups[gl_GlobalInvocationID.x] = xspan;
+}
+
+)";
+
+const char* ClearIndirectWorkCount = R"(
+
+layout (local_size_x = 32) in;
+
+void main()
+{
+    VariantWorkCount[gl_GlobalInvocationID.x] = uvec4(1, 1, 0, 0);
+}
+
+)";
+
+const char* ClearCoarseBinMask = R"(
+
+layout (local_size_x = 32) in;
+
+void main()
+{
+    BinnedMaskCoarse[gl_GlobalInvocationID.x*CoarseBinStride+0] = 0;
+    BinnedMaskCoarse[gl_GlobalInvocationID.x*CoarseBinStride+1] = 0;
+}
+
+)";
+
+const char* BinCombined = 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;
+
+    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;
+
+    BinnedMask[linearTile * BinStride + groupIdx] = binnedMask;
+    int coarseMaskIdx = linearTile * CoarseBinStride + (groupIdx >> 5);
+    if (binnedMask != 0U)
+        atomicOr(BinnedMaskCoarse[coarseMaskIdx], 1U << (groupIdx & 0x1F));
+
+    if (binnedMask != 0U)
+    {
+        uint workOffset = atomicAdd(VariantWorkCount[0].w, uint(bitCount(binnedMask)));
+        WorkOffsets[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));
+            UnsortedWorkDescs[workOffset + idx] = uvec2(tilePositionCombined, bitfieldInsert(inVariantOffset, polygonIdx, 16, 16));
+
+            idx++;
+        }
+    }
+}
+
+)";
+
+const char* CalcOffsets = 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 char* SortWork = R"(
+
+layout (local_size_x = 32) in;
+
+void main()
+{
+    if (gl_GlobalInvocationID.x < VariantWorkCount[0].w)
+    {
+        uvec2 workDesc = UnsortedWorkDescs[gl_GlobalInvocationID.x];
+        int inVariantOffset = int(bitfieldExtract(workDesc.y, 0, 16));
+        int polygonIdx = int(bitfieldExtract(workDesc.y, 16, 16));
+        int variantIdx = Polygons[polygonIdx].Variant;
+
+        int sortedIndex = int(SortedWorkOffset[variantIdx]) + inVariantOffset;
+        SortedWork[sortedIndex] = uvec2(workDesc.x, bitfieldInsert(workDesc.y, gl_GlobalInvocationID.x, 0, 16));
+    }
+}
+
+)";
+
+const char* Rasterise = R"(
+
+layout (local_size_x = TileSize, local_size_y = TileSize) in;
+
+layout (binding = 0) uniform usampler2DArray CurrentTexture;
+
+void main()
+{
+    uvec2 workDesc = SortedWork[SortedWorkOffset[CurVariant] + gl_WorkGroupID.z];
+    Polygon polygon = Polygons[bitfieldExtract(workDesc.y, 16, 16)];
+    ivec2 position = ivec2(bitfieldExtract(workDesc.x, 0, 16), bitfieldExtract(workDesc.x, 16, 16)) + ivec2(gl_LocalInvocationID.xy);
+    int tileOffset = int(bitfieldExtract(workDesc.y, 0, 16)) * 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 & (1U<<31)) != 0U)
+                {
+                    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 & (1U<<31)) != 0U)
+                {
+                    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 char* DepthBlend = 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 = BinnedMask[tileOffset];
+        uint workIdx = WorkOffsets[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 = BinnedMaskCoarse[linearTile*CoarseBinStride + 0];
+    uint coarseMaskHi = BinnedMaskCoarse[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) * 256;
+    ColorResult[resultOffset] = color.x;
+    ColorResult[resultOffset+FramebufferStride] = color.y;
+    DepthResult[resultOffset] = depth.x;
+    DepthResult[resultOffset+FramebufferStride] = depth.y;
+    AttrResult[resultOffset] = attr.x;
+    AttrResult[resultOffset+FramebufferStride] = attr.y;
+}
+
+)";
+
+const char* FinalPass = R"(
+
+layout (local_size_x = 32) in;
+
+layout (binding = 0, r32ui) writeonly uniform uimage2D FinalFB; 
+
+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) + XScroll) & 0x1FF;
+    int resultOffset = int(srcX) + int(gl_GlobalInvocationID.y) * 256;
+
+    uvec2 color = uvec2(0);
+    uvec2 depth = uvec2(0);
+    uvec2 attr = uvec2(0);
+    if (srcX < 256)
+    {
+        color = uvec2(ColorResult[resultOffset], ColorResult[resultOffset+FramebufferStride]);
+        depth = uvec2(DepthResult[resultOffset], DepthResult[resultOffset+FramebufferStride]);
+        attr = uvec2(AttrResult[resultOffset], AttrResult[resultOffset+FramebufferStride]);
+    }
+
+#ifdef EdgeMarking
+    if ((attr.x & 0xFU) != 0U)
+    {
+        uvec4 otherAttr = uvec4(ClearAttr);
+        uvec4 otherDepth = uvec4(ClearDepth);
+
+        if (srcX > 0U)
+        {
+            otherAttr.x = AttrResult[resultOffset-1];
+            otherDepth.x = DepthResult[resultOffset-1];
+        }
+        if (srcX < 255U)
+        {
+            otherAttr.y = AttrResult[resultOffset+1];
+            otherDepth.y = DepthResult[resultOffset+1];
+        }
+        if (gl_GlobalInvocationID.y > 0U)
+        {
+            otherAttr.z = AttrResult[resultOffset-256];
+            otherDepth.z = DepthResult[resultOffset-256];
+        }
+        if (gl_GlobalInvocationID.y < 191U)
+        {
+            otherAttr.w = AttrResult[resultOffset+256];
+            otherDepth.w = DepthResult[resultOffset+256];
+        }
+
+        uint polyId = bitfieldExtract(attr.x, 24, 5);
+        uvec4 otherPolyId = bitfieldExtract(otherAttr, 24, 5);
+
+        bvec4 polyIdMatch = equal(uvec4(polyId), otherPolyId);
+        bvec4 nearer = lessThan(uvec4(depth.x), otherDepth);
+
+        if ((!polyIdMatch.x && nearer.x)
+            || (!polyIdMatch.y && nearer.y)
+            || (!polyIdMatch.z && nearer.z)
+            || (!polyIdMatch.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_LocalInvocationID.x == 7 || gl_LocalInvocationID.y == 7)
+        //color.x = 0x1F00001FU | 0x40000000U;
+
+    imageStore(FinalFB, ivec2(gl_GlobalInvocationID.xy), uvec4(color.x, 0, 0, 0));
+}
+
+)";
+
+}
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/GPU3D_OpenGL.cpp b/src/GPU3D_OpenGL.cpp
index ebabd51c4..d5f30158c 100644
--- a/src/GPU3D_OpenGL.cpp
+++ b/src/GPU3D_OpenGL.cpp
@@ -48,25 +48,18 @@ bool GLRenderer::BuildRenderShader(u32 flags, const char* vs, const char* fs)
     strcpy(&fsbuf[headerlen], kRenderFSCommon);
     strcpy(&fsbuf[headerlen + fsclen], fs);
 
-    bool ret = OpenGL::BuildShaderProgram(vsbuf, fsbuf, RenderShader[flags], shadername);
+    GLuint prog;
+    bool ret = OpenGL::CompileVertexFragmentProgram(prog,
+        vsbuf, fsbuf,
+        shadername,
+        {{"vPosition", 0}, {"vColor", 1}, {"vTexcoord", 2}, {"vPolygonAttr", 3}},
+        {{"oColor", 0}, {"oAttr", 1}});
 
     delete[] vsbuf;
     delete[] fsbuf;
 
     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 +70,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 +106,17 @@ bool GLRenderer::Init()
     glDepthRange(0, 1);
     glClearDepth(1.0);
 
-
-    if (!OpenGL::BuildShaderProgram(kClearVS, kClearFS, ClearShaderPlain, "ClearShader"))
-        return false;
-
-    glBindAttribLocation(ClearShaderPlain[2], 0, "vPosition");
-    glBindFragDataLocation(ClearShaderPlain[2], 0, "oColor");
-    glBindFragDataLocation(ClearShaderPlain[2], 1, "oAttr");
-
-    if (!OpenGL::LinkShaderProgram(ClearShaderPlain))
+    if (!OpenGL::CompileVertexFragmentProgram(ClearShaderPlain,
+            kClearVS, kClearFS,
+            "ClearShader",
+            {{"vPosition", 0}},
+            {{"oColor", 0}, {"oAttr", 1}}))
         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 +137,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");
-
-    if (!OpenGL::LinkShaderProgram(FinalPassFogShader))
-        return false;
-
-    uni_id = glGetUniformBlockIndex(FinalPassFogShader[2], "uConfig");
-    glUniformBlockBinding(FinalPassFogShader[2], uni_id, 0);
-
-    glUseProgram(FinalPassFogShader[2]);
+    uni_id = glGetUniformBlockIndex(FinalPassFogShader, "uConfig");
+    glUniformBlockBinding(FinalPassFogShader, uni_id, 0);
 
-    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);
 
 
@@ -304,8 +288,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]);
     }
 }
 
@@ -1077,7 +1061,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 +1072,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);
@@ -1222,7 +1206,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;
diff --git a/src/GPU3D_OpenGL.h b/src/GPU3D_OpenGL.h
index a9dd62cf4..e4005cefe 100644
--- a/src/GPU3D_OpenGL.h
+++ b/src/GPU3D_OpenGL.h
@@ -83,13 +83,13 @@ class GLRenderer : public Renderer3D
     };
 
 
-    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
diff --git a/src/GPU_OpenGL.cpp b/src/GPU_OpenGL.cpp
index 837d22402..3bb1d5045 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()
@@ -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
diff --git a/src/GPU_OpenGL.h b/src/GPU_OpenGL.h
index d27ae20b2..165dd7c77 100644
--- a/src/GPU_OpenGL.h
+++ b/src/GPU_OpenGL.h
@@ -46,7 +46,7 @@ class GLCompositor
     int Scale;
     int ScreenH, ScreenW;
 
-    GLuint CompShader[1][3];
+    GLuint CompShader[1];
     GLuint CompScaleLoc[1];
     GLuint Comp3DXPosLoc[1];
 
diff --git a/src/NonStupidBitfield.h b/src/NonStupidBitfield.h
index badefaf70..759946de9 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));
+        else
+            return 0xFFFFFFFFFFFFFFFF;
+
+        return 0xFFFFFFFFFFFFFFFF;
+    }
+    else if (idx == startEntry)
+    {
+        return ((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)
 
@@ -163,6 +189,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;
@@ -184,6 +215,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++)
@@ -192,6 +243,7 @@ struct NonStupidBitField
         }
         return *this;
     }
+
     NonStupidBitField& operator&=(const NonStupidBitField<Size>& other)
     {
         for (u32 i = 0; i < DataLength; i++)
@@ -200,6 +252,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 958930db1..c00ad612f 100644
--- a/src/OpenGLSupport.cpp
+++ b/src/OpenGLSupport.cpp
@@ -24,103 +24,131 @@ using Platform::LogLevel;
 namespace OpenGL
 {
 
-bool BuildShaderProgram(const char* vs, const char* fs, GLuint* ids, const char* name)
+#define checkGLError() if (glGetError() != GL_NO_ERROR) printf("error %d\n", __LINE__)
+
+bool CompilerShader(GLuint& id, const char* source, const char* name, const char* type)
 {
     int len;
     int res;
 
-    ids[0] = glCreateShader(GL_VERTEX_SHADER);
-    len = strlen(vs);
-    glShaderSource(ids[0], 1, &vs, &len);
-    glCompileShader(ids[0]);
+    len = strlen(source);
+    glShaderSource(id, 1, &source, &len);
+    checkGLError();
+    glCompileShader(id);
+    checkGLError();
 
-    glGetShaderiv(ids[0], GL_COMPILE_STATUS, &res);
+    glGetShaderiv(id, GL_COMPILE_STATUS, &res);
+    checkGLError();
     if (res != GL_TRUE)
     {
-        glGetShaderiv(ids[0], 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[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);
+        glGetShaderInfoLog(id, res+1, NULL, log);
+        Log(LogLevel::Error, "OpenGL: failed to compile %s shader %s: %s\n", type, name, log);
+        Log(LogLevel::Debug, "shader source:\n--\n%s\n--\n", source);
         delete[] log;
 
-        glDeleteShader(ids[0]);
-
         return false;
     }
 
-    ids[1] = glCreateShader(GL_FRAGMENT_SHADER);
-    len = strlen(fs);
-    glShaderSource(ids[1], 1, &fs, &len);
-    glCompileShader(ids[1]);
-
-    glGetShaderiv(ids[1], GL_COMPILE_STATUS, &res);
-    if (res != GL_TRUE)
-    {
-        glGetShaderiv(ids[1], 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);
-        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]);
+        checkGLError();
+    }
 
-    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 char* source, const char* name)
 {
-    glDeleteProgram(ids[2]);
+    GLuint shader = glCreateShader(GL_COMPUTE_SHADER);
+    bool linkingSucess = false;
+
+    result = glCreateProgram();
+
+    printf("compiling %s", name);
+    if (!CompilerShader(shader, source, name, "compute"))
+        goto error;
+
+    linkingSucess = LinkProgram(result, &shader, 1);
+
+error:
+    glDeleteShader(shader);
+
+    if (!linkingSucess)
+        glDeleteProgram(result);
+
+    return linkingSucess;
 }
 
-void UseShaderProgram(GLuint* ids)
+bool CompileVertexFragmentProgram(GLuint& result,
+    const char* vs, const char* fs,
+    const char* 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 14be01a6f..7d8aae449 100644
--- a/src/OpenGLSupport.h
+++ b/src/OpenGLSupport.h
@@ -29,10 +29,19 @@
 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);
+struct AttributeTarget
+{
+    const char* Name;
+    u32 Location;
+};
+
+bool CompileVertexFragmentProgram(GLuint& result,
+    const char* vs, const char* fs,
+    const char* name,
+    const std::initializer_list<AttributeTarget>& vertexInAttrs,
+    const std::initializer_list<AttributeTarget>& fragmentOutAttrs);
+
+bool CompileComputeProgram(GLuint& result, const char* source, const char* name);
 
 }
 
diff --git a/src/frontend/qt_sdl/CMakeLists.txt b/src/frontend/qt_sdl/CMakeLists.txt
index 0ae6ecea7..a767972c8 100644
--- a/src/frontend/qt_sdl/CMakeLists.txt
+++ b/src/frontend/qt_sdl/CMakeLists.txt
@@ -24,6 +24,7 @@ set(SOURCES_QT_SDL
     ROMInfoDialog.cpp
     RAMInfoDialog.cpp
     TitleManagerDialog.cpp
+    RTCSettingsDialog.cpp
     Input.cpp
     LAN_PCap.cpp
     LAN_Socket.cpp
diff --git a/src/frontend/qt_sdl/OSD.cpp b/src/frontend/qt_sdl/OSD.cpp
index d3becc126..6842d5f09 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/main.cpp b/src/frontend/qt_sdl/main.cpp
index 4ed7d3fc5..9ec28cc1e 100644
--- a/src/frontend/qt_sdl/main.cpp
+++ b/src/frontend/qt_sdl/main.cpp
@@ -227,19 +227,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
@@ -299,7 +297,7 @@ void EmuThread::deinitOpenGL()
     glDeleteVertexArrays(1, &screenVertexArray);
     glDeleteBuffers(1, &screenVertexBuffer);
 
-    OpenGL::DeleteShaderProgram(screenShaderProgram);
+    glDeleteProgram(screenShaderProgram);
 
     OSD::DeInit();
 
@@ -745,7 +743,7 @@ void EmuThread::drawScreenGL()
 
     glViewport(0, 0, w, h);
 
-    glUseProgram(screenShaderProgram[2]);
+    glUseProgram(screenShaderProgram);
     glUniform2f(screenShaderScreenSizeULoc, w / factor, h / factor);
 
     int frontbuf = FrontBuffer;
diff --git a/src/frontend/qt_sdl/main.h b/src/frontend/qt_sdl/main.h
index 8a902ee64..4504e4286 100644
--- a/src/frontend/qt_sdl/main.h
+++ b/src/frontend/qt_sdl/main.h
@@ -104,7 +104,7 @@ class EmuThread : public QThread
     GL::Context* oglContext = nullptr;
     GLuint screenVertexBuffer, screenVertexArray;
     GLuint screenTexture;
-    GLuint screenShaderProgram[3];
+    GLuint screenShaderProgram;
     GLuint screenShaderTransformULoc, screenShaderScreenSizeULoc;
 
     QMutex screenSettingsLock;

From 0c16bd4a40b42324ef37f0694cea1d16602ecd35 Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Tue, 11 Apr 2023 22:59:57 +0200
Subject: [PATCH 02/20] don't double buffer 3D framebuffers for the GL Renderer
 looks like leftovers from when 3D+2D composition was done in the frontend

---
 src/GPU.cpp          |  2 +-
 src/GPU3D_OpenGL.cpp | 81 +++++++++++++++++---------------------------
 src/GPU3D_OpenGL.h   | 10 +++---
 src/GPU_OpenGL.cpp   | 10 +++---
 4 files changed, 42 insertions(+), 61 deletions(-)

diff --git a/src/GPU.cpp b/src/GPU.cpp
index 23db96696..f51748b67 100644
--- a/src/GPU.cpp
+++ b/src/GPU.cpp
@@ -397,7 +397,7 @@ void InitRenderer(int renderer)
             GPU3D::CurrentRenderer = std::make_unique<GPU3D::SoftRenderer>();
             GPU3D::CurrentRenderer->Init();
         }
-        GPU3D::CurrentRenderer = std::make_unique<GPU3D::ComputeRenderer>();
+        GPU3D::CurrentRenderer = std::make_unique<GPU3D::GLRenderer>();
         if (!GPU3D::CurrentRenderer->Init())
         {
             // Fallback on software renderer
diff --git a/src/GPU3D_OpenGL.cpp b/src/GPU3D_OpenGL.cpp
index d5f30158c..c57b1c7c3 100644
--- a/src/GPU3D_OpenGL.cpp
+++ b/src/GPU3D_OpenGL.cpp
@@ -218,29 +218,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);
@@ -276,8 +273,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);
@@ -307,40 +308,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]);
-    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]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, ScreenW, ScreenH, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
-
-    glBindTexture(GL_TEXTURE_2D, FramebufferTex[6]);
+    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[7]);
+    glBindTexture(GL_TEXTURE_2D, AttrBufferTex);
     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);
+    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[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);
-    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);
 
@@ -1049,9 +1035,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);
@@ -1100,7 +1086,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;
@@ -1266,22 +1252,17 @@ 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]);
+    glBindFramebuffer(GL_READ_FRAMEBUFFER, DownscaleFramebuffer);
     glReadPixels(0, 0, 256, 192, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
 }
 
@@ -1310,7 +1291,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 e4005cefe..fabf6f107 100644
--- a/src/GPU3D_OpenGL.h
+++ b/src/GPU3D_OpenGL.h
@@ -142,11 +142,11 @@ class GLRenderer : public Renderer3D
     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/GPU_OpenGL.cpp b/src/GPU_OpenGL.cpp
index 3bb1d5045..7f1b04834 100644
--- a/src/GPU_OpenGL.cpp
+++ b/src/GPU_OpenGL.cpp
@@ -180,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);
@@ -203,12 +203,12 @@ 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);

From dfb6296ef53fa3cc0791386f571ed134ef682c65 Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Tue, 11 Apr 2023 23:00:03 +0200
Subject: [PATCH 03/20] oops

---
 src/frontend/qt_sdl/CMakeLists.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/frontend/qt_sdl/CMakeLists.txt b/src/frontend/qt_sdl/CMakeLists.txt
index a767972c8..0ae6ecea7 100644
--- a/src/frontend/qt_sdl/CMakeLists.txt
+++ b/src/frontend/qt_sdl/CMakeLists.txt
@@ -24,7 +24,6 @@ set(SOURCES_QT_SDL
     ROMInfoDialog.cpp
     RAMInfoDialog.cpp
     TitleManagerDialog.cpp
-    RTCSettingsDialog.cpp
     Input.cpp
     LAN_PCap.cpp
     LAN_Socket.cpp

From eeb651d07acf015d473d6e55de2d60e50eec7096 Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Thu, 13 Apr 2023 22:50:27 +0200
Subject: [PATCH 04/20] it works!

diff --git a/src/GPU.cpp b/src/GPU.cpp
index f51748b67..23db96696 100644
--- a/src/GPU.cpp
+++ b/src/GPU.cpp
@@ -397,7 +397,7 @@ void InitRenderer(int renderer)
             GPU3D::CurrentRenderer = std::make_unique<GPU3D::SoftRenderer>();
             GPU3D::CurrentRenderer->Init();
         }
-        GPU3D::CurrentRenderer = std::make_unique<GPU3D::GLRenderer>();
+        GPU3D::CurrentRenderer = std::make_unique<GPU3D::ComputeRenderer>();
         if (!GPU3D::CurrentRenderer->Init())
         {
             // Fallback on software renderer
diff --git a/src/GPU2D_Soft.cpp b/src/GPU2D_Soft.cpp
index 66095e179..a67897d8a 100644
--- a/src/GPU2D_Soft.cpp
+++ b/src/GPU2D_Soft.cpp
@@ -367,7 +367,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();
+            //reinterpret_cast<GPU3D::GLRenderer*>(GPU3D::CurrentRenderer.get())->PrepareCaptureFrame();
         }
     }
 #endif
diff --git a/src/GPU3D.h b/src/GPU3D.h
index a78240120..f6377bd12 100644
--- a/src/GPU3D.h
+++ b/src/GPU3D.h
@@ -159,6 +159,8 @@ class Renderer3D
     virtual void RenderFrame() = 0;
     virtual void RestartFrame() {};
     virtual u32* GetLine(int line) = 0;
+
+    virtual void SetupAccelFrame() {}
 };
 
 extern int Renderer;
diff --git a/src/GPU3D_Compute.cpp b/src/GPU3D_Compute.cpp
index de8b33936..d346a6870 100644
--- a/src/GPU3D_Compute.cpp
+++ b/src/GPU3D_Compute.cpp
@@ -99,6 +99,14 @@ bool ComputeRenderer::Init()
     glBindTexture(GL_TEXTURE_BUFFER, YSpanIndicesTexture);
     glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA16UI, YSpanIndicesTextureMemory);
 
+    glGenTextures(1, &Framebuffer);
+    glBindTexture(GL_TEXTURE_2D, Framebuffer);
+    glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 256, 192);
+
+    glGenBuffers(1, &MetaUniformMemory);
+    glBindBuffer(GL_UNIFORM_BUFFER, MetaUniformMemory);
+    glBufferData(GL_UNIFORM_BUFFER, sizeof(MetaUniform), nullptr, GL_DYNAMIC_DRAW);
+
     CompileShader(ShaderInterpXSpans[0], ComputeRendererShaders::InterpSpans, {"InterpSpans", "ZBuffer"});
     CompileShader(ShaderInterpXSpans[1], ComputeRendererShaders::InterpSpans, {"InterpSpans", "WBuffer"});
     CompileShader(ShaderBinCombined, ComputeRendererShaders::BinCombined, {"BinCombined"});
@@ -133,6 +141,19 @@ bool ComputeRenderer::Init()
     CompileShader(ShaderFinalPass[6], ComputeRendererShaders::FinalPass, {"FinalPass", "AntiAliasing", "Fog"});
     CompileShader(ShaderFinalPass[7], ComputeRendererShaders::FinalPass, {"FinalPass", "AntiAliasing", "EdgeMarking", "Fog"});
 
+    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);
+        }
+    }
+
     return true;
 }
 
@@ -143,23 +164,17 @@ void ComputeRenderer::DeInit()
 
 void ComputeRenderer::Reset()
 {
-    /*for (u32 i = 0; i < 8; i++)
+    for (u32 i = 0; i < 8; i++)
     {
         for (u32 j = 0; j < 8; j++)
         {
             for (u32 k = 0; k < TexArrays[i][j].size(); k++)
-                Gfx::TextureHeap->Free(TexArrays[i][j][k].Memory);
+                glDeleteTextures(1, &TexArrays[i][j][k]);
             TexArrays[i][j].clear();
             FreeTextures[i][j].clear();
         }
-    }*/
-    TexCache.clear();
-
-    FreeImageDescriptorsCount = TexCacheMaxImages;
-    for (int i = 0; i < TexCacheMaxImages; i++)
-    {
-        FreeImageDescriptors[i] = i;
     }
+    TexCache.clear();
 }
 
 void ComputeRenderer::SetRenderSettings(GPU::RenderSettings& settings)
@@ -401,28 +416,6 @@ inline u16 Color3of5(u16 color0, u16 color1)
     return r | g | b;
 }
 
-/*
-inline void RGB5ToRGB6(uint8x16_t lo, uint8x16_t hi, uint8x16_t& red, uint8x16_t& green, uint8x16_t& blue)
-{
-    red = vandq_u8(vshlq_n_u8(lo, 1), vdupq_n_u8(0x3E));
-    green = vbslq_u8(vdupq_n_u8(0xCE), vshrq_n_u8(lo, 4), vshlq_n_u8(hi, 4));
-    blue = vandq_u8(vshrq_n_u8(hi, 1), vdupq_n_u8(0x3E));
-    red = vandq_u8(vtstq_u8(red, red), vaddq_u8(red, vdupq_n_u8(1)));
-    green = vandq_u8(vtstq_u8(green, green), vaddq_u8(green, vdupq_n_u8(1)));
-    blue =  vandq_u8(vtstq_u8(blue, blue), vaddq_u8(blue, vdupq_n_u8(1)));
-}
-
-inline void RGB5ToRGB6(uint8x8_t lo, uint8x8_t hi, uint8x8_t& red, uint8x8_t& green, uint8x8_t& blue)
-{
-    red   = vand_u8(vshl_n_u8(lo, 1), vdup_n_u8(0x3E));
-    green = vbsl_u8(vdup_n_u8(0xCE), vshr_n_u8(lo, 4), vshl_n_u8(hi, 4));
-    blue  = vand_u8(vshr_n_u8(hi, 1), vdup_n_u8(0x3E));
-
-    red   = vand_u8(vtst_u8(red, red), vadd_u8(red, vdup_n_u8(1)));
-    green = vand_u8(vtst_u8(green, green), vadd_u8(green, vdup_n_u8(1)));
-    blue  = vand_u8(vtst_u8(blue, blue), vadd_u8(blue, vdup_n_u8(1)));
-}*/
-
 inline u32 ConvertRGB5ToRGB8(u16 val)
 {
     return (((u32)val & 0x1F) << 3)
@@ -555,7 +548,7 @@ void ConvertCompressedTexture(u32 width, u32 height, u32* output, u8* texData, u
 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 y = 0; y < height; y++)
     {
         for (int x = 0; x < width; x++)
         {
@@ -578,43 +571,7 @@ void ConvertAXIYTexture(u32 width, u32 height, u32* output, u8* texData, u16* pa
             }
             output[x + y * width] = res;
         }
-    }*/
-}
-
-void Convert16ColorsTexture(u32 width, u32 height, u32* output, u8* texData, u16* palData, bool color0Transparent)
-{
-    /*uint8x16x2_t palette = vld2q_u8((u8*)palData);
-
-    uint8x16_t paletteR, paletteG, paletteB;
-    RGB5ToRGB6(palette.val[0], palette.val[1], paletteR, paletteG, paletteB);
-
-    uint8x16_t firstEntryAlpha = vdupq_n_u8(color0Transparent ? 0 : 0x1F);
-
-    for (int i = 0; i < width*height/2; i += 16)
-    {
-        uint8x16_t packedIndices = vld1q_u8(&texData[i]);
-
-        // unpack indices
-        uint8x16_t oddIndices = vandq_u8(packedIndices, vdupq_n_u8(0xF));
-        uint8x16_t evenIndices = vshrq_n_u8(packedIndices, 4);
-
-        uint8x16_t indices0 = vzip1q_u8(oddIndices, evenIndices);
-        uint8x16_t indices1 = vzip2q_u8(oddIndices, evenIndices);
-
-        // palettise
-        uint8x16x4_t finalPixels0, finalPixels1;
-        finalPixels0.val[0] = vqtbl1q_u8(paletteR, indices0);
-        finalPixels0.val[1] = vqtbl1q_u8(paletteG, indices0);
-        finalPixels0.val[2] = vqtbl1q_u8(paletteB, indices0);
-        finalPixels0.val[3] = vbslq_u8(vceqzq_u8(indices0), firstEntryAlpha, vdupq_n_u8(0x1F));
-        finalPixels1.val[0] = vqtbl1q_u8(paletteR, indices1);
-        finalPixels1.val[1] = vqtbl1q_u8(paletteG, indices1);
-        finalPixels1.val[2] = vqtbl1q_u8(paletteB, indices1);
-        finalPixels1.val[3] = vbslq_u8(vceqzq_u8(indices1), firstEntryAlpha, vdupq_n_u8(0x1F));
-
-        vst4q_u8((u8*)&output[i*2], finalPixels0);
-        vst4q_u8((u8*)&output[i*2+16], finalPixels1);
-    }*/
+    }
 }
 
 template <int outputFmt, int colorBits>
@@ -688,22 +645,12 @@ ComputeRenderer::TexCacheEntry& ComputeRenderer::GetTexture(u32 texParam, u32 pa
     {
         entry.TextureRAMSize[0] = width*height*2;
 
-        /*for (u32 i = 0; i < width*height; i += 16)
+        for (u32 i = 0; i < width*height; i += 2)
         {
-            uint8x16x2_t pixels = vld2q_u8(&GPU::VRAMFlat_Texture[addr + i * 2]);
+            u16 value = *(u16*)&GPU::VRAMFlat_Texture[addr + i * 2];
 
-            uint8x16_t red, green, blue;
-            RGB5ToRGB6(pixels.val[0], pixels.val[1], red, green, blue);
-            uint8x16_t alpha = vbslq_u8(vtstq_u8(pixels.val[1], vdupq_n_u8(0x80)), vdupq_n_u8(0x1F), vdupq_n_u8(0));
-
-            vst4q_u8((u8*)&TextureDecodingBuffer[i],
-            {
-                red,
-                green,
-                blue,
-                alpha
-            });
-        }*/
+            TextureDecodingBuffer[i] = ConvertRGB5ToRGB6(value);
+        }
     }
     else if (fmt == 5)
     {
@@ -756,7 +703,7 @@ ComputeRenderer::TexCacheEntry& ComputeRenderer::GetTexture(u32 texParam, u32 pa
         case 1: ConvertAXIYTexture<outputFmt_RGB6A5, 3, 5>(width, height, TextureDecodingBuffer, texData, palData); break;
         case 6: ConvertAXIYTexture<outputFmt_RGB6A5, 5, 3>(width, height, TextureDecodingBuffer, texData, palData); break;
         case 2: ConvertNColorsTexture<outputFmt_RGB6A5, 2>(width, height, TextureDecodingBuffer, texData, palData, color0Transparent); break;
-        case 3: Convert16ColorsTexture(width, height, TextureDecodingBuffer, texData, palData, color0Transparent); break;
+        case 3: ConvertNColorsTexture<outputFmt_RGB6A5, 4>(width, height, TextureDecodingBuffer, texData, palData, color0Transparent); break;
         case 4: ConvertNColorsTexture<outputFmt_RGB6A5, 8>(width, height, TextureDecodingBuffer, texData, palData, color0Transparent); break;
         }
     }
@@ -772,55 +719,36 @@ ComputeRenderer::TexCacheEntry& ComputeRenderer::GetTexture(u32 texParam, u32 pa
     auto& texArrays = TexArrays[widthLog2][heightLog2];
     auto& freeTextures = FreeTextures[widthLog2][heightLog2];
 
-    /*if (freeTextures.size() == 0)
+    if (freeTextures.size() == 0)
     {
         texArrays.resize(texArrays.size()+1);
-        TexArray& array = texArrays[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
-        dk::ImageLayout imageLayout;
-        dk::ImageLayoutMaker{Gfx::Device}
-            .setType(DkImageType_2DArray)
-            .setFormat(DkImageFormat_RGBA8_Uint)
-            .setDimensions(width, height, layers)
-            .initialize(imageLayout);
-
-        assert(FreeImageDescriptorsCount > 0);
-        array.ImageDescriptor = FreeImageDescriptors[--FreeImageDescriptorsCount];
-
-        array.Memory = Gfx::TextureHeap->Alloc(imageLayout.getSize(), imageLayout.getAlignment());
-        array.Image.initialize(imageLayout, Gfx::TextureHeap->MemBlock, array.Memory.Offset);
-
-        dk::ImageDescriptor descriptor;
-        descriptor.initialize(array.Image);
-        DkGpuAddr descriptors = Gfx::DataHeap->GpuAddr(ImageDescriptors);
-        EmuCmdBuf.pushData(descriptors + (descriptorOffset_TexcacheStart + array.ImageDescriptor) * sizeof(DkImageDescriptor),
-            &descriptor,
-            sizeof(DkImageDescriptor));
-
+        glGenTextures(1, &array);
+        glBindTexture(GL_TEXTURE_2D_ARRAY, array);
+        glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8UI, width, height, layers);
         //printf("allocating new layer set for %d %d %d %d\n", width, height, texArrays.size()-1, array.ImageDescriptor);
 
-        for (u16 i = 0; i < layers; i++)
+        for (u32 i = 0; i < layers; i++)
         {
-            freeTextures.push_back(TexArrayEntry{(u16)(texArrays.size()-1), i});
+            freeTextures.push_back(TexArrayEntry{array, i});
         }
-    }*/
+    }
 
     TexArrayEntry storagePlace = freeTextures[freeTextures.size()-1];
     freeTextures.pop_back();
 
-    TexArray& array = texArrays[storagePlace.TexArrayIdx];
     //printf("using storage place %d %d | %d %d (%d)\n", width, height, storagePlace.TexArrayIdx, storagePlace.LayerIdx, array.ImageDescriptor);
 
-    /*UploadBuf.UploadAndCopyTexture(Gfx::EmuCmdBuf, array.Image,
-        (u8*)TextureDecodingBuffer,
-        0, 0, width, height,
-        width*4,
-        storagePlace.LayerIdx);*/
+    glBindTexture(GL_TEXTURE_2D_ARRAY, storagePlace.TextureID);
+    glTexSubImage3D(GL_TEXTURE_2D_ARRAY,
+        0, 0, 0, storagePlace.Layer,
+        width, height, 1,
+        GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, TextureDecodingBuffer);
 
-    entry.DescriptorIdx = array.ImageDescriptor;
     entry.Texture = storagePlace;
 
     return TexCache.emplace(std::make_pair(key, entry)).first->second;
@@ -828,7 +756,7 @@ ComputeRenderer::TexCacheEntry& ComputeRenderer::GetTexture(u32 texParam, u32 pa
 
 struct Variant
 {
-    s16 Texture, Sampler;
+    GLuint Texture, Sampler;
     u16 Width, Height;
     u8 BlendMode;
 
@@ -841,11 +769,11 @@ struct Variant
 /*
     Antialiasing
     W-Buffer
-    Mit Textur
+    With Texture
     0
     1, 3
     2
-    Ohne Textur
+    without Texture
     2
     0, 1, 3
 
@@ -925,6 +853,18 @@ void ComputeRenderer::RenderFrame()
     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];
 
@@ -951,6 +891,8 @@ void ComputeRenderer::RenderFrame()
         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
@@ -964,9 +906,10 @@ void ComputeRenderer::RenderFrame()
         {
             Variant variant;
             variant.BlendMode = polygon->IsShadowMask ? 4 : ((polygon->Attr >> 4) & 0x3);
-            variant.Texture = -1;
-            variant.Sampler = -1;
+            variant.Texture = 0;
+            variant.Sampler = 0;
             TexCacheEntry* texcacheEntry = nullptr;
+            // we always need to look up the texture to get the layer of the array texture
             if (enableTextureMaps && (polygon->TexParam >> 26) & 0x7)
             {
                 texcacheEntry = &GetTexture(polygon->TexParam, polygon->TexPalette);
@@ -974,9 +917,10 @@ void ComputeRenderer::RenderFrame()
                 bool wrapT = (polygon->TexParam >> 17) & 1;
                 bool mirrorS = (polygon->TexParam >> 18) & 1;
                 bool mirrorT = (polygon->TexParam >> 19) & 1;
-                variant.Sampler = (wrapS ? (mirrorS ? 2 : 1) : 0) + (wrapT ? (mirrorT ? 2 : 1) : 0) * 3;
-                variant.Texture = texcacheEntry->DescriptorIdx;
-                prevTexLayer = texcacheEntry->Texture.LayerIdx;
+                variant.Sampler = Samplers[(wrapS ? (mirrorS ? 2 : 1) : 0) + (wrapT ? (mirrorT ? 2 : 1) : 0) * 3];
+                variant.Texture = texcacheEntry->Texture.TextureID;
+                prevTexLayer = texcacheEntry->Texture.Layer;
+
                 if (texcacheEntry->LastVariant < numVariants && variants[texcacheEntry->LastVariant] == variant)
                 {
                     foundVariant = true;
@@ -1272,7 +1216,8 @@ void ComputeRenderer::RenderFrame()
         u32 fogA = (RenderFogColor >> 16) & 0x1F;
         meta.FogColor = fogR | (fogG << 8) | (fogB << 16) | (fogA << 24);
     }
-    meta.XScroll = RenderXPos;
+    meta.XScroll = 0;
+    //meta.XScroll = RenderXPos;
 
     glBindBuffer(GL_UNIFORM_BUFFER, MetaUniformMemory);
     glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(MetaUniform), &meta);
@@ -1312,6 +1257,8 @@ void ComputeRenderer::RenderFrame()
         glDispatchComputeIndirect(offsetof(BinResult, SortWorkWorkCount));
         glMemoryBarrier(GL_SHADER_STORAGE_BUFFER);
 
+        glActiveTexture(GL_TEXTURE0);
+
         // rasterise
         {
             bool highLightMode = RenderDispCnt & (1<<1);
@@ -1338,7 +1285,7 @@ void ComputeRenderer::RenderFrame()
             };
 
             GLuint prevShader = 0;
-            s32 prevTexture = -1, prevSampler = -1;
+            s32 prevTexture = 0, prevSampler = 0;
             for (int i = 0; i < numVariants; i++)
             {
                 GLuint shader = 0;
@@ -1349,11 +1296,14 @@ void ComputeRenderer::RenderFrame()
                 else
                 {
                     shader = shadersUseTexture[variants[i].BlendMode];
-                    if (variants[i].Texture != prevTexture || variants[i].Sampler != prevSampler)
+                    if (variants[i].Texture != prevTexture)
                     {
-                        assert(variants[i].Sampler < 9);
-                        glBindTexture(GL_TEXTURE_2D, variants[i].Texture);
+                        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;
                     }
                 }
@@ -1364,7 +1314,7 @@ void ComputeRenderer::RenderFrame()
                     prevShader = shader;
                 }
 
-                glUniform1i(UniformIdxCurVariant, i);
+                glUniform1ui(UniformIdxCurVariant, i);
                 glUniform2f(UniformIdxTextureSize, 1.f / variants[i].Width, 1.f / variants[i].Height);
                 glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, BinResultMemory);
                 glDispatchComputeIndirect(offsetof(BinResult, VariantWorkCount) + i*4*4);
@@ -1378,7 +1328,7 @@ void ComputeRenderer::RenderFrame()
     glDispatchCompute(256/8, 192/8, 1);
     glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
 
-    //glBindTexture(GL_TEXTURE_2D, )
+    glBindImageTexture(0, Framebuffer, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8);
     u32 finalPassShader = 0;
     if (RenderDispCnt & (1<<4))
         finalPassShader |= 0x4;
@@ -1448,4 +1398,9 @@ u32* ComputeRenderer::GetLine(int line)
     return DummyLine;
 }
 
+void ComputeRenderer::SetupAccelFrame()
+{
+    glBindTexture(GL_TEXTURE_2D, Framebuffer);
+}
+
 }
\ No newline at end of file
diff --git a/src/GPU3D_Compute.h b/src/GPU3D_Compute.h
index 5278c76ca..ee5f9bd29 100644
--- a/src/GPU3D_Compute.h
+++ b/src/GPU3D_Compute.h
@@ -48,8 +48,7 @@ class ComputeRenderer : public Renderer3D
     void RestartFrame() override;
     u32* GetLine(int line) override;
 
-    //dk::Fence FrameReady = {};
-    //dk::Fence FrameReserveFence = {};
+    void SetupAccelFrame() override;
 private:
     GLuint ShaderInterpXSpans[2];
     GLuint ShaderBinCombined;
@@ -197,18 +196,12 @@ class ComputeRenderer : public Renderer3D
 
     struct TexArrayEntry
     {
-        u16 TexArrayIdx;
-        u16 LayerIdx;
-    };
-    struct TexArray
-    {
-        GLuint Image;
-        u32 ImageDescriptor;
+        GLuint TextureID;
+        u32 Layer;
     };
 
     struct TexCacheEntry
     {
-        u32 DescriptorIdx;
         u32 LastVariant; // very cheap way to make variant lookup faster
 
         u32 TextureRAMStart[2], TextureRAMSize[2];
@@ -239,16 +232,15 @@ class ComputeRenderer : public Renderer3D
     };
     GLuint MetaUniformMemory;
 
-    static const u32 TexCacheMaxImages = 4096;
-
-    u32 FreeImageDescriptorsCount = 0;
-    u32 FreeImageDescriptors[TexCacheMaxImages];
-
     std::vector<TexArrayEntry> FreeTextures[8][8];
-    std::vector<TexArray> TexArrays[8][8];
+    std::vector<GLuint> TexArrays[8][8];
+
+    GLuint Samplers[9];
 
     u32 TextureDecodingBuffer[1024*1024];
 
+    GLuint Framebuffer;
+
     TexCacheEntry& GetTexture(u32 textureParam, u32 paletteParam);
 
     void SetupAttrs(SpanSetupY* span, Polygon* poly, int from, int to);
diff --git a/src/GPU3D_Compute_shaders.h b/src/GPU3D_Compute_shaders.h
index d770658cf..786f66c9f 100644
--- a/src/GPU3D_Compute_shaders.h
+++ b/src/GPU3D_Compute_shaders.h
@@ -223,13 +223,8 @@ layout (std140, binding = 0) uniform MetaUniform
     uint FogOffset, FogShift, FogColor;
 
     int XScroll;
-
-    // only used/updated for rasteriation
-    uint CurVariant;
-    vec2 InvTextureSize;
 };
 
-
 #if defined(InterpSpans) || defined(Rasterise)
 uint Umulh(uint a, uint b)
 {
@@ -920,6 +915,9 @@ 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 = SortedWork[SortedWorkOffset[CurVariant] + gl_WorkGroupID.z];
@@ -1328,7 +1326,7 @@ const char* FinalPass = R"(
 
 layout (local_size_x = 32) in;
 
-layout (binding = 0, r32ui) writeonly uniform uimage2D FinalFB; 
+layout (binding = 0, rgba8) writeonly uniform image2D FinalFB; 
 
 uint BlendFog(uint color, uint depth)
 {
@@ -1482,15 +1480,17 @@ void main()
     }
 #endif
 
-    if (bitfieldExtract(color.x, 24, 8) != 0U)
-        color.x |= 0x40000000U;
-    else
-        color.x = 0U;
+//    if (bitfieldExtract(color.x, 24, 8) != 0U)
+//        color.x |= 0x40000000U;
+//    else
+//        color.x = 0U;
 
     //if (gl_LocalInvocationID.x == 7 || gl_LocalInvocationID.y == 7)
         //color.x = 0x1F00001FU | 0x40000000U;
 
-    imageStore(FinalFB, ivec2(gl_GlobalInvocationID.xy), uvec4(color.x, 0, 0, 0));
+    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);
 }
 
 )";
diff --git a/src/GPU3D_OpenGL.h b/src/GPU3D_OpenGL.h
index fabf6f107..f2d8349ae 100644
--- a/src/GPU3D_OpenGL.h
+++ b/src/GPU3D_OpenGL.h
@@ -40,7 +40,7 @@ class GLRenderer : public Renderer3D
     virtual void RenderFrame() override;
     virtual u32* GetLine(int line) override;
 
-    void SetupAccelFrame();
+    void SetupAccelFrame() override;
     void PrepareCaptureFrame();
 private:
 
diff --git a/src/GPU_OpenGL.cpp b/src/GPU_OpenGL.cpp
index 7f1b04834..55c2c7c1c 100644
--- a/src/GPU_OpenGL.cpp
+++ b/src/GPU_OpenGL.cpp
@@ -212,7 +212,7 @@ void GLCompositor::RenderFrame()
     }
 
     glActiveTexture(GL_TEXTURE1);
-    reinterpret_cast<GPU3D::GLRenderer*>(GPU3D::CurrentRenderer.get())->SetupAccelFrame();
+    GPU3D::CurrentRenderer->SetupAccelFrame();
 
     glBindBuffer(GL_ARRAY_BUFFER, CompVertexBufferID);
     glBindVertexArray(CompVertexArrayID);

From ba0139fa63bb9da9fa202af8339a6205f7424595 Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Thu, 13 Apr 2023 23:14:20 +0200
Subject: [PATCH 05/20] implement display capture for compute renderer it's
 actually just all stolen from the regular OpenGL renderer

diff --git a/src/GPU2D_Soft.cpp b/src/GPU2D_Soft.cpp
index a67897d8a..66095e179 100644
--- a/src/GPU2D_Soft.cpp
+++ b/src/GPU2D_Soft.cpp
@@ -367,7 +367,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();
+            reinterpret_cast<GPU3D::GLRenderer*>(GPU3D::CurrentRenderer.get())->PrepareCaptureFrame();
         }
     }
 #endif
diff --git a/src/GPU3D.h b/src/GPU3D.h
index f6377bd12..f229e66f4 100644
--- a/src/GPU3D.h
+++ b/src/GPU3D.h
@@ -161,6 +161,7 @@ class Renderer3D
     virtual u32* GetLine(int line) = 0;
 
     virtual void SetupAccelFrame() {}
+    virtual void PrepareCaptureFrame() {}
 };
 
 extern int Renderer;
diff --git a/src/GPU3D_Compute.cpp b/src/GPU3D_Compute.cpp
index d346a6870..40222de04 100644
--- a/src/GPU3D_Compute.cpp
+++ b/src/GPU3D_Compute.cpp
@@ -154,12 +154,15 @@ bool ComputeRenderer::Init()
         }
     }
 
+    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()
 {
-
 }
 
 void ComputeRenderer::Reset()
@@ -1395,7 +1398,26 @@ void ComputeRenderer::RestartFrame()
 
 u32* ComputeRenderer::GetLine(int line)
 {
-    return DummyLine;
+    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);
+    }
+
+    u64* ptr = (u64*)&FramebufferCPU[stride * line];
+    for (int i = 0; i < stride; i+=2)
+    {
+        u64 rgb = *ptr & 0x00FCFCFC00FCFCFC;
+        u64 a = *ptr & 0xF8000000F8000000;
+
+        *ptr++ = (rgb >> 2) | (a >> 3);
+    }
+
+    return &FramebufferCPU[stride * line];
 }
 
 void ComputeRenderer::SetupAccelFrame()
@@ -1403,4 +1425,11 @@ void ComputeRenderer::SetupAccelFrame()
     glBindTexture(GL_TEXTURE_2D, Framebuffer);
 }
 
+void ComputeRenderer::PrepareCaptureFrame()
+{
+    glBindBuffer(GL_PIXEL_PACK_BUFFER, PixelBuffer);
+    glBindTexture(GL_TEXTURE_2D, Framebuffer);
+    glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_BYTE, nullptr);
+}
+
 }
\ No newline at end of file
diff --git a/src/GPU3D_Compute.h b/src/GPU3D_Compute.h
index ee5f9bd29..f417aa966 100644
--- a/src/GPU3D_Compute.h
+++ b/src/GPU3D_Compute.h
@@ -49,6 +49,7 @@ class ComputeRenderer : public Renderer3D
     u32* GetLine(int line) override;
 
     void SetupAccelFrame() override;
+    void PrepareCaptureFrame() override;
 private:
     GLuint ShaderInterpXSpans[2];
     GLuint ShaderBinCombined;
@@ -240,6 +241,9 @@ class ComputeRenderer : public Renderer3D
     u32 TextureDecodingBuffer[1024*1024];
 
     GLuint Framebuffer;
+    GLuint PixelBuffer;
+
+    u32 FramebufferCPU[256*192];
 
     TexCacheEntry& GetTexture(u32 textureParam, u32 paletteParam);
 
diff --git a/src/GPU3D_OpenGL.cpp b/src/GPU3D_OpenGL.cpp
index c57b1c7c3..517f481d7 100644
--- a/src/GPU3D_OpenGL.cpp
+++ b/src/GPU3D_OpenGL.cpp
@@ -1262,6 +1262,7 @@ void GLRenderer::PrepareCaptureFrame()
     glDrawBuffer(GL_COLOR_ATTACHMENT0);
     glBlitFramebuffer(0, 0, ScreenW, ScreenH, 0, 0, 256, 192, GL_COLOR_BUFFER_BIT, GL_NEAREST);
 
+    glBindBuffer(GL_PIXEL_PACK_BUFFER, PixelbufferID);
     glBindFramebuffer(GL_READ_FRAMEBUFFER, DownscaleFramebuffer);
     glReadPixels(0, 0, 256, 192, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
 }
@@ -1272,6 +1273,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);
diff --git a/src/GPU3D_OpenGL.h b/src/GPU3D_OpenGL.h
index f2d8349ae..cb3bd7cbf 100644
--- a/src/GPU3D_OpenGL.h
+++ b/src/GPU3D_OpenGL.h
@@ -41,7 +41,7 @@ class GLRenderer : public Renderer3D
     virtual u32* GetLine(int line) override;
 
     void SetupAccelFrame() override;
-    void PrepareCaptureFrame();
+    void PrepareCaptureFrame() override;
 private:
 
     // GL version requirements

From b530b4d7b684667e002a08d5bd15bce0987e1a0c Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Thu, 13 Apr 2023 23:15:22 +0200
Subject: [PATCH 06/20] fix bad indirect call

---
 src/GPU2D_Soft.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GPU2D_Soft.cpp b/src/GPU2D_Soft.cpp
index 66095e179..54027f465 100644
--- a/src/GPU2D_Soft.cpp
+++ b/src/GPU2D_Soft.cpp
@@ -367,7 +367,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

From 89ea4e894bc6996c4e7614797403690f519a1d39 Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Thu, 13 Apr 2023 23:38:38 +0200
Subject: [PATCH 07/20] handle cleanup properly

---
 src/GPU3D_Compute.cpp | 61 ++++++++++++++++++++++++++++++++++++++++++-
 src/GPU3D_Compute.h   |  2 ++
 2 files changed, 62 insertions(+), 1 deletion(-)

diff --git a/src/GPU3D_Compute.cpp b/src/GPU3D_Compute.cpp
index 40222de04..55ad21b00 100644
--- a/src/GPU3D_Compute.cpp
+++ b/src/GPU3D_Compute.cpp
@@ -163,9 +163,63 @@ bool ComputeRenderer::Init()
 
 void ComputeRenderer::DeInit()
 {
+    ResetTexcache();
+
+    glDeleteBuffers(1, &YSpanSetupMemory);
+    glDeleteBuffers(1, &RenderPolygonMemory);
+    glDeleteBuffers(1, &TileMemory);
+    glDeleteBuffers(1, &XSpanSetupMemory);
+    glDeleteBuffers(1, &BinResultMemory);
+    glDeleteBuffers(1, &FinalTileMemory);
+    glDeleteBuffers(1, &YSpanIndicesTextureMemory);
+    glDeleteTextures(1, &YSpanIndicesTexture);
+    glDeleteTextures(1, &Framebuffer);
+    glDeleteBuffers(1, &MetaUniformMemory);
+
+    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);
+
+    glDeleteSamplers(9, Samplers);
+    glDeleteBuffers(1, &PixelBuffer);
 }
 
-void ComputeRenderer::Reset()
+void ComputeRenderer::ResetTexcache()
 {
     for (u32 i = 0; i < 8; i++)
     {
@@ -180,6 +234,11 @@ void ComputeRenderer::Reset()
     TexCache.clear();
 }
 
+void ComputeRenderer::Reset()
+{
+    ResetTexcache();
+}
+
 void ComputeRenderer::SetRenderSettings(GPU::RenderSettings& settings)
 {
 
diff --git a/src/GPU3D_Compute.h b/src/GPU3D_Compute.h
index f417aa966..9b83b38c8 100644
--- a/src/GPU3D_Compute.h
+++ b/src/GPU3D_Compute.h
@@ -247,6 +247,8 @@ class ComputeRenderer : public Renderer3D
 
     TexCacheEntry& GetTexture(u32 textureParam, u32 paletteParam);
 
+    void ResetTexcache();
+
     void SetupAttrs(SpanSetupY* span, Polygon* poly, int from, int to);
     void SetupYSpan(int polynum, SpanSetupY* span, Polygon* poly, int from, int to, u32 y, int side);
     void SetupYSpanDummy(SpanSetupY* span, Polygon* poly, int vertex, int side);

From 9f0b24393ef1c9edde3e4f6990b50d9944dcb55d Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Mon, 17 Apr 2023 00:07:47 +0200
Subject: [PATCH 08/20] add hires rendering to the compute shader renderer

---
 src/GPU3D_Compute.cpp       | 304 ++++++++++++++++++++----------------
 src/GPU3D_Compute.h         |  64 +++-----
 src/GPU3D_Compute_shaders.h | 193 +++++++++++++++++------
 3 files changed, 331 insertions(+), 230 deletions(-)

diff --git a/src/GPU3D_Compute.cpp b/src/GPU3D_Compute.cpp
index 55ad21b00..5421708e9 100644
--- a/src/GPU3D_Compute.cpp
+++ b/src/GPU3D_Compute.cpp
@@ -52,6 +52,13 @@ bool ComputeRenderer::CompileShader(GLuint& shader, const char* source, const st
         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;
 
@@ -65,8 +72,8 @@ void blah(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,con
 
 bool ComputeRenderer::Init()
 {
-    glDebugMessageCallback(blah, NULL);
-    glEnable(GL_DEBUG_OUTPUT);
+    //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);
@@ -75,72 +82,22 @@ bool ComputeRenderer::Init()
     glBindBuffer(GL_SHADER_STORAGE_BUFFER, RenderPolygonMemory);
     glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(RenderPolygon)*2048, nullptr, GL_DYNAMIC_DRAW);
 
-    glGenBuffers(1, &TileMemory);
-    glBindBuffer(GL_SHADER_STORAGE_BUFFER, TileMemory);
-    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(Tiles), nullptr, GL_DYNAMIC_DRAW);
-
     glGenBuffers(1, &XSpanSetupMemory);
-    glBindBuffer(GL_SHADER_STORAGE_BUFFER, XSpanSetupMemory);
-    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(SpanSetupX)*MaxYSpanIndices, nullptr, GL_DYNAMIC_DRAW);
-
     glGenBuffers(1, &BinResultMemory);
-    glBindBuffer(GL_SHADER_STORAGE_BUFFER, BinResultMemory);
-    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(BinResult), nullptr, GL_DYNAMIC_DRAW);
-
     glGenBuffers(1, &FinalTileMemory);
-    glBindBuffer(GL_SHADER_STORAGE_BUFFER, FinalTileMemory);
-    glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(FinalTiles), nullptr, GL_DYNAMIC_DRAW);
-
     glGenBuffers(1, &YSpanIndicesTextureMemory);
-    glBindBuffer(GL_TEXTURE_BUFFER, YSpanIndicesTextureMemory);
-    glBufferData(GL_TEXTURE_BUFFER, MaxYSpanIndices*2*4, nullptr, GL_DYNAMIC_DRAW);
+    glGenBuffers(1, &TileMemory);
 
     glGenTextures(1, &YSpanIndicesTexture);
-    glBindTexture(GL_TEXTURE_BUFFER, YSpanIndicesTexture);
-    glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA16UI, YSpanIndicesTextureMemory);
-
     glGenTextures(1, &Framebuffer);
-    glBindTexture(GL_TEXTURE_2D, Framebuffer);
-    glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 256, 192);
+    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);
 
-    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"});
-
     glGenSamplers(9, Samplers);
     for (u32 j = 0; j < 3; j++)
     {
@@ -176,6 +133,12 @@ void ComputeRenderer::DeInit()
     glDeleteTextures(1, &Framebuffer);
     glDeleteBuffers(1, &MetaUniformMemory);
 
+    glDeleteSamplers(9, Samplers);
+    glDeleteBuffers(1, &PixelBuffer);
+}
+
+void ComputeRenderer::DeleteShaders()
+{
     std::initializer_list<GLuint> allPrograms =
     {
         ShaderInterpXSpans[0],
@@ -214,9 +177,6 @@ void ComputeRenderer::DeInit()
     };
     for (GLuint program : allPrograms)
         glDeleteProgram(program);
-
-    glDeleteSamplers(9, Samplers);
-    glDeleteBuffers(1, &PixelBuffer);
 }
 
 void ComputeRenderer::ResetTexcache()
@@ -241,7 +201,85 @@ void ComputeRenderer::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;
 
+    MaxWorkTiles = TilesPerLine*TileLines*8;
+
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, TileMemory);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, 4*3*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)
+        + MaxWorkTiles*2*4 // UnsortedWorkDescs
+        + MaxWorkTiles*2*4 // SortedWork
+        + 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);
+
+    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()
@@ -267,9 +305,9 @@ void ComputeRenderer::SetupAttrs(SpanSetupY* span, Polygon* poly, int from, int
     span->TexcoordV1 = poly->Vertices[to]->TexCoords[1];
 }
 
-void ComputeRenderer::SetupYSpanDummy(SpanSetupY* span, Polygon* poly, int vertex, int side)
+void ComputeRenderer::SetupYSpanDummy(SpanSetupY* span, Polygon* poly, int vertex, int side, s32 positions[10][2])
 {
-    s32 x0 = poly->Vertices[vertex]->FinalPosition[0];
+    s32 x0 = positions[vertex][0];
     if (side)
     {
         span->DxInitial = -0x40000;
@@ -283,7 +321,7 @@ void ComputeRenderer::SetupYSpanDummy(SpanSetupY* span, Polygon* poly, int verte
     span->X0 = span->X1 = x0;
     span->XMin = x0;
     span->XMax = x0;
-    span->Y0 = span->Y1 = poly->Vertices[vertex]->FinalPosition[1];
+    span->Y0 = span->Y1 = positions[vertex][1];
 
     span->Increment = 0;
 
@@ -297,12 +335,12 @@ void ComputeRenderer::SetupYSpanDummy(SpanSetupY* span, Polygon* poly, int verte
     SetupAttrs(span, poly, vertex, vertex);
 }
 
-void ComputeRenderer::SetupYSpan(int polynum, SpanSetupY* span, Polygon* poly, int from, int to, u32 y, int side)
+void ComputeRenderer::SetupYSpan(int polynum, SpanSetupY* span, Polygon* poly, int from, int to, u32 y, int side, s32 positions[10][2])
 {
-    span->X0 = poly->Vertices[from]->FinalPosition[0];
-    span->X1 = poly->Vertices[to]->FinalPosition[0];
-    span->Y0 = poly->Vertices[from]->FinalPosition[1];
-    span->Y1 = poly->Vertices[to]->FinalPosition[1];
+    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);
 
@@ -396,9 +434,6 @@ void ComputeRenderer::SetupYSpan(int polynum, SpanSetupY* span, Polygon* poly, i
         span->I1 = span->Y1;
     }
 
-    //if (span->I1 < span->I0)
-    //    std::swap(span->I0, span->I1);
-
     if (span->I0 != span->I1)
         span->IRecip = (1<<30) / (span->I1 - span->I0);
     else
@@ -940,14 +975,11 @@ void ComputeRenderer::RenderFrame()
 
         u32 nverts = polygon->NumVertices;
         u32 vtop = polygon->VTop, vbot = polygon->VBottom;
-        s32 ytop = polygon->YTop, ybot = polygon->YBottom;
 
         u32 curVL = vtop, curVR = vtop;
         u32 nextVL, nextVR;
 
         RenderPolygons[i].FirstXSpan = numSetupIndices;
-        RenderPolygons[i].YTop = ytop;
-        RenderPolygons[i].YBot = ybot;
         RenderPolygons[i].Attr = polygon->Attr;
 
         bool foundVariant = false;
@@ -1034,10 +1066,22 @@ void ComputeRenderer::RenderFrame()
             if (nextVR >= nverts) nextVR = 0;
         }
 
-        s32 minX = polygon->Vertices[vtop]->FinalPosition[0];
-        s32 minXY = polygon->Vertices[vtop]->FinalPosition[1];
-        s32 maxX = polygon->Vertices[vtop]->FinalPosition[0];
-        s32 maxXY = polygon->Vertices[vtop]->FinalPosition[1];
+        s32 scaledPositions[10][2];
+        s32 ytop = ScreenHeight, ybot = 0;
+        for (int i = 0; i < polygon->NumVertices; i++)
+        {
+            scaledPositions[i][0] = (polygon->Vertices[i]->HiresPosition[0] * ScaleFactor) >> 4;
+            scaledPositions[i][1] = (polygon->Vertices[i]->HiresPosition[1] * ScaleFactor) >> 4;
+            ytop = std::min(scaledPositions[i][1], ytop);
+            ybot = std::max(scaledPositions[i][1], ybot);
+        }
+        RenderPolygons[i].YTop = ytop;
+        RenderPolygons[i].YBot = ybot;
+
+        s32 minX = scaledPositions[vtop][0];
+        s32 minXY = scaledPositions[vtop][1];
+        s32 maxX = scaledPositions[vtop][0];
+        s32 maxXY = scaledPositions[vtop][1];
 
         if (ybot == ytop)
         {
@@ -1046,19 +1090,19 @@ void ComputeRenderer::RenderFrame()
             RenderPolygons[i].YBot++;
 
             int j = 1;
-            if (polygon->Vertices[j]->FinalPosition[0] < polygon->Vertices[vtop]->FinalPosition[0]) vtop = j;
-            if (polygon->Vertices[j]->FinalPosition[0] > polygon->Vertices[vbot]->FinalPosition[0]) vbot = j;
+            if (scaledPositions[j][0] < scaledPositions[vtop][0]) vtop = j;
+            if (scaledPositions[j][0] > scaledPositions[vbot][0]) vbot = j;
 
             j = nverts - 1;
-            if (polygon->Vertices[j]->FinalPosition[0] < polygon->Vertices[vtop]->FinalPosition[0]) vtop = j;
-            if (polygon->Vertices[j]->FinalPosition[0] > polygon->Vertices[vbot]->FinalPosition[0]) vbot = j;
+            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(&YSpanSetups[numYSpans++], polygon, vtop, 0);
+            SetupYSpanDummy(&YSpanSetups[numYSpans++], polygon, vtop, 0, scaledPositions);
             assert(numYSpans < MaxYSpanSetups);
             u32 curSpanR = numYSpans;
-            SetupYSpanDummy(&YSpanSetups[numYSpans++], polygon, vbot, 1);
+            SetupYSpanDummy(&YSpanSetups[numYSpans++], polygon, vbot, 1, scaledPositions);
 
             minX = YSpanSetups[curSpanL].X0;
             minXY = YSpanSetups[curSpanL].Y0;
@@ -1070,7 +1114,6 @@ void ComputeRenderer::RenderFrame()
                 std::swap(minXY, maxXY);
             }
 
-            assert(numSetupIndices < MaxYSpanIndices);
             YSpanIndices[numSetupIndices].PolyIdx = i;
             YSpanIndices[numSetupIndices].SpanIdxL = curSpanL;
             YSpanIndices[numSetupIndices].SpanIdxR = curSpanR;
@@ -1081,16 +1124,16 @@ void ComputeRenderer::RenderFrame()
         {
             u32 curSpanL = numYSpans;
             assert(numYSpans < MaxYSpanSetups);
-            SetupYSpan(i, &YSpanSetups[numYSpans++], polygon, curVL, nextVL, ytop, 0);
+            SetupYSpan(i, &YSpanSetups[numYSpans++], polygon, curVL, nextVL, ytop, 0, scaledPositions);
             u32 curSpanR = numYSpans;
             assert(numYSpans < MaxYSpanSetups);
-            SetupYSpan(i, &YSpanSetups[numYSpans++], polygon, curVR, nextVR, ytop, 1);
+            SetupYSpan(i, &YSpanSetups[numYSpans++], polygon, curVR, nextVR, ytop, 1, scaledPositions);
 
             for (u32 y = ytop; y < ybot; y++)
             {
-                if (y >= polygon->Vertices[nextVL]->FinalPosition[1] && curVL != polygon->VBottom)
+                if (y >= scaledPositions[nextVL][1] && curVL != polygon->VBottom)
                 {
-                    while (y >= polygon->Vertices[nextVL]->FinalPosition[1] && curVL != polygon->VBottom)
+                    while (y >= scaledPositions[nextVL][1] && curVL != polygon->VBottom)
                     {
                         curVL = nextVL;
                         if (polygon->FacingView)
@@ -1107,24 +1150,24 @@ void ComputeRenderer::RenderFrame()
                         }
                     }
 
-                    if (polygon->Vertices[curVL]->FinalPosition[0] < minX)
+                    if (scaledPositions[curVL][0] < minX)
                     {
-                        minX = polygon->Vertices[curVL]->FinalPosition[0];
-                        minXY = polygon->Vertices[curVL]->FinalPosition[1];
+                        minX = scaledPositions[curVL][0];
+                        minXY = scaledPositions[curVL][1];
                     }
-                    if (polygon->Vertices[curVL]->FinalPosition[0] > maxX)
+                    if (scaledPositions[curVL][0] > maxX)
                     {
-                        maxX = polygon->Vertices[curVL]->FinalPosition[0];
-                        maxXY = polygon->Vertices[curVL]->FinalPosition[1];
+                        maxX = scaledPositions[curVL][0];
+                        maxXY = scaledPositions[curVL][1];
                     }
 
                     assert(numYSpans < MaxYSpanSetups);
                     curSpanL = numYSpans;
-                    SetupYSpan(i,&YSpanSetups[numYSpans++], polygon, curVL, nextVL, y, 0);
+                    SetupYSpan(i,&YSpanSetups[numYSpans++], polygon, curVL, nextVL, y, 0, scaledPositions);
                 }
-                if (y >= polygon->Vertices[nextVR]->FinalPosition[1] && curVR != polygon->VBottom)
+                if (y >= scaledPositions[nextVR][1] && curVR != polygon->VBottom)
                 {
-                    while (y >= polygon->Vertices[nextVR]->FinalPosition[1] && curVR != polygon->VBottom)
+                    while (y >= scaledPositions[nextVR][1] && curVR != polygon->VBottom)
                     {
                         curVR = nextVR;
                         if (polygon->FacingView)
@@ -1141,23 +1184,22 @@ void ComputeRenderer::RenderFrame()
                         }
                     }
 
-                    if (polygon->Vertices[curVR]->FinalPosition[0] < minX)
+                    if (scaledPositions[curVR][0] < minX)
                     {
-                        minX = polygon->Vertices[curVR]->FinalPosition[0];
-                        minXY = polygon->Vertices[curVR]->FinalPosition[1];
+                        minX = scaledPositions[curVR][0];
+                        minXY = scaledPositions[curVR][1];
                     }
-                    if (polygon->Vertices[curVR]->FinalPosition[0] > maxX)
+                    if (scaledPositions[curVR][0] > maxX)
                     {
-                        maxX = polygon->Vertices[curVR]->FinalPosition[0];
-                        maxXY = polygon->Vertices[curVR]->FinalPosition[1];
+                        maxX = scaledPositions[curVR][0];
+                        maxXY = scaledPositions[curVR][1];
                     }
 
                     assert(numYSpans < MaxYSpanSetups);
                     curSpanR = numYSpans;
-                    SetupYSpan(i,&YSpanSetups[numYSpans++], polygon, curVR, nextVR, y, 1);
+                    SetupYSpan(i,&YSpanSetups[numYSpans++], polygon, curVR, nextVR, y, 1, scaledPositions);
                 }
 
-                assert(numSetupIndices < MaxYSpanIndices);
                 YSpanIndices[numSetupIndices].PolyIdx = i;
                 YSpanIndices[numSetupIndices].SpanIdxL = curSpanL;
                 YSpanIndices[numSetupIndices].SpanIdxR = curSpanR;
@@ -1166,25 +1208,25 @@ void ComputeRenderer::RenderFrame()
             }
         }
 
-        if (polygon->Vertices[nextVL]->FinalPosition[0] < minX)
+        if (scaledPositions[nextVL][0] < minX)
         {
-            minX = polygon->Vertices[nextVL]->FinalPosition[0];
-            minXY = polygon->Vertices[nextVL]->FinalPosition[1];
+            minX = scaledPositions[nextVL][0];
+            minXY = scaledPositions[nextVL][1];
         }
-        if (polygon->Vertices[nextVL]->FinalPosition[0] > maxX)
+        if (scaledPositions[nextVL][0] > maxX)
         {
-            maxX = polygon->Vertices[nextVL]->FinalPosition[0];
-            maxXY = polygon->Vertices[nextVL]->FinalPosition[1];
+            maxX = scaledPositions[nextVL][0];
+            maxXY = scaledPositions[nextVL][1];
         }
-        if (polygon->Vertices[nextVR]->FinalPosition[0] < minX)
+        if (scaledPositions[nextVR][0] < minX)
         {
-            minX = polygon->Vertices[nextVR]->FinalPosition[0];
-            minXY = polygon->Vertices[nextVR]->FinalPosition[1];
+            minX = scaledPositions[nextVR][0];
+            minXY = scaledPositions[nextVR][1];
         }
-        if (polygon->Vertices[nextVR]->FinalPosition[0] > maxX)
+        if (scaledPositions[nextVR][0] > maxX)
         {
-            maxX = polygon->Vertices[nextVR]->FinalPosition[0];
-            maxXY = polygon->Vertices[nextVR]->FinalPosition[1];
+            maxX = scaledPositions[nextVR][0];
+            maxXY = scaledPositions[nextVR][1];
         }
 
         RenderPolygons[i].XMin = minX;
@@ -1210,7 +1252,7 @@ void ComputeRenderer::RenderFrame()
         glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(SpanSetupY)*numYSpans, YSpanSetups);
 
         glBindBuffer(GL_TEXTURE_BUFFER, YSpanIndicesTextureMemory);
-        glBufferSubData(GL_TEXTURE_BUFFER, 0, numSetupIndices*4*2, YSpanIndices);
+        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);
@@ -1278,8 +1320,6 @@ void ComputeRenderer::RenderFrame()
         u32 fogA = (RenderFogColor >> 16) & 0x1F;
         meta.FogColor = fogR | (fogG << 8) | (fogB << 16) | (fogA << 24);
     }
-    meta.XScroll = 0;
-    //meta.XScroll = RenderXPos;
 
     glBindBuffer(GL_UNIFORM_BUFFER, MetaUniformMemory);
     glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(MetaUniform), &meta);
@@ -1304,7 +1344,7 @@ void ComputeRenderer::RenderFrame()
 
         // bin polygons
         glUseProgram(ShaderBinCombined);
-        glDispatchCompute(((RenderNumPolygons + 31) / 32), 256/CoarseTileW, 192/CoarseTileH);
+        glDispatchCompute(((RenderNumPolygons + 31) / 32), ScreenWidth/CoarseTileW, ScreenHeight/CoarseTileH);
         glMemoryBarrier(GL_SHADER_STORAGE_BUFFER);
 
         // calculate list offsets
@@ -1316,7 +1356,7 @@ void ComputeRenderer::RenderFrame()
         // sort shader work
         glUseProgram(ShaderSortWork);
         glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, BinResultMemory);
-        glDispatchComputeIndirect(offsetof(BinResult, SortWorkWorkCount));
+        glDispatchComputeIndirect(offsetof(BinResultHeader, SortWorkWorkCount));
         glMemoryBarrier(GL_SHADER_STORAGE_BUFFER);
 
         glActiveTexture(GL_TEXTURE0);
@@ -1379,7 +1419,7 @@ void ComputeRenderer::RenderFrame()
                 glUniform1ui(UniformIdxCurVariant, i);
                 glUniform2f(UniformIdxTextureSize, 1.f / variants[i].Width, 1.f / variants[i].Height);
                 glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, BinResultMemory);
-                glDispatchComputeIndirect(offsetof(BinResult, VariantWorkCount) + i*4*4);
+                glDispatchComputeIndirect(offsetof(BinResultHeader, VariantWorkCount) + i*4*4);
             }
         }
     }
@@ -1387,10 +1427,11 @@ void ComputeRenderer::RenderFrame()
 
     // compose final image
     glUseProgram(ShaderDepthBlend[wbuffer]);
-    glDispatchCompute(256/8, 192/8, 1);
+    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;
@@ -1400,7 +1441,7 @@ void ComputeRenderer::RenderFrame()
         finalPassShader |= 0x1;
     
     glUseProgram(ShaderFinalPass[finalPassShader]);
-    glDispatchCompute(256/32, 192, 1);
+    glDispatchCompute(ScreenWidth/32, ScreenHeight, 1);
     glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
 
     /*u64 starttime = armGetSystemTick();
@@ -1467,15 +1508,6 @@ u32* ComputeRenderer::GetLine(int line)
         glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
     }
 
-    u64* ptr = (u64*)&FramebufferCPU[stride * line];
-    for (int i = 0; i < stride; i+=2)
-    {
-        u64 rgb = *ptr & 0x00FCFCFC00FCFCFC;
-        u64 a = *ptr & 0xF8000000F8000000;
-
-        *ptr++ = (rgb >> 2) | (a >> 3);
-    }
-
     return &FramebufferCPU[stride * line];
 }
 
@@ -1487,8 +1519,8 @@ void ComputeRenderer::SetupAccelFrame()
 void ComputeRenderer::PrepareCaptureFrame()
 {
     glBindBuffer(GL_PIXEL_PACK_BUFFER, PixelBuffer);
-    glBindTexture(GL_TEXTURE_2D, Framebuffer);
-    glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_BYTE, nullptr);
+    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
index 9b83b38c8..7a3af101a 100644
--- a/src/GPU3D_Compute.h
+++ b/src/GPU3D_Compute.h
@@ -141,57 +141,32 @@ class ComputeRenderer : public Renderer3D
         u32 __pad0, __pad1;
     };
 
-    static const int TileSize = 8;
-    static const int CoarseTileCountX = 8;
-    static const int CoarseTileCountY = 4;
-    static const int CoarseTileW = CoarseTileCountX * TileSize;
-    static const int CoarseTileH = CoarseTileCountY * TileSize;
+    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 const int TilesPerLine = 256/TileSize;
-    static const int TileLines = 192/TileSize;
+    static constexpr int BinStride = 2048/32;
+    static constexpr int CoarseBinStride = BinStride/32;
 
-    static const int BinStride = 2048/32;
-    static const int CoarseBinStride = BinStride/32;
+    static constexpr int MaxVariants = 256;
 
-    static const int MaxWorkTiles = TilesPerLine*TileLines*48;
-    static const int MaxVariants = 256;
+    static constexpr int UniformIdxCurVariant = 0;
+    static constexpr int UniformIdxTextureSize = 1;
 
-    static const int UniformIdxCurVariant = 0;
-    static const int UniformIdxTextureSize = 1;
+    static constexpr int MaxFullscreenLayers = 16;
 
-    struct BinResult
+    struct BinResultHeader
     {
         u32 VariantWorkCount[MaxVariants*4];
         u32 SortedWorkOffset[MaxVariants];
 
         u32 SortWorkWorkCount[4];
-        u32 UnsortedWorkDescs[MaxWorkTiles*2];
-        u32 SortedWork[MaxWorkTiles*2];
-
-        u32 BinnedMaskCoarse[TilesPerLine*TileLines*CoarseBinStride];
-        u32 BinnedMask[TilesPerLine*TileLines*BinStride];
-        u32 WorkOffsets[TilesPerLine*TileLines*BinStride];
     };
 
-    struct Tiles
-    {
-        u32 ColorTiles[MaxWorkTiles*TileSize*TileSize];
-        u32 DepthTiles[MaxWorkTiles*TileSize*TileSize];
-        u32 AttrStencilTiles[MaxWorkTiles*TileSize*TileSize];
-    };
-
-    struct FinalTiles
-    {
-        u32 ColorResult[256*192*2];
-        u32 DepthResult[256*192*2];
-        u32 AttrResult[256*192*2];
-    };
-
-    // eh those are pretty bad guesses
-    // though real hw shouldn't be eable to render all 2048 polygons on every line either
-    static const int MaxYSpanIndices = 64*2048;
     static const int MaxYSpanSetups = 6144*2;
-    SetupIndices YSpanIndices[MaxYSpanIndices];
+    std::vector<SetupIndices> YSpanIndices;
     SpanSetupY YSpanSetups[MaxYSpanSetups];
     RenderPolygon RenderPolygons[2048];
 
@@ -228,8 +203,6 @@ class ComputeRenderer : public Renderer3D
         u32 ClearColor, ClearDepth, ClearAttr;
 
         u32 FogOffset, FogShift, FogColor;
-
-        u32 XScroll;
     };
     GLuint MetaUniformMemory;
 
@@ -241,17 +214,24 @@ class ComputeRenderer : public Renderer3D
     u32 TextureDecodingBuffer[1024*1024];
 
     GLuint Framebuffer;
+    GLuint LowResFramebuffer;
     GLuint PixelBuffer;
 
     u32 FramebufferCPU[256*192];
 
     TexCacheEntry& GetTexture(u32 textureParam, u32 paletteParam);
 
+    int ScreenWidth, ScreenHeight;
+    int TilesPerLine, TileLines;
+    int ScaleFactor = -1;
+    int MaxWorkTiles;
+
     void ResetTexcache();
+    void DeleteShaders();
 
     void SetupAttrs(SpanSetupY* span, Polygon* poly, int from, int to);
-    void SetupYSpan(int polynum, SpanSetupY* span, Polygon* poly, int from, int to, u32 y, int side);
-    void SetupYSpanDummy(SpanSetupY* span, Polygon* poly, int vertex, int side);
+    void SetupYSpan(int polynum, SpanSetupY* span, Polygon* poly, int from, int to, u32 y, int side, s32 positions[10][2]);
+    void SetupYSpanDummy(SpanSetupY* span, Polygon* poly, int vertex, int side, s32 positions[10][2]);
 
     bool CompileShader(GLuint& shader, const char* source, const std::initializer_list<const char*>& defines);
 };
diff --git a/src/GPU3D_Compute_shaders.h b/src/GPU3D_Compute_shaders.h
index 786f66c9f..26e7adeb4 100644
--- a/src/GPU3D_Compute_shaders.h
+++ b/src/GPU3D_Compute_shaders.h
@@ -52,6 +52,24 @@ namespace ComputeRendererShaders
 // 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 char* Common = R"(
 struct Polygon
 {
@@ -149,14 +167,14 @@ const int CoarseTileCountY = 4;
 const int CoarseTileW = (CoarseTileCountX * TileSize);
 const int CoarseTileH = (CoarseTileCountY * TileSize);
 
-const int FramebufferStride = 256*192;
-const int TilesPerLine = 256/TileSize;
-const int TileLines = 192/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 MaxWorkTiles = TilesPerLine*TileLines*48;
+
 const int MaxVariants = 256;
 
 layout (std430, binding = 3)
@@ -199,9 +217,9 @@ readonly
 #endif
 buffer RasterResult
 {
-    uint ColorResult[256*192*2];
-    uint DepthResult[256*192*2];
-    uint AttrResult[256*192*2];
+    uint ColorResult[ScreenWidth*ScreenHeight*2];
+    uint DepthResult[ScreenWidth*ScreenHeight*2];
+    uint AttrResult[ScreenWidth*ScreenHeight*2];
 };
 
 layout (std140, binding = 0) uniform MetaUniform
@@ -221,8 +239,6 @@ layout (std140, binding = 0) uniform MetaUniform
     uint ClearColor, ClearDepth, ClearAttr;
 
     uint FogOffset, FogShift, FogColor;
-
-    int XScroll;
 };
 
 #if defined(InterpSpans) || defined(Rasterise)
@@ -238,7 +254,7 @@ const uint startTable[256] = uint[256](
 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)
+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);
@@ -251,7 +267,7 @@ uint Div(uint x, uint y)
     z += Umulh(z, my * z);
 
     uint q = Umulh(x, z);
-    uint r = x - y * q;
+    r = x - y * q;
     if(r >= y)
     {
         r = r - y;
@@ -266,16 +282,77 @@ uint Div(uint x, uint y)
     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. <---- in C. I'm pretty sure shifts are masked in GLSL, but whatever.
+    uint shift = 31 - findMSB(den);
+    den <<= shift;
+    numHi <<= shift;
+    numHi |= (numLo >> (-shift & 63U)) & uint(-int(shift) >> 63);
+    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);
+}
+
 #ifdef InterpSpans
-const int Shift = 9;
+const int YFactorShift = 9;
 #else
-const int Shift = 8;
+const int YFactorShift = 8;
 #endif
 
 int CalcYFactorY(YSpanSetup span, int i)
 {
-    int num = abs((i) * span.W0n) << Shift;
-    int den = abs(((i) * span.W0d) + (((span.I1 - span.I0 - i) * span.W1d)));
+    /*
+        maybe it would be better to do use a 32x32=64 multiplication?
+    */
+    uint numLo = abs(i * span.W0n);
+    uint numHi = 0U;
+    numHi |= numLo >> (32-YFactorShift);
+    numLo <<= YFactorShift;
+
+    uint den = abs(i * span.W0d + (span.I1 - span.I0 - i) * span.W1d);
 
     if (den == 0)
     {
@@ -283,10 +360,7 @@ int CalcYFactorY(YSpanSetup span, int i)
     }
     else
     {
-        int q = int(Div(num, den));
-        //if ((num < 0) != (den < 0))
-        //    return -q;
-        return q;
+        return int(Div64_32_32(numHi, numLo, den));
     }
 }
 
@@ -296,13 +370,17 @@ int CalcYFactorX(XSpanSetup span, int x)
 
     if (span.X0 != span.X1)
     {
-        uint num = (uint(x) * span.W0) << Shift;
+        uint numLo = uint(x) * span.W0;
+        uint numHi = 0U;
+        numHi |= numLo >> (32-YFactorShift);
+        numLo <<= YFactorShift;
+
         uint den = (uint(x) * span.W0) + (uint(span.X1 - span.X0 - x) * span.W1);
 
         if (den == 0)
             return 0;
         else
-            return int(Div(num, den));
+            return int(Div64_32_32(numHi, numLo, den));
     }
     else
     {
@@ -316,9 +394,9 @@ int InterpolateAttrPersp(int y0, int y1, int ifactor)
         return y0;
 
     if (y0 < y1)
-        return y0 + (((y1-y0) * ifactor) >> Shift);
+        return y0 + (((y1-y0) * ifactor) >> YFactorShift);
     else
-        return y1 + (((y0-y1) * ((1<<Shift)-ifactor)) >> Shift);
+        return y1 + (((y0-y1) * ((1<<YFactorShift)-ifactor)) >> YFactorShift);
 }
 
 int InterpolateAttrLinear(int y0, int y1, int i, int irecip, int idiff)
@@ -439,11 +517,11 @@ uint InterpolateZWBuffer(int z0, int z1, int ifactor)
     // 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) >> Shift);
+        return uint(z0) + (((z1-z0) * ifactor) >> YFactorShift);
     }
     else
     {
-        return uint(z1) + (((z0-z1) * ((1<<Shift)-ifactor)) >> Shift);
+        return uint(z1) + (((z0-z1) * ((1<<YFactorShift)-ifactor)) >> YFactorShift);
     }
 #else
     uint mulLo, mulHi;
@@ -451,21 +529,21 @@ uint InterpolateZWBuffer(int z0, int z1, int ifactor)
     {
         umulExtended(z1-z0, ifactor, mulHi, mulLo);
         // 64-bit shift
-        return uint(z0) + ((mulLo >> Shift) | (mulHi << (32-Shift)));
+        return uint(z0) + ((mulLo >> YFactorShift) | (mulHi << (32-YFactorShift)));
     }
     else
     {
-        umulExtended(z0-z1, (1<<Shift)-ifactor, mulHi, mulLo);
-        return uint(z1) + ((mulLo >> Shift) | (mulHi << (32-Shift)));
+        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)) >> Shift);
+        return uint(z0) + uint((int64_t(z1-z0) * int64_t(ifactor)) >> YFactorShift);
     }
     else
     {
-        return uint(z1) + uint((int64_t(z0-z1) * int64_t((1<<Shift)-ifactor)) >> Shift);
+        return uint(z1) + uint((int64_t(z0-z1) * int64_t((1<<YFactorShift)-ifactor)) >> YFactorShift);
     }*/
 }
 
@@ -499,7 +577,8 @@ void EdgeParams_XMajor(bool side, int dx, YSpanSetup span, out int edgelen, out
     if (negative) startx = xlen - startx;
     if (side) startx = startx - len + 1;
 
-    int startcov = int(Div(uint(((startx << 10) + 0x1FF) * (span.Y1 - span.Y0)), uint(xlen)));
+    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);
 }
 
@@ -713,7 +792,8 @@ void main()
     }
     {
 #endif
-        xspan.XRecip = int(Div(1U<<30, uint(xspan.X1 - xspan.X0)));
+        uint r;
+        xspan.XRecip = int(Div(1U<<30, uint(xspan.X1 - xspan.X0), r));
     }
 
     XSpanSetups[gl_GlobalInvocationID.x] = xspan;
@@ -950,7 +1030,7 @@ void main()
                 attr |= 0x1U;
 
                 int cov = xspan.EdgeCovL;
-                if ((cov & (1U<<31)) != 0U)
+                if (cov < 0)
                 {
                     int xcov = xspan.CovLInitial + (xspan.EdgeCovL & 0x3FF) * (position.x - xspan.X0);
                     cov = min(xcov >> 5, 31);
@@ -963,7 +1043,7 @@ void main()
                 attr |= 0x2U;
 
                 int cov = xspan.EdgeCovR;
-                if ((cov & (1U<<31)) != 0U)
+                if (cov < 0)
                 {
                     int xcov = xspan.CovRInitial + (xspan.EdgeCovR & 0x3FF) * (position.x - xspan.InsideEnd);
                     cov = max(0x1F - (xcov >> 5), 0);
@@ -1311,7 +1391,7 @@ void main()
     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) * 256;
+    int resultOffset = int(gl_GlobalInvocationID.x) + int(gl_GlobalInvocationID.y) * ScreenWidth;
     ColorResult[resultOffset] = color.x;
     ColorResult[resultOffset+FramebufferStride] = color.y;
     DepthResult[resultOffset] = depth.x;
@@ -1327,6 +1407,7 @@ const char* FinalPass = 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)
 {
@@ -1373,18 +1454,12 @@ uint BlendFog(uint color, uint depth)
 
 void main()
 {
-    int srcX = (int(gl_GlobalInvocationID.x) + XScroll) & 0x1FF;
-    int resultOffset = int(srcX) + int(gl_GlobalInvocationID.y) * 256;
+    int srcX = int(gl_GlobalInvocationID.x);
+    int resultOffset = int(srcX) + int(gl_GlobalInvocationID.y) * ScreenWidth;
 
-    uvec2 color = uvec2(0);
-    uvec2 depth = uvec2(0);
-    uvec2 attr = uvec2(0);
-    if (srcX < 256)
-    {
-        color = uvec2(ColorResult[resultOffset], ColorResult[resultOffset+FramebufferStride]);
-        depth = uvec2(DepthResult[resultOffset], DepthResult[resultOffset+FramebufferStride]);
-        attr = uvec2(AttrResult[resultOffset], AttrResult[resultOffset+FramebufferStride]);
-    }
+    uvec2 color = uvec2(ColorResult[resultOffset], ColorResult[resultOffset+FramebufferStride]);
+    uvec2 depth = uvec2(DepthResult[resultOffset], DepthResult[resultOffset+FramebufferStride]);
+    uvec2 attr = uvec2(AttrResult[resultOffset], AttrResult[resultOffset+FramebufferStride]);
 
 #ifdef EdgeMarking
     if ((attr.x & 0xFU) != 0U)
@@ -1397,20 +1472,20 @@ void main()
             otherAttr.x = AttrResult[resultOffset-1];
             otherDepth.x = DepthResult[resultOffset-1];
         }
-        if (srcX < 255U)
+        if (srcX < ScreenWidth-1)
         {
             otherAttr.y = AttrResult[resultOffset+1];
             otherDepth.y = DepthResult[resultOffset+1];
         }
         if (gl_GlobalInvocationID.y > 0U)
         {
-            otherAttr.z = AttrResult[resultOffset-256];
-            otherDepth.z = DepthResult[resultOffset-256];
+            otherAttr.z = AttrResult[resultOffset-ScreenWidth];
+            otherDepth.z = DepthResult[resultOffset-ScreenWidth];
         }
-        if (gl_GlobalInvocationID.y < 191U)
+        if (gl_GlobalInvocationID.y < ScreenHeight-1)
         {
-            otherAttr.w = AttrResult[resultOffset+256];
-            otherDepth.w = DepthResult[resultOffset+256];
+            otherAttr.w = AttrResult[resultOffset+ScreenWidth];
+            otherDepth.w = DepthResult[resultOffset+ScreenWidth];
         }
 
         uint polyId = bitfieldExtract(attr.x, 24, 5);
@@ -1491,6 +1566,20 @@ void main()
     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);
+    }
 }
 
 )";

From 7d0d5e8270600e2b20ccaa49271333276cc476b4 Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Mon, 17 Apr 2023 20:53:41 +0200
Subject: [PATCH 09/20] fix UB also misc changes to use more unsigned
 multiplication also fix framebuffer resize

---
 src/GPU3D_Compute.cpp       |  6 ++++--
 src/GPU3D_Compute.h         |  2 +-
 src/GPU3D_Compute_shaders.h | 16 ++++++++--------
 3 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/src/GPU3D_Compute.cpp b/src/GPU3D_Compute.cpp
index 5421708e9..bfb10e92a 100644
--- a/src/GPU3D_Compute.cpp
+++ b/src/GPU3D_Compute.cpp
@@ -89,7 +89,6 @@ bool ComputeRenderer::Init()
     glGenBuffers(1, &TileMemory);
 
     glGenTextures(1, &YSpanIndicesTexture);
-    glGenTextures(1, &Framebuffer);
     glGenTextures(1, &LowResFramebuffer);
     glBindTexture(GL_TEXTURE_2D, LowResFramebuffer);
     glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8UI, 256, 192);
@@ -230,6 +229,9 @@ void ComputeRenderer::SetRenderSettings(GPU::RenderSettings& settings)
     glBindBuffer(GL_SHADER_STORAGE_BUFFER, BinResultMemory);
     glBufferData(GL_SHADER_STORAGE_BUFFER, binResultSize, 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);
 
@@ -1391,7 +1393,7 @@ void ComputeRenderer::RenderFrame()
             for (int i = 0; i < numVariants; i++)
             {
                 GLuint shader = 0;
-                if (variants[i].Texture == -1)
+                if (variants[i].Texture == 0)
                 {
                     shader = shadersNoTexture[variants[i].BlendMode];
                 }
diff --git a/src/GPU3D_Compute.h b/src/GPU3D_Compute.h
index 7a3af101a..fc1b7c008 100644
--- a/src/GPU3D_Compute.h
+++ b/src/GPU3D_Compute.h
@@ -213,7 +213,7 @@ class ComputeRenderer : public Renderer3D
 
     u32 TextureDecodingBuffer[1024*1024];
 
-    GLuint Framebuffer;
+    GLuint Framebuffer = 0;
     GLuint LowResFramebuffer;
     GLuint PixelBuffer;
 
diff --git a/src/GPU3D_Compute_shaders.h b/src/GPU3D_Compute_shaders.h
index 26e7adeb4..65ec4f128 100644
--- a/src/GPU3D_Compute_shaders.h
+++ b/src/GPU3D_Compute_shaders.h
@@ -299,11 +299,11 @@ uint Div64_32_32(uint numHi, uint numLo, uint den)
     // 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. <---- in C. I'm pretty sure shifts are masked in GLSL, but whatever.
+    // by 64. (it's also UB in GLSL!!!!)
     uint shift = 31 - findMSB(den);
     den <<= shift;
     numHi <<= shift;
-    numHi |= (numLo >> (-shift & 63U)) & uint(-int(shift) >> 63);
+    numHi |= (numLo >> (-shift & 31U)) & uint(-int(shift) >> 31);
     numLo <<= shift;
 
     // Extract the low digits of the numerator and both digits of the denominator.
@@ -347,12 +347,12 @@ int CalcYFactorY(YSpanSetup span, int i)
     /*
         maybe it would be better to do use a 32x32=64 multiplication?
     */
-    uint numLo = abs(i * span.W0n);
+    uint numLo = uint(abs(i)) * uint(span.W0n);
     uint numHi = 0U;
-    numHi |= numLo >> (32-YFactorShift);
+    numHi |= numLo >> (32U-YFactorShift);
     numLo <<= YFactorShift;
 
-    uint den = abs(i * span.W0d + (span.I1 - span.I0 - i) * span.W1d);
+    uint den = uint(abs(i)) * uint(span.W0d) + uint(abs(span.I1 - span.I0 - i)) * span.W1d;
 
     if (den == 0)
     {
@@ -370,12 +370,12 @@ int CalcYFactorX(XSpanSetup span, int x)
 
     if (span.X0 != span.X1)
     {
-        uint numLo = uint(x) * span.W0;
+        uint numLo = uint(x) * uint(span.W0);
         uint numHi = 0U;
-        numHi |= numLo >> (32-YFactorShift);
+        numHi |= numLo >> (32U-YFactorShift);
         numLo <<= YFactorShift;
 
-        uint den = (uint(x) * span.W0) + (uint(span.X1 - span.X0 - x) * span.W1);
+        uint den = uint(x) * uint(span.W0) + uint(span.X1 - span.X0 - x) * uint(span.W1);
 
         if (den == 0)
             return 0;

From 433e00032c78a6c8d13329625f0e5f33811805a7 Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Mon, 17 Apr 2023 21:13:38 +0200
Subject: [PATCH 10/20] correct edge filling behaviour when AA is disabled

---
 src/GPU3D_Compute_shaders.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GPU3D_Compute_shaders.h b/src/GPU3D_Compute_shaders.h
index 65ec4f128..bcf57b2e3 100644
--- a/src/GPU3D_Compute_shaders.h
+++ b/src/GPU3D_Compute_shaders.h
@@ -683,7 +683,7 @@ void main()
         xspan.InsideEnd = xspan.X1;
 
     bool isShadowMask = ((polygon.Attr & 0x3F000030U) == 0x00000030U);
-    bool fillAllEdges = /*polyalpha < 31*/true;
+    bool fillAllEdges = polyalpha < 31 || (DispCnt & (3U<<4)) != 0U;
 
     if (fillAllEdges || spanL.X1 < spanL.X0 || spanL.Increment <= 0x40000)
         xspan.Flags |= XSpanSetup_FillLeft;

From 38a96e4c15e3631458fa00f92ae760281456569c Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Mon, 17 Apr 2023 21:58:51 +0200
Subject: [PATCH 11/20] fix full color textures

---
 src/GPU3D_Compute.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/GPU3D_Compute.cpp b/src/GPU3D_Compute.cpp
index bfb10e92a..1d1bd8318 100644
--- a/src/GPU3D_Compute.cpp
+++ b/src/GPU3D_Compute.cpp
@@ -744,11 +744,11 @@ ComputeRenderer::TexCacheEntry& ComputeRenderer::GetTexture(u32 texParam, u32 pa
     {
         entry.TextureRAMSize[0] = width*height*2;
 
-        for (u32 i = 0; i < width*height; i += 2)
+        for (u32 i = 0; i < width*height; i++)
         {
             u16 value = *(u16*)&GPU::VRAMFlat_Texture[addr + i * 2];
 
-            TextureDecodingBuffer[i] = ConvertRGB5ToRGB6(value);
+            TextureDecodingBuffer[i] = ConvertRGB5ToRGB6(value) | (value & 0x8000 ? 0x1F000000 : 0);
         }
     }
     else if (fmt == 5)

From 1c834db5e950b4037b0da320d9d90b18f11a8e1e Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Wed, 19 Apr 2023 23:31:09 +0200
Subject: [PATCH 12/20] fix edge marking (polygon id is 6-bit not 5) also make
 the code a bit nicer

---
 src/GPU3D_Compute_shaders.h | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/GPU3D_Compute_shaders.h b/src/GPU3D_Compute_shaders.h
index bcf57b2e3..eaef76c97 100644
--- a/src/GPU3D_Compute_shaders.h
+++ b/src/GPU3D_Compute_shaders.h
@@ -1488,16 +1488,13 @@ void main()
             otherDepth.w = DepthResult[resultOffset+ScreenWidth];
         }
 
-        uint polyId = bitfieldExtract(attr.x, 24, 5);
-        uvec4 otherPolyId = bitfieldExtract(otherAttr, 24, 5);
+        uint polyId = bitfieldExtract(attr.x, 24, 6);
+        uvec4 otherPolyId = bitfieldExtract(otherAttr, 24, 6);
 
-        bvec4 polyIdMatch = equal(uvec4(polyId), otherPolyId);
+        bvec4 polyIdMismatch = notEqual(uvec4(polyId), otherPolyId);
         bvec4 nearer = lessThan(uvec4(depth.x), otherDepth);
 
-        if ((!polyIdMatch.x && nearer.x)
-            || (!polyIdMatch.y && nearer.y)
-            || (!polyIdMatch.z && nearer.z)
-            || (!polyIdMatch.w && nearer.w))
+        if (any(polyIdMismatch & nearer))
         {
             color.x = ToonTable[polyId >> 3].b | (color.x & 0xFF000000U);
             attr.x = (attr.x & 0xFFFFE0FFU) | 0x00001000U;

From 5ec2c2b9e4590d6f07ddc20ca4e9d30508ef235a Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Sat, 22 Apr 2023 01:00:30 +0200
Subject: [PATCH 13/20] take all edge cases into account for XMin/XMax
 calculation

---
 src/GPU3D_Compute.cpp       | 117 ++++++++++++++----------------------
 src/GPU3D_Compute.h         |   4 +-
 src/GPU3D_Compute_shaders.h |  28 ++++++++-
 src/OpenGLSupport.cpp       |   6 --
 4 files changed, 73 insertions(+), 82 deletions(-)

diff --git a/src/GPU3D_Compute.cpp b/src/GPU3D_Compute.cpp
index 1d1bd8318..68d3af079 100644
--- a/src/GPU3D_Compute.cpp
+++ b/src/GPU3D_Compute.cpp
@@ -307,7 +307,7 @@ void ComputeRenderer::SetupAttrs(SpanSetupY* span, Polygon* poly, int from, int
     span->TexcoordV1 = poly->Vertices[to]->TexCoords[1];
 }
 
-void ComputeRenderer::SetupYSpanDummy(SpanSetupY* span, Polygon* poly, int vertex, int side, s32 positions[10][2])
+void ComputeRenderer::SetupYSpanDummy(RenderPolygon* rp, SpanSetupY* span, Polygon* poly, int vertex, int side, s32 positions[10][2])
 {
     s32 x0 = positions[vertex][0];
     if (side)
@@ -325,6 +325,17 @@ void ComputeRenderer::SetupYSpanDummy(SpanSetupY* span, Polygon* poly, int verte
     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;
@@ -337,7 +348,7 @@ void ComputeRenderer::SetupYSpanDummy(SpanSetupY* span, Polygon* poly, int verte
     SetupAttrs(span, poly, vertex, vertex);
 }
 
-void ComputeRenderer::SetupYSpan(int polynum, SpanSetupY* span, Polygon* poly, int from, int to, u32 y, int side, s32 positions[10][2])
+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];
@@ -346,23 +357,45 @@ void ComputeRenderer::SetupYSpan(int polynum, SpanSetupY* span, Polygon* poly, i
 
     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;
@@ -1072,18 +1105,15 @@ void ComputeRenderer::RenderFrame()
         s32 ytop = ScreenHeight, ybot = 0;
         for (int i = 0; i < polygon->NumVertices; i++)
         {
-            scaledPositions[i][0] = (polygon->Vertices[i]->HiresPosition[0] * ScaleFactor) >> 4;
-            scaledPositions[i][1] = (polygon->Vertices[i]->HiresPosition[1] * ScaleFactor) >> 4;
+            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;
-
-        s32 minX = scaledPositions[vtop][0];
-        s32 minXY = scaledPositions[vtop][1];
-        s32 maxX = scaledPositions[vtop][0];
-        s32 maxXY = scaledPositions[vtop][1];
+        RenderPolygons[i].XMin = ScreenWidth;
+        RenderPolygons[i].XMax = 0;
 
         if (ybot == ytop)
         {
@@ -1101,20 +1131,10 @@ void ComputeRenderer::RenderFrame()
 
             assert(numYSpans < MaxYSpanSetups);
             u32 curSpanL = numYSpans;
-            SetupYSpanDummy(&YSpanSetups[numYSpans++], polygon, vtop, 0, scaledPositions);
+            SetupYSpanDummy(&RenderPolygons[i], &YSpanSetups[numYSpans++], polygon, vtop, 0, scaledPositions);
             assert(numYSpans < MaxYSpanSetups);
             u32 curSpanR = numYSpans;
-            SetupYSpanDummy(&YSpanSetups[numYSpans++], polygon, vbot, 1, scaledPositions);
-
-            minX = YSpanSetups[curSpanL].X0;
-            minXY = YSpanSetups[curSpanL].Y0;
-            maxX = YSpanSetups[curSpanR].X0;
-            maxXY = YSpanSetups[curSpanR].Y0;
-            if (maxX < minX)
-            {
-                std::swap(minX, maxX);
-                std::swap(minXY, maxXY);
-            }
+            SetupYSpanDummy(&RenderPolygons[i], &YSpanSetups[numYSpans++], polygon, vbot, 1, scaledPositions);
 
             YSpanIndices[numSetupIndices].PolyIdx = i;
             YSpanIndices[numSetupIndices].SpanIdxL = curSpanL;
@@ -1126,10 +1146,10 @@ void ComputeRenderer::RenderFrame()
         {
             u32 curSpanL = numYSpans;
             assert(numYSpans < MaxYSpanSetups);
-            SetupYSpan(i, &YSpanSetups[numYSpans++], polygon, curVL, nextVL, ytop, 0, scaledPositions);
+            SetupYSpan(&RenderPolygons[i], &YSpanSetups[numYSpans++], polygon, curVL, nextVL, 0, scaledPositions);
             u32 curSpanR = numYSpans;
             assert(numYSpans < MaxYSpanSetups);
-            SetupYSpan(i, &YSpanSetups[numYSpans++], polygon, curVR, nextVR, ytop, 1, scaledPositions);
+            SetupYSpan(&RenderPolygons[i], &YSpanSetups[numYSpans++], polygon, curVR, nextVR, 1, scaledPositions);
 
             for (u32 y = ytop; y < ybot; y++)
             {
@@ -1152,20 +1172,10 @@ void ComputeRenderer::RenderFrame()
                         }
                     }
 
-                    if (scaledPositions[curVL][0] < minX)
-                    {
-                        minX = scaledPositions[curVL][0];
-                        minXY = scaledPositions[curVL][1];
-                    }
-                    if (scaledPositions[curVL][0] > maxX)
-                    {
-                        maxX = scaledPositions[curVL][0];
-                        maxXY = scaledPositions[curVL][1];
-                    }
 
                     assert(numYSpans < MaxYSpanSetups);
                     curSpanL = numYSpans;
-                    SetupYSpan(i,&YSpanSetups[numYSpans++], polygon, curVL, nextVL, y, 0, scaledPositions);
+                    SetupYSpan(&RenderPolygons[i], &YSpanSetups[numYSpans++], polygon, curVL, nextVL, 0, scaledPositions);
                 }
                 if (y >= scaledPositions[nextVR][1] && curVR != polygon->VBottom)
                 {
@@ -1186,20 +1196,9 @@ void ComputeRenderer::RenderFrame()
                         }
                     }
 
-                    if (scaledPositions[curVR][0] < minX)
-                    {
-                        minX = scaledPositions[curVR][0];
-                        minXY = scaledPositions[curVR][1];
-                    }
-                    if (scaledPositions[curVR][0] > maxX)
-                    {
-                        maxX = scaledPositions[curVR][0];
-                        maxXY = scaledPositions[curVR][1];
-                    }
-
                     assert(numYSpans < MaxYSpanSetups);
                     curSpanR = numYSpans;
-                    SetupYSpan(i,&YSpanSetups[numYSpans++], polygon, curVR, nextVR, y, 1, scaledPositions);
+                    SetupYSpan(&RenderPolygons[i] ,&YSpanSetups[numYSpans++], polygon, curVR, nextVR, 1, scaledPositions);
                 }
 
                 YSpanIndices[numSetupIndices].PolyIdx = i;
@@ -1210,32 +1209,6 @@ void ComputeRenderer::RenderFrame()
             }
         }
 
-        if (scaledPositions[nextVL][0] < minX)
-        {
-            minX = scaledPositions[nextVL][0];
-            minXY = scaledPositions[nextVL][1];
-        }
-        if (scaledPositions[nextVL][0] > maxX)
-        {
-            maxX = scaledPositions[nextVL][0];
-            maxXY = scaledPositions[nextVL][1];
-        }
-        if (scaledPositions[nextVR][0] < minX)
-        {
-            minX = scaledPositions[nextVR][0];
-            minXY = scaledPositions[nextVR][1];
-        }
-        if (scaledPositions[nextVR][0] > maxX)
-        {
-            maxX = scaledPositions[nextVR][0];
-            maxXY = scaledPositions[nextVR][1];
-        }
-
-        RenderPolygons[i].XMin = minX;
-        RenderPolygons[i].XMinY = minXY;
-        RenderPolygons[i].XMax = maxX;
-        RenderPolygons[i].XMaxY = maxXY;
-
         //printf("polygon min max %d %d | %d %d\n", RenderPolygons[i].XMin, RenderPolygons[i].XMinY, RenderPolygons[i].XMax, RenderPolygons[i].XMaxY);
     }
 
diff --git a/src/GPU3D_Compute.h b/src/GPU3D_Compute.h
index fc1b7c008..721c7a61d 100644
--- a/src/GPU3D_Compute.h
+++ b/src/GPU3D_Compute.h
@@ -230,8 +230,8 @@ class ComputeRenderer : public Renderer3D
     void DeleteShaders();
 
     void SetupAttrs(SpanSetupY* span, Polygon* poly, int from, int to);
-    void SetupYSpan(int polynum, SpanSetupY* span, Polygon* poly, int from, int to, u32 y, int side, s32 positions[10][2]);
-    void SetupYSpanDummy(SpanSetupY* span, Polygon* poly, int vertex, int side, s32 positions[10][2]);
+    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 char* source, const std::initializer_list<const char*>& defines);
 };
diff --git a/src/GPU3D_Compute_shaders.h b/src/GPU3D_Compute_shaders.h
index eaef76c97..6b63919a7 100644
--- a/src/GPU3D_Compute_shaders.h
+++ b/src/GPU3D_Compute_shaders.h
@@ -208,6 +208,7 @@ buffer TilesBuffer
 };
 #endif
 
+#if defined(DepthBlend) || defined(FinalPass)
 layout (std430, binding = 5)
 #ifdef DepthBlend
 writeonly
@@ -221,6 +222,7 @@ buffer RasterResult
     uint DepthResult[ScreenWidth*ScreenHeight*2];
     uint AttrResult[ScreenWidth*ScreenHeight*2];
 };
+#endif
 
 layout (std140, binding = 0) uniform MetaUniform
 {
@@ -835,6 +837,28 @@ bool BinPolygon(Polygon polygon, ivec2 topLeft, ivec2 botRight)
 
     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));
 
@@ -1557,8 +1581,8 @@ void main()
 //    else
 //        color.x = 0U;
 
-    //if (gl_LocalInvocationID.x == 7 || gl_LocalInvocationID.y == 7)
-        //color.x = 0x1F00001FU | 0x40000000U;
+    //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);
diff --git a/src/OpenGLSupport.cpp b/src/OpenGLSupport.cpp
index c00ad612f..6b6fba8a7 100644
--- a/src/OpenGLSupport.cpp
+++ b/src/OpenGLSupport.cpp
@@ -24,8 +24,6 @@ using Platform::LogLevel;
 namespace OpenGL
 {
 
-#define checkGLError() if (glGetError() != GL_NO_ERROR) printf("error %d\n", __LINE__)
-
 bool CompilerShader(GLuint& id, const char* source, const char* name, const char* type)
 {
     int len;
@@ -33,12 +31,9 @@ bool CompilerShader(GLuint& id, const char* source, const char* name, const char
 
     len = strlen(source);
     glShaderSource(id, 1, &source, &len);
-    checkGLError();
     glCompileShader(id);
-    checkGLError();
 
     glGetShaderiv(id, GL_COMPILE_STATUS, &res);
-    checkGLError();
     if (res != GL_TRUE)
     {
         glGetShaderiv(id, GL_INFO_LOG_LENGTH, &res);
@@ -62,7 +57,6 @@ bool LinkProgram(GLuint& result, GLuint* ids, int numIds)
     for (int i = 0; i < numIds; i++)
     {
         glAttachShader(result, ids[i]);
-        checkGLError();
     }
 
     glLinkProgram(result);

From e79e74e681934a772f68b8e933b4238b286ee1c3 Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Sat, 22 Apr 2023 03:05:08 +0200
Subject: [PATCH 14/20] use hires coordinate again

---
 src/GPU3D_Compute.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/GPU3D_Compute.cpp b/src/GPU3D_Compute.cpp
index 68d3af079..a7fd9cb8d 100644
--- a/src/GPU3D_Compute.cpp
+++ b/src/GPU3D_Compute.cpp
@@ -1105,8 +1105,8 @@ void ComputeRenderer::RenderFrame()
         s32 ytop = ScreenHeight, ybot = 0;
         for (int i = 0; i < polygon->NumVertices; i++)
         {
-            scaledPositions[i][0] = (polygon->Vertices[i]->FinalPosition[0] * ScaleFactor);
-            scaledPositions[i][1] = (polygon->Vertices[i]->FinalPosition[1] * ScaleFactor);
+            scaledPositions[i][0] = (polygon->Vertices[i]->HiresPosition[0] * ScaleFactor) >> 4;
+            scaledPositions[i][1] = (polygon->Vertices[i]->HiresPosition[1] * ScaleFactor) >> 4;
             ytop = std::min(scaledPositions[i][1], ytop);
             ybot = std::max(scaledPositions[i][1], ybot);
         }

From a944a169f75fdd2d299cbbeb673537b800ecc2ea Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Mon, 8 May 2023 19:34:05 +0200
Subject: [PATCH 15/20] stop using fixed size buffers based on scale factor in
 shaders this makes shader compile times tolerable on Wintel - beginning of
 the shader cache - increase size of tile idx in workdesc to 20 bits

diff --git a/src/GPU3D_Compute.cpp b/src/GPU3D_Compute.cpp
index a7fd9cb8d..348562355 100644
--- a/src/GPU3D_Compute.cpp
+++ b/src/GPU3D_Compute.cpp
@@ -39,7 +39,7 @@ ComputeRenderer::~ComputeRenderer()
 
 
 
-bool ComputeRenderer::CompileShader(GLuint& shader, const char* source, const std::initializer_list<const char*>& defines)
+bool ComputeRenderer::CompileShader(GLuint& shader, const std::string& source, const std::initializer_list<const char*>& defines)
 {
     std::string shaderName;
     std::string shaderSource;
@@ -72,8 +72,8 @@ void blah(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,con
 
 bool ComputeRenderer::Init()
 {
-    //glDebugMessageCallback(blah, NULL);
-    //glEnable(GL_DEBUG_OUTPUT);
+    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);
@@ -86,7 +86,8 @@ bool ComputeRenderer::Init()
     glGenBuffers(1, &BinResultMemory);
     glGenBuffers(1, &FinalTileMemory);
     glGenBuffers(1, &YSpanIndicesTextureMemory);
-    glGenBuffers(1, &TileMemory);
+    glGenBuffers(tilememoryLayer_Num, TileMemory);
+    glGenBuffers(1, &WorkDescMemory);
 
     glGenTextures(1, &YSpanIndicesTexture);
     glGenTextures(1, &LowResFramebuffer);
@@ -123,9 +124,10 @@ void ComputeRenderer::DeInit()
 
     glDeleteBuffers(1, &YSpanSetupMemory);
     glDeleteBuffers(1, &RenderPolygonMemory);
-    glDeleteBuffers(1, &TileMemory);
     glDeleteBuffers(1, &XSpanSetupMemory);
     glDeleteBuffers(1, &BinResultMemory);
+    glDeleteBuffers(tilememoryLayer_Num, TileMemory);
+    glDeleteBuffers(1, &WorkDescMemory);
     glDeleteBuffers(1, &FinalTileMemory);
     glDeleteBuffers(1, &YSpanIndicesTextureMemory);
     glDeleteTextures(1, &YSpanIndicesTexture);
@@ -214,21 +216,25 @@ void ComputeRenderer::SetRenderSettings(GPU::RenderSettings& settings)
 
     MaxWorkTiles = TilesPerLine*TileLines*8;
 
-    glBindBuffer(GL_SHADER_STORAGE_BUFFER, TileMemory);
-    glBufferData(GL_SHADER_STORAGE_BUFFER, 4*3*TileSize*TileSize*MaxWorkTiles, nullptr, GL_DYNAMIC_DRAW);
+    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)
-        + MaxWorkTiles*2*4 // UnsortedWorkDescs
-        + MaxWorkTiles*2*4 // SortedWork
         + 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);
@@ -1237,12 +1243,14 @@ void ComputeRenderer::RenderFrame()
     //printf("found via %d %d %d of %d\n", foundviatexcache, foundviaprev, numslow, RenderNumPolygons);
 
     // bind everything
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, YSpanSetupMemory);
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, RenderPolygonMemory);
+
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, XSpanSetupMemory);
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, RenderPolygonMemory);
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, BinResultMemory);
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, TileMemory);
+    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;
@@ -1327,7 +1335,6 @@ void ComputeRenderer::RenderFrame()
         glDispatchCompute((numVariants + 31) / 32, 1, 1);
         glMemoryBarrier(GL_SHADER_STORAGE_BUFFER);
 
-
         // sort shader work
         glUseProgram(ShaderSortWork);
         glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, BinResultMemory);
@@ -1336,6 +1343,9 @@ void ComputeRenderer::RenderFrame()
 
         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);
diff --git a/src/GPU3D_Compute.h b/src/GPU3D_Compute.h
index 721c7a61d..b28a3006e 100644
--- a/src/GPU3D_Compute.h
+++ b/src/GPU3D_Compute.h
@@ -74,7 +74,17 @@ class ComputeRenderer : public Renderer3D
     GLuint XSpanSetupMemory;
     GLuint BinResultMemory;
     GLuint RenderPolygonMemory;
-    GLuint TileMemory;
+    GLuint WorkDescMemory;
+
+    enum
+    {
+        tilememoryLayer_Color,
+        tilememoryLayer_Depth,
+        tilememoryLayer_Attr,
+        tilememoryLayer_Num,
+    };
+
+    GLuint TileMemory[tilememoryLayer_Num];
     GLuint FinalTileMemory;
 
     u32 DummyLine[256] = {};
@@ -102,7 +112,7 @@ class ComputeRenderer : public Renderer3D
         s32 DxInitial;
 
         s32 XCovIncr;
-        u32 IsDummy, __pad1;
+        u32 IsDummy;
     };
     struct SpanSetupX
     {
@@ -138,7 +148,6 @@ class ComputeRenderer : public Renderer3D
         u32 Attr;
 
         float TextureLayer;
-        u32 __pad0, __pad1;
     };
 
     static constexpr int TileSize = 8;
@@ -233,7 +242,7 @@ class ComputeRenderer : public Renderer3D
     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 char* source, const std::initializer_list<const char*>& defines);
+    bool CompileShader(GLuint& shader, const std::string& source, const std::initializer_list<const char*>& defines);
 };
 
 }
diff --git a/src/GPU3D_Compute_shaders.h b/src/GPU3D_Compute_shaders.h
index 6b63919a7..dccbe6ee9 100644
--- a/src/GPU3D_Compute_shaders.h
+++ b/src/GPU3D_Compute_shaders.h
@@ -19,6 +19,8 @@
 #ifndef GPU3D_COMPUTE_SHADERS
 #define GPU3D_COMPUTE_SHADERS
 
+#include <string>
+
 namespace GPU3D
 {
 
@@ -69,23 +71,67 @@ namespace ComputeRendererShaders
 
 */
 
+const std::string XSpanSetupBuffer{R"(
 
-const char* Common = R"(
-struct Polygon
+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 FirstXSpan;
-    int YTop, YBot;
+    int X0, X1;
 
-    int XMin, XMax;
-    int XMinY, XMaxY;
+    int InsideStart, InsideEnd, EdgeCovL, EdgeCovR;
 
-    int Variant;
+    int XRecip;
 
-    uint Attr;
+    uint Flags;
 
-    float TextureLayer;
+    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
@@ -113,116 +159,200 @@ struct YSpanSetup
     bool IsDummy;
 };
 
-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
+#if defined(InterpSpans)
+int CalcYFactorY(YSpanSetup span, int i)
 {
-    int X0, X1;
+    /*
+        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;
 
-    int InsideStart, InsideEnd, EdgeCovL, EdgeCovR;
+    uint den = uint(abs(i)) * uint(span.W0d) + uint(abs(span.I1 - span.I0 - i)) * span.W1d;
 
-    int XRecip;
+    if (den == 0)
+    {
+        return 0;
+    }
+    else
+    {
+        return int(Div64_32_32(numHi, numLo, den));
+    }
+}
 
-    uint Flags;
+int CalculateDx(int y, YSpanSetup span)
+{
+    return span.DxInitial + (y - span.Y0) * span.Increment;
+}
 
-    int Z0, Z1, W0, W1;
-    int ColorR0, ColorG0, ColorB0;
-    int ColorR1, ColorG1, ColorB1;
-    int TexcoordU0, TexcoordV0;
-    int TexcoordU1, TexcoordV1;
+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);
+}
 
-    int CovLInitial, CovRInitial;
-};
+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);
+}
 
-layout (std140, binding = 0) readonly buffer YSpanSetupsBuffer
+void EdgeParams_YMajor(bool side, int dx, YSpanSetup span, out int edgelen, out int edgecov)
 {
-    YSpanSetup YSpanSetups[];
-};
+    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;
 
-#if defined(InterpSpans) || defined(BinCombined) || defined(Rasterise)
-layout (std140, binding = 1)
-#ifdef InterpSpans
-writeonly
-#endif
-#if defined(BinCombined) || defined(Rasterise)
-readonly
+        edgecov = cov;
+    }
+}
 #endif
-buffer XSpanSetupsBuffer
+
+layout (std430, binding = 2) buffer YSpanSetupsBuffer
 {
-    XSpanSetup XSpanSetups[];
+    YSpanSetup YSpanSetups[];
 };
-#endif
 
-layout (std140, binding = 2) readonly buffer PolygonBuffer
+)"};
+
+const std::string PolygonBuffer{R"(
+struct Polygon
 {
-    Polygon Polygons[];
-};
+    int FirstXSpan;
+    int YTop, YBot;
 
-#define TileSize 8
-const int CoarseTileCountX = 8;
-const int CoarseTileCountY = 4;
-const int CoarseTileW = (CoarseTileCountX * TileSize);
-const int CoarseTileH = (CoarseTileCountY * TileSize);
+    int XMin, XMax;
+    int XMinY, XMaxY;
 
-const int FramebufferStride = ScreenWidth*ScreenHeight;
-const int TilesPerLine = ScreenWidth/TileSize;
-const int TileLines = ScreenHeight/TileSize;
+    int Variant;
 
-const int BinStride = 2048/32;
-const int CoarseBinStride = BinStride/32;
+    uint Attr;
 
+    float TextureLayer;
+};
 
-const int MaxVariants = 256;
+layout (std430, binding = 0) readonly buffer PolygonBuffer
+{
+    Polygon Polygons[];
+};
+)"};
+
+const std::string BinningBuffer{R"(
 
-layout (std430, binding = 3)
-buffer BinResultBuffer
+layout (std430, binding = 6) buffer BinResultBuffer
 {
     uvec4 VariantWorkCount[MaxVariants];
     uint SortedWorkOffset[MaxVariants];
 
     uvec4 SortWorkWorkCount;
-    uvec2 UnsortedWorkDescs[MaxWorkTiles];
-    uvec2 SortedWork[MaxWorkTiles];
 
-    uint BinnedMaskCoarse[TilesPerLine*TileLines*CoarseBinStride];
-    uint BinnedMask[TilesPerLine*TileLines*BinStride];
-    uint WorkOffsets[TilesPerLine*TileLines*BinStride];
+    uint BinningMaskAndOffset[];
+    //uint BinnedMaskCoarse[TilesPerLine*TileLines*CoarseBinStride];
+    //uint BinnedMask[TilesPerLine*TileLines*BinStride];
+    //uint WorkOffsets[TilesPerLine*TileLines*BinStride];
 };
 
-#if defined(Rasterise) || defined(DepthBlend)
-layout (std430, binding = 4)
-#ifdef Rasterise
-writeonly
-#endif
-#ifdef DepthBlend
-readonly
-#endif
-buffer TilesBuffer
+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
 {
-    uint ColorTiles[MaxWorkTiles*TileSize*TileSize];
-    uint DepthTiles[MaxWorkTiles*TileSize*TileSize];
-    uint AttrTiles[MaxWorkTiles*TileSize*TileSize];
+    //uvec2 UnsortedWorkDescs[MaxWorkTiles];
+    //uvec2 SortedWorkDescs[MaxWorkTiles];
+    uvec2 WorkDescs[];
 };
-#endif
 
-#if defined(DepthBlend) || defined(FinalPass)
-layout (std430, binding = 5)
-#ifdef DepthBlend
-writeonly
-#endif
-#ifdef FinalPass
-readonly
-#endif
-buffer RasterResult
+const uint WorkDescsUnsortedStart = 0;
+const uint WorkDescsSortedStart = WorkDescsUnsortedStart+MaxWorkTiles;
+
+)"};
+
+const std::string Tilebuffers{R"(
+layout (std430, binding = 2) buffer ColorTileBuffer
 {
-    uint ColorResult[ScreenWidth*ScreenHeight*2];
-    uint DepthResult[ScreenWidth*ScreenHeight*2];
-    uint AttrResult[ScreenWidth*ScreenHeight*2];
+    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[];
 };
-#endif
+
+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
 {
@@ -243,6 +373,12 @@ layout (std140, binding = 0) uniform MetaUniform
     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)
 {
@@ -338,58 +474,6 @@ uint Div64_32_32(uint numHi, uint numLo, uint den)
     return bitfieldInsert(qhat, q1, 16, 16);
 }
 
-#ifdef InterpSpans
-const int YFactorShift = 9;
-#else
-const int YFactorShift = 8;
-#endif
-
-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 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;
-    }
-}
-
 int InterpolateAttrPersp(int y0, int y1, int ifactor)
 {
     if (y0 == y1)
@@ -548,67 +632,14 @@ uint InterpolateZWBuffer(int z0, int z1, int ifactor)
         return uint(z1) + uint((int64_t(z0-z1) * int64_t((1<<YFactorShift)-ifactor)) >> YFactorShift);
     }*/
 }
-
-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
 
 )";
 
-const char* InterpSpans = R"(
-
+const std::string InterpSpans = 
+    PolygonBuffer +
+    XSpanSetupBuffer +
+    YSpanSetupBuffer + R"(
 layout (local_size_x = 32) in;
 
 layout (binding = 0, rgba16ui) uniform readonly uimageBuffer SetupIndices;
@@ -803,7 +834,8 @@ void main()
 
 )";
 
-const char* ClearIndirectWorkCount = R"(
+const std::string ClearIndirectWorkCount =
+    BinningBuffer + R"(
 
 layout (local_size_x = 32) in;
 
@@ -814,19 +846,23 @@ void main()
 
 )";
 
-const char* ClearCoarseBinMask = R"(
-
+const std::string ClearCoarseBinMask =
+    BinningBuffer + R"(
 layout (local_size_x = 32) in;
 
 void main()
 {
-    BinnedMaskCoarse[gl_GlobalInvocationID.x*CoarseBinStride+0] = 0;
-    BinnedMaskCoarse[gl_GlobalInvocationID.x*CoarseBinStride+1] = 0;
+    BinningMaskAndOffset[BinningCoarseMaskStart + gl_GlobalInvocationID.x*CoarseBinStride+0] = 0;
+    BinningMaskAndOffset[BinningCoarseMaskStart + gl_GlobalInvocationID.x*CoarseBinStride+1] = 0;
 }
 
 )";
 
-const char* BinCombined = R"(
+const std::string BinCombined =
+    PolygonBuffer +
+    BinningBuffer +
+    XSpanSetupBuffer +
+    WorkDescBuffer + R"(
 
 layout (local_size_x = 32) in;
 
@@ -942,15 +978,15 @@ void main()
 
     int linearTile = fineTile.x + fineTile.y * TilesPerLine + coarseTile.x * CoarseTileCountX + coarseTile.y * TilesPerLine * CoarseTileCountY;
 
-    BinnedMask[linearTile * BinStride + groupIdx] = binnedMask;
+    BinningMaskAndOffset[BinningMaskStart + linearTile * BinStride + groupIdx] = binnedMask;
     int coarseMaskIdx = linearTile * CoarseBinStride + (groupIdx >> 5);
     if (binnedMask != 0U)
-        atomicOr(BinnedMaskCoarse[coarseMaskIdx], 1U << (groupIdx & 0x1F));
+        atomicOr(BinningMaskAndOffset[BinningCoarseMaskStart + coarseMaskIdx], 1U << (groupIdx & 0x1F));
 
     if (binnedMask != 0U)
     {
         uint workOffset = atomicAdd(VariantWorkCount[0].w, uint(bitCount(binnedMask)));
-        WorkOffsets[linearTile * BinStride + groupIdx] = workOffset;
+        BinningMaskAndOffset[BinningWorkOffsetsStart + linearTile * BinStride + groupIdx] = workOffset;
 
         uint tilePositionCombined = bitfieldInsert(fineTileTopLeft.x, fineTileTopLeft.y, 16, 16);
 
@@ -964,7 +1000,7 @@ void main()
             int variantIdx = Polygons[polygonIdx].Variant;
 
             int inVariantOffset = int(atomicAdd(VariantWorkCount[variantIdx].z, 1));
-            UnsortedWorkDescs[workOffset + idx] = uvec2(tilePositionCombined, bitfieldInsert(inVariantOffset, polygonIdx, 16, 16));
+            WorkDescs[WorkDescsUnsortedStart + workOffset + idx] = uvec2(tilePositionCombined, bitfieldInsert(polygonIdx, inVariantOffset, 12, 20));
 
             idx++;
         }
@@ -973,7 +1009,8 @@ void main()
 
 )";
 
-const char* CalcOffsets = R"(
+const std::string CalcOffsets = 
+    BinningBuffer + R"(
 
 layout (local_size_x = 32) in;
 
@@ -993,7 +1030,10 @@ void main()
 
 )";
 
-const char* SortWork = R"(
+const std::string SortWork =
+    PolygonBuffer +
+    BinningBuffer +
+    WorkDescBuffer + R"(
 
 layout (local_size_x = 32) in;
 
@@ -1001,19 +1041,24 @@ void main()
 {
     if (gl_GlobalInvocationID.x < VariantWorkCount[0].w)
     {
-        uvec2 workDesc = UnsortedWorkDescs[gl_GlobalInvocationID.x];
-        int inVariantOffset = int(bitfieldExtract(workDesc.y, 0, 16));
-        int polygonIdx = int(bitfieldExtract(workDesc.y, 16, 16));
+        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;
-        SortedWork[sortedIndex] = uvec2(workDesc.x, bitfieldInsert(workDesc.y, gl_GlobalInvocationID.x, 0, 16));
+        WorkDescs[WorkDescsSortedStart + sortedIndex] = uvec2(workDesc.x, bitfieldInsert(workDesc.y, gl_GlobalInvocationID.x, 12, 20));
     }
 }
 
 )";
 
-const char* Rasterise = R"(
+const std::string Rasterise =
+    PolygonBuffer +
+    WorkDescBuffer +
+    XSpanSetupBuffer +
+    BinningBuffer +
+    Tilebuffers + R"(
 
 layout (local_size_x = TileSize, local_size_y = TileSize) in;
 
@@ -1024,10 +1069,10 @@ layout (location = 1) uniform vec2 InvTextureSize;
 
 void main()
 {
-    uvec2 workDesc = SortedWork[SortedWorkOffset[CurVariant] + gl_WorkGroupID.z];
-    Polygon polygon = Polygons[bitfieldExtract(workDesc.y, 16, 16)];
+    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, 0, 16)) * TileSize * TileSize + TileSize * int(gl_LocalInvocationID.y) + int(gl_LocalInvocationID.x);
+    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)
@@ -1203,7 +1248,11 @@ void main()
 
 )";
 
-const char* DepthBlend = R"(
+const std::string DepthBlend =
+    PolygonBuffer +
+    Tilebuffers +
+    ResultBuffer +
+    BinningBuffer + R"(
 
 layout (local_size_x = TileSize, local_size_y = TileSize) in;
 
@@ -1253,8 +1302,8 @@ void ProcessCoarseMask(int linearTile, uint coarseMask, uint coarseOffset,
 
         uint tileOffset = linearTile * BinStride + coarseBit + coarseOffset;
 
-        uint fineMask = BinnedMask[tileOffset];
-        uint workIdx = WorkOffsets[tileOffset];
+        uint fineMask = BinningMaskAndOffset[BinningMaskStart + tileOffset];
+        uint workIdx = BinningMaskAndOffset[BinningWorkOffsetsStart + tileOffset];
 
         while (fineMask != 0U)
         {
@@ -1403,8 +1452,8 @@ void main()
 {
     int linearTile = int(gl_WorkGroupID.x + (gl_WorkGroupID.y * TilesPerLine));
 
-    uint coarseMaskLo = BinnedMaskCoarse[linearTile*CoarseBinStride + 0];
-    uint coarseMaskHi = BinnedMaskCoarse[linearTile*CoarseBinStride + 1];
+    uint coarseMaskLo = BinningMaskAndOffset[BinningCoarseMaskStart + linearTile*CoarseBinStride + 0];
+    uint coarseMaskHi = BinningMaskAndOffset[BinningCoarseMaskStart + linearTile*CoarseBinStride + 1];
 
     uvec2 color = uvec2(ClearColor, 0U);
     uvec2 depth = uvec2(ClearDepth, 0U);
@@ -1416,17 +1465,18 @@ void main()
     ProcessCoarseMask(linearTile, coarseMaskHi, BinStride/2, color, depth, attr, stencil, prevIsShadowMask);
 
     int resultOffset = int(gl_GlobalInvocationID.x) + int(gl_GlobalInvocationID.y) * ScreenWidth;
-    ColorResult[resultOffset] = color.x;
-    ColorResult[resultOffset+FramebufferStride] = color.y;
-    DepthResult[resultOffset] = depth.x;
-    DepthResult[resultOffset+FramebufferStride] = depth.y;
-    AttrResult[resultOffset] = attr.x;
-    AttrResult[resultOffset+FramebufferStride] = attr.y;
+    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 char* FinalPass = R"(
+const std::string FinalPass =
+    ResultBuffer + R"(
 
 layout (local_size_x = 32) in;
 
@@ -1481,9 +1531,9 @@ void main()
     int srcX = int(gl_GlobalInvocationID.x);
     int resultOffset = int(srcX) + int(gl_GlobalInvocationID.y) * ScreenWidth;
 
-    uvec2 color = uvec2(ColorResult[resultOffset], ColorResult[resultOffset+FramebufferStride]);
-    uvec2 depth = uvec2(DepthResult[resultOffset], DepthResult[resultOffset+FramebufferStride]);
-    uvec2 attr = uvec2(AttrResult[resultOffset], AttrResult[resultOffset+FramebufferStride]);
+    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)
@@ -1493,23 +1543,23 @@ void main()
 
         if (srcX > 0U)
         {
-            otherAttr.x = AttrResult[resultOffset-1];
-            otherDepth.x = DepthResult[resultOffset-1];
+            otherAttr.x = ResultValue[resultOffset-1+ResultAttrStart];
+            otherDepth.x = ResultValue[resultOffset-1+ResultDepthStart];
         }
         if (srcX < ScreenWidth-1)
         {
-            otherAttr.y = AttrResult[resultOffset+1];
-            otherDepth.y = DepthResult[resultOffset+1];
+            otherAttr.y = ResultValue[resultOffset+1+ResultAttrStart];
+            otherDepth.y = ResultValue[resultOffset+1+ResultDepthStart];
         }
         if (gl_GlobalInvocationID.y > 0U)
         {
-            otherAttr.z = AttrResult[resultOffset-ScreenWidth];
-            otherDepth.z = DepthResult[resultOffset-ScreenWidth];
+            otherAttr.z = ResultValue[resultOffset-ScreenWidth+ResultAttrStart];
+            otherDepth.z = ResultValue[resultOffset-ScreenWidth+ResultDepthStart];
         }
         if (gl_GlobalInvocationID.y < ScreenHeight-1)
         {
-            otherAttr.w = AttrResult[resultOffset+ScreenWidth];
-            otherDepth.w = DepthResult[resultOffset+ScreenWidth];
+            otherAttr.w = ResultValue[resultOffset+ScreenWidth+ResultAttrStart];
+            otherDepth.w = ResultValue[resultOffset+ScreenWidth+ResultDepthStart];
         }
 
         uint polyId = bitfieldExtract(attr.x, 24, 6);
diff --git a/src/GPU3D_OpenGL.cpp b/src/GPU3D_OpenGL.cpp
index 517f481d7..c67d0f168 100644
--- a/src/GPU3D_OpenGL.cpp
+++ b/src/GPU3D_OpenGL.cpp
@@ -27,26 +27,22 @@
 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;
 
     GLuint prog;
     bool ret = OpenGL::CompileVertexFragmentProgram(prog,
@@ -55,9 +51,6 @@ bool GLRenderer::BuildRenderShader(u32 flags, const char* vs, const char* fs)
         {{"vPosition", 0}, {"vColor", 1}, {"vTexcoord", 2}, {"vPolygonAttr", 3}},
         {{"oColor", 0}, {"oAttr", 1}});
 
-    delete[] vsbuf;
-    delete[] fsbuf;
-
     if (!ret) return false;
 
     GLint uni_id = glGetUniformBlockIndex(prog, "uConfig");
diff --git a/src/GPU3D_OpenGL.h b/src/GPU3D_OpenGL.h
index cb3bd7cbf..21f815c69 100644
--- a/src/GPU3D_OpenGL.h
+++ b/src/GPU3D_OpenGL.h
@@ -64,7 +64,7 @@ class GLRenderer : public Renderer3D
 
     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);
diff --git a/src/OpenGLSupport.cpp b/src/OpenGLSupport.cpp
index 6b6fba8a7..4cb0e9772 100644
--- a/src/OpenGLSupport.cpp
+++ b/src/OpenGLSupport.cpp
@@ -18,19 +18,179 @@
 
 #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 CompilerShader(GLuint& id, const char* source, const char* name, const char* type)
+struct ShaderCacheEntry
+{
+    u32 Length;
+    u8* Data;
+    u32 BinaryFormat;
+
+    ShaderCacheEntry(u8* data, u32 length, u32 binaryFmt)
+        : Length(length), Data(data), BinaryFormat(binaryFmt)
+    {
+        assert(data != nullptr);
+    }
+
+    ShaderCacheEntry(const ShaderCacheEntry&) = delete;
+    ShaderCacheEntry(ShaderCacheEntry&& other)
+    {
+        Data = other.Data;
+        Length = other.Length;
+        BinaryFormat = other.BinaryFormat;
+
+        other.Data = nullptr;
+        other.Length = 0;
+        other.BinaryFormat = 0;
+    }
+
+    ~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;
+    }
+
+    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());
+
+    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 len;
     int res;
 
-    len = strlen(source);
-    glShaderSource(id, 1, &source, &len);
+    const char* sourceC = source.c_str();
+    int len = source.length();
+    glShaderSource(id, 1, &sourceC, &len);
     glCompileShader(id);
 
     glGetShaderiv(id, GL_COMPILE_STATUS, &res);
@@ -40,8 +200,8 @@ bool CompilerShader(GLuint& id, const char* source, const char* name, const char
         if (res < 1) res = 1024;
         char* log = new char[res+1];
         glGetShaderInfoLog(id, res+1, NULL, log);
-        Log(LogLevel::Error, "OpenGL: failed to compile %s shader %s: %s\n", type, name, log);
-        Log(LogLevel::Debug, "shader source:\n--\n%s\n--\n", source);
+        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;
 
         return false;
@@ -80,14 +240,32 @@ bool LinkProgram(GLuint& result, GLuint* ids, int numIds)
     return true;
 }
 
-bool CompileComputeProgram(GLuint& result, const char* source, const char* name)
+bool CompileComputeProgram(GLuint& result, const std::string& source, const std::string& name)
 {
+    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;
 
-    result = glCreateProgram();
-
-    printf("compiling %s", name);
     if (!CompilerShader(shader, source, name, "compute"))
         goto error;
 
@@ -97,14 +275,28 @@ bool CompileComputeProgram(GLuint& result, const char* source, const char* name)
     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;
 }
 
 bool CompileVertexFragmentProgram(GLuint& result,
-    const char* vs, const char* fs,
-    const char* name,
+    const std::string& vs, const std::string& fs,
+    const std::string& name,
     const std::initializer_list<AttributeTarget>& vertexInAttrs,
     const std::initializer_list<AttributeTarget>& fragmentOutAttrs)
 {
diff --git a/src/OpenGLSupport.h b/src/OpenGLSupport.h
index 7d8aae449..ec2cb1f19 100644
--- a/src/OpenGLSupport.h
+++ b/src/OpenGLSupport.h
@@ -29,19 +29,23 @@
 namespace OpenGL
 {
 
+void LoadShaderCache();
+void SaveShaderCache();
+
 struct AttributeTarget
 {
     const char* Name;
     u32 Location;
 };
 
+
 bool CompileVertexFragmentProgram(GLuint& result,
-    const char* vs, const char* fs,
-    const char* name,
+    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 char* source, const char* name);
+bool CompileComputeProgram(GLuint& result, const std::string& source, const std::string& name);
 
 }

From f11cfa324808c1a026df1e1b355ff561a4468d49 Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Sat, 13 May 2023 22:40:50 +0200
Subject: [PATCH 16/20] apparently & is not defined on bvec4 why does this even
 compile on Intel and Nvidia?

---
 src/GPU3D_Compute_shaders.h | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/GPU3D_Compute_shaders.h b/src/GPU3D_Compute_shaders.h
index dccbe6ee9..39858a4af 100644
--- a/src/GPU3D_Compute_shaders.h
+++ b/src/GPU3D_Compute_shaders.h
@@ -1568,7 +1568,10 @@ void main()
         bvec4 polyIdMismatch = notEqual(uvec4(polyId), otherPolyId);
         bvec4 nearer = lessThan(uvec4(depth.x), otherDepth);
 
-        if (any(polyIdMismatch & nearer))
+        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;

From 4ab0447f2c1acab0e2418a060aaac97899a44c8f Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Sun, 14 May 2023 19:52:40 +0200
Subject: [PATCH 17/20] put the texture cache into it's own file

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index ec07aa770..73ea9d5bf 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,8 @@ if (ENABLE_OGLRENDERER)
         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 68779142a..21da0ae2c 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 dba920c11..4db18f3c7 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 23db96696..d08e58ff3 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;
diff --git a/src/GPU.h b/src/GPU.h
index 96867044c..96d5b5404 100644
--- a/src/GPU.h
+++ b/src/GPU.h
@@ -617,6 +617,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 9d616d31b..f4357e3a0 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 54027f465..c4fb81d81 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
 {
diff --git a/src/GPU3D.cpp b/src/GPU3D.cpp
index 5c4857508..d1887bb11 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_Compute.cpp b/src/GPU3D_Compute.cpp
index 348562355..e5c347976 100644
--- a/src/GPU3D_Compute.cpp
+++ b/src/GPU3D_Compute.cpp
@@ -20,9 +20,6 @@
 
 #include <assert.h>
 
-#define XXH_STATIC_LINKING_ONLY
-#include "xxhash/xxhash.h"
-
 #include "OpenGLSupport.h"
 
 #include "GPU3D_Compute_shaders.h"
@@ -31,7 +28,7 @@ namespace GPU3D
 {
 
 ComputeRenderer::ComputeRenderer()
-    : Renderer3D(true)
+    : Renderer3D(true), Texcache(TexcacheOpenGLLoader())
 {}
 
 ComputeRenderer::~ComputeRenderer()
@@ -72,8 +69,8 @@ void blah(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,con
 
 bool ComputeRenderer::Init()
 {
-    glDebugMessageCallback(blah, NULL);
-    glEnable(GL_DEBUG_OUTPUT);
+    //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);
@@ -120,7 +117,7 @@ bool ComputeRenderer::Init()
 
 void ComputeRenderer::DeInit()
 {
-    ResetTexcache();
+    Texcache.Reset();
 
     glDeleteBuffers(1, &YSpanSetupMemory);
     glDeleteBuffers(1, &RenderPolygonMemory);
@@ -180,24 +177,9 @@ void ComputeRenderer::DeleteShaders()
         glDeleteProgram(program);
 }
 
-void ComputeRenderer::ResetTexcache()
-{
-    for (u32 i = 0; i < 8; i++)
-    {
-        for (u32 j = 0; j < 8; j++)
-        {
-            for (u32 k = 0; k < TexArrays[i][j].size(); k++)
-                glDeleteTextures(1, &TexArrays[i][j][k]);
-            TexArrays[i][j].clear();
-            FreeTextures[i][j].clear();
-        }
-    }
-    TexCache.clear();
-}
-
 void ComputeRenderer::Reset()
 {
-    ResetTexcache();
+    Texcache.Reset();
 }
 
 void ComputeRenderer::SetRenderSettings(GPU::RenderSettings& settings)
@@ -496,402 +478,6 @@ void ComputeRenderer::SetupYSpan(RenderPolygon* rp, SpanSetupY* span, Polygon* p
     }
 }
 
-inline u32 TextureWidth(u32 texparam)
-{
-    return 8 << ((texparam >> 20) & 0x7);
-}
-
-inline u32 TextureHeight(u32 texparam)
-{
-    return 8 << ((texparam >> 23) & 0x7);
-}
-
-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);
-}
-
-enum
-{
-    outputFmt_RGB6A5,
-    outputFmt_RGBA8,
-    outputFmt_BGRA8
-};
-
-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 <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 <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;
-            }
-        }
-    }
-}
-
-ComputeRenderer::TexCacheEntry& ComputeRenderer::GetTexture(u32 texParam, u32 palBase)
-{
-    // 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 = TexCache.find(key);
-
-    if (it != TexCache.end())
-        return it->second;
-
-    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;
-
-        for (u32 i = 0; i < width*height; i++)
-        {
-            u16 value = *(u16*)&GPU::VRAMFlat_Texture[addr + i * 2];
-
-            TextureDecodingBuffer[i] = ConvertRGB5ToRGB6(value) | (value & 0x8000 ? 0x1F000000 : 0);
-        }
-    }
-    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, TextureDecodingBuffer, 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, TextureDecodingBuffer, texData, palData); break;
-        case 6: ConvertAXIYTexture<outputFmt_RGB6A5, 5, 3>(width, height, TextureDecodingBuffer, texData, palData); break;
-        case 2: ConvertNColorsTexture<outputFmt_RGB6A5, 2>(width, height, TextureDecodingBuffer, texData, palData, color0Transparent); break;
-        case 3: ConvertNColorsTexture<outputFmt_RGB6A5, 4>(width, height, TextureDecodingBuffer, texData, palData, color0Transparent); break;
-        case 4: ConvertNColorsTexture<outputFmt_RGB6A5, 8>(width, height, TextureDecodingBuffer, 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
-        glGenTextures(1, &array);
-        glBindTexture(GL_TEXTURE_2D_ARRAY, array);
-        glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8UI, width, height, layers);
-        //printf("allocating new layer set for %d %d %d %d\n", width, height, texArrays.size()-1, array.ImageDescriptor);
-
-        for (u32 i = 0; i < layers; i++)
-        {
-            freeTextures.push_back(TexArrayEntry{array, i});
-        }
-    }
-
-    TexArrayEntry storagePlace = freeTextures[freeTextures.size()-1];
-    freeTextures.pop_back();
-
-    //printf("using storage place %d %d | %d %d (%d)\n", width, height, storagePlace.TexArrayIdx, storagePlace.LayerIdx, array.ImageDescriptor);
-
-    glBindTexture(GL_TEXTURE_2D_ARRAY, storagePlace.TextureID);
-    glTexSubImage3D(GL_TEXTURE_2D_ARRAY,
-        0, 0, 0, storagePlace.Layer,
-        width, height, 1,
-        GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, TextureDecodingBuffer);
-
-    entry.Texture = storagePlace;
-
-    return TexCache.emplace(std::make_pair(key, entry)).first->second;
-}
-
 struct Variant
 {
     GLuint Texture, Sampler;
@@ -921,69 +507,8 @@ struct Variant
 void ComputeRenderer::RenderFrame()
 {
     //printf("render frame\n");
-    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 = TexCache.begin(); it != TexCache.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 = TexCache.erase(it);
-        }
-    }
-    else if (RenderFrameIdentical)
+    if (!Texcache.Update() && RenderFrameIdentical)
     {
         return;
     }
@@ -1006,8 +531,6 @@ void ComputeRenderer::RenderFrame()
     u32 numVariants = 0, prevVariant, prevTexLayer;
     Variant variants[MaxVariants];
 
-    int foundviatexcache = 0, foundviaprev = 0, numslow = 0;
-
     bool enableTextureMaps = RenderDispCnt & (1<<0);
 
     for (int i = 0; i < RenderNumPolygons; i++)
@@ -1033,8 +556,6 @@ void ComputeRenderer::RenderFrame()
                 && prevPolygon->TexPalette == polygon->TexPalette
                 && (prevPolygon->Attr & 0x30) == (polygon->Attr & 0x30)
                 && prevPolygon->IsShadowMask == polygon->IsShadowMask;
-            if (foundVariant)
-                foundviaprev++;
         }
 
         if (!foundVariant)
@@ -1043,30 +564,26 @@ void ComputeRenderer::RenderFrame()
             variant.BlendMode = polygon->IsShadowMask ? 4 : ((polygon->Attr >> 4) & 0x3);
             variant.Texture = 0;
             variant.Sampler = 0;
-            TexCacheEntry* texcacheEntry = nullptr;
+            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)
             {
-                texcacheEntry = &GetTexture(polygon->TexParam, polygon->TexPalette);
+                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];
-                variant.Texture = texcacheEntry->Texture.TextureID;
-                prevTexLayer = texcacheEntry->Texture.Layer;
 
-                if (texcacheEntry->LastVariant < numVariants && variants[texcacheEntry->LastVariant] == variant)
+                if (*textureLastVariant < numVariants && variants[*textureLastVariant] == variant)
                 {
                     foundVariant = true;
-                    prevVariant = texcacheEntry->LastVariant;
-                    foundviatexcache++;
+                    prevVariant = *textureLastVariant;
                 }
             }
 
             if (!foundVariant)
             {
-                numslow++;
                 for (int j = numVariants - 1; j >= 0; j--)
                 {
                     if (variants[j] == variant)
@@ -1085,8 +602,8 @@ void ComputeRenderer::RenderFrame()
                 assert(numVariants <= MaxVariants);
             foundVariant:;
 
-                if (texcacheEntry)
-                    texcacheEntry->LastVariant = prevVariant;
+                if (textureLastVariant)
+                    *textureLastVariant = prevVariant;
             }
         }
         RenderPolygons[i].Variant = prevVariant;
diff --git a/src/GPU3D_Compute.h b/src/GPU3D_Compute.h
index b28a3006e..d91075a0a 100644
--- a/src/GPU3D_Compute.h
+++ b/src/GPU3D_Compute.h
@@ -23,9 +23,9 @@
 
 #include "OpenGLSupport.h"
 
-#include "NonStupidBitfield.h"
+#include "GPU3D_TexcacheOpenGL.h"
 
-#include <unordered_map>
+#include "NonStupidBitfield.h"
 
 namespace GPU3D
 {
@@ -179,25 +179,7 @@ class ComputeRenderer : public Renderer3D
     SpanSetupY YSpanSetups[MaxYSpanSetups];
     RenderPolygon RenderPolygons[2048];
 
-    struct TexArrayEntry
-    {
-        GLuint 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> TexCache;
+    TexcacheOpenGL Texcache;
 
     struct MetaUniform
     {
@@ -215,27 +197,19 @@ class ComputeRenderer : public Renderer3D
     };
     GLuint MetaUniformMemory;
 
-    std::vector<TexArrayEntry> FreeTextures[8][8];
-    std::vector<GLuint> TexArrays[8][8];
-
     GLuint Samplers[9];
 
-    u32 TextureDecodingBuffer[1024*1024];
-
     GLuint Framebuffer = 0;
     GLuint LowResFramebuffer;
     GLuint PixelBuffer;
 
     u32 FramebufferCPU[256*192];
 
-    TexCacheEntry& GetTexture(u32 textureParam, u32 paletteParam);
-
     int ScreenWidth, ScreenHeight;
     int TilesPerLine, TileLines;
     int ScaleFactor = -1;
     int MaxWorkTiles;
 
-    void ResetTexcache();
     void DeleteShaders();
 
     void SetupAttrs(SpanSetupY* span, Polygon* poly, int from, int to);
diff --git a/src/GPU3D_Texcache.cpp b/src/GPU3D_Texcache.cpp
new file mode 100644
index 000000000..1d409c23c
--- /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 000000000..73d70cbae
--- /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 000000000..047323714
--- /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 000000000..d61ae2432
--- /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/NDS.cpp b/src/NDS.cpp
index b5c00db12..526145dd0 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"

From bb4cbbe5b5cd0ae2cee163cbd04f6636d707bd70 Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Sun, 14 May 2023 22:16:11 +0200
Subject: [PATCH 18/20] add compute shader renderer properly to the GUI also
 add option to toggle using high resolution vertex coordinates

diff --git a/src/GPU.cpp b/src/GPU.cpp
index d08e58ff3..af691a952 100644
--- a/src/GPU.cpp
+++ b/src/GPU.cpp
@@ -387,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
@@ -398,7 +398,10 @@ void InitRenderer(int renderer)
             GPU3D::CurrentRenderer = std::make_unique<GPU3D::SoftRenderer>();
             GPU3D::CurrentRenderer->Init();
         }
-        GPU3D::CurrentRenderer = std::make_unique<GPU3D::ComputeRenderer>();
+        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 96d5b5404..ee75fc197 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();
diff --git a/src/GPU3D_Compute.cpp b/src/GPU3D_Compute.cpp
index e5c347976..76df9e0b7 100644
--- a/src/GPU3D_Compute.cpp
+++ b/src/GPU3D_Compute.cpp
@@ -196,6 +196,8 @@ void ComputeRenderer::SetRenderSettings(GPU::RenderSettings& settings)
     TilesPerLine = ScreenWidth/TileSize;
     TileLines = ScreenHeight/TileSize;
 
+    HiresCoordinates = settings.GL_HiresCoordinates;
+
     MaxWorkTiles = TilesPerLine*TileLines*8;
 
     for (int i = 0; i < tilememoryLayer_Num; i++)
@@ -628,8 +630,16 @@ void ComputeRenderer::RenderFrame()
         s32 ytop = ScreenHeight, ybot = 0;
         for (int i = 0; i < polygon->NumVertices; i++)
         {
-            scaledPositions[i][0] = (polygon->Vertices[i]->HiresPosition[0] * ScaleFactor) >> 4;
-            scaledPositions[i][1] = (polygon->Vertices[i]->HiresPosition[1] * ScaleFactor) >> 4;
+            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);
         }
diff --git a/src/GPU3D_Compute.h b/src/GPU3D_Compute.h
index d91075a0a..73f840b96 100644
--- a/src/GPU3D_Compute.h
+++ b/src/GPU3D_Compute.h
@@ -209,6 +209,7 @@ class ComputeRenderer : public Renderer3D
     int TilesPerLine, TileLines;
     int ScaleFactor = -1;
     int MaxWorkTiles;
+    bool HiresCoordinates;
 
     void DeleteShaders();
 
diff --git a/src/frontend/qt_sdl/Config.cpp b/src/frontend/qt_sdl/Config.cpp
index 49c41a1b5..9fff6ca9c 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;
@@ -228,11 +230,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.h b/src/frontend/qt_sdl/Config.h
index 2028879a6..4d31080b7 100644
--- a/src/frontend/qt_sdl/Config.h
+++ b/src/frontend/qt_sdl/Config.h
@@ -114,6 +114,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/VideoSettingsDialog.cpp b/src/frontend/qt_sdl/VideoSettingsDialog.cpp
index 95ec7d31d..5ef10c5a6 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 7fee5bb89..166a8266e 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 slots:
     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 11cfe3d9b..ff9baf8ff 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 9ec28cc1e..b5198c9b5 100644
--- a/src/frontend/qt_sdl/main.cpp
+++ b/src/frontend/qt_sdl/main.cpp
@@ -322,6 +322,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)
     {
@@ -443,16 +444,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);
             }
@@ -1849,7 +1851,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)
     {
@@ -3264,13 +3266,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);

From a6d6869fa486db42686b513b4242c2baaedc7b0e Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Sun, 14 May 2023 22:37:52 +0200
Subject: [PATCH 19/20] unbind sampler object in compute shader renderer

---
 src/GPU3D_Compute.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/GPU3D_Compute.cpp b/src/GPU3D_Compute.cpp
index 76df9e0b7..d4972774a 100644
--- a/src/GPU3D_Compute.cpp
+++ b/src/GPU3D_Compute.cpp
@@ -956,6 +956,8 @@ void ComputeRenderer::RenderFrame()
     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);*/

From b3d367a80c68614afc533805a78bb0420159ed79 Mon Sep 17 00:00:00 2001
From: RSDuck <RSDuck@users.noreply.github.com>
Date: Mon, 29 May 2023 23:30:23 +0200
Subject: [PATCH 20/20] fix GetRangedBitMask for 64 bit aligned 64 bits pretty
 embarassing

---
 src/NonStupidBitfield.h | 544 ++++++++++++++++++++--------------------
 1 file changed, 272 insertions(+), 272 deletions(-)

diff --git a/src/NonStupidBitfield.h b/src/NonStupidBitfield.h
index 759946de9..d5a179e34 100644
--- a/src/NonStupidBitfield.h
+++ b/src/NonStupidBitfield.h
@@ -1,272 +1,272 @@
-/*
-    Copyright 2016-2022 melonDS team, RSDuck
-
-    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 NONSTUPIDBITFIELD_H
-#define NONSTUPIDBITFIELD_H
-
-#include "types.h"
-
-#include <memory.h>
-
-#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));
-        else
-            return 0xFFFFFFFFFFFFFFFF;
-
-        return 0xFFFFFFFFFFFFFFFF;
-    }
-    else if (idx == startEntry)
-    {
-        return ((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)
-
-template <u32 Size>
-struct NonStupidBitField
-{
-    static constexpr u32 DataLength = (Size + 0x3F) >> 6;
-    u64 Data[DataLength];
-
-    struct Ref
-    {
-        NonStupidBitField<Size>& BitField;
-        u32 Idx;
-
-        operator bool()
-        {
-            return BitField.Data[Idx >> 6] & (1ULL << (Idx & 0x3F));
-        }
-
-        Ref& operator=(bool set)
-        {
-            BitField.Data[Idx >> 6] &= ~(1ULL << (Idx & 0x3F));
-            BitField.Data[Idx >> 6] |= ((u64)set << (Idx & 0x3F));
-            return *this;
-        }
-    };
-
-    struct Iterator
-    {
-        NonStupidBitField<Size>& BitField;
-        u32 DataIdx;
-        u32 BitIdx;
-        u64 RemainingBits;
-
-        u32 operator*() { return DataIdx * 64 + BitIdx; }
-
-        bool operator==(const Iterator& other)
-        {
-            return other.DataIdx == DataIdx;
-        }
-        bool operator!=(const Iterator& other)
-        {
-            return other.DataIdx != DataIdx;
-        }
-
-        void Next()
-        {
-            if (RemainingBits == 0)
-            {
-                for (u32 i = DataIdx + 1; i < DataLength; i++)
-                {
-                    if (BitField.Data[i])
-                    {
-                        DataIdx = i;
-                        RemainingBits = BitField.Data[i];
-                        goto done;
-                    }
-                }
-                DataIdx = DataLength;
-                return;
-            done:;
-            }
-
-            BitIdx = __builtin_ctzll(RemainingBits);
-            RemainingBits &= ~(1ULL << BitIdx);
-
-            if ((Size & 0x3F) && BitIdx >= Size)
-                DataIdx = DataLength;
-        }
-
-        Iterator operator++(int)
-        {
-            Iterator prev(*this);
-            ++*this;
-            return prev;
-        }
-
-        Iterator& operator++()
-        {
-            Next();
-            return *this;
-        }
-    };
-
-    NonStupidBitField(u32 startBit, u32 bitsCount)
-    {
-        Clear();
-
-        if (bitsCount == 0)
-            return;
-
-        SetRange(startBit, bitsCount);
-        /*for (int i = 0; i < Size; i++)
-        {
-            bool state = (*this)[i];
-            if (state != (i >= startBit && i < startBit + bitsCount))
-            {
-                for (u32 j = 0; j < DataLength; j++)
-                    printf("data %016lx\n", Data[j]);
-                printf("blarg %d %d %d %d\n", i, startBit, bitsCount, Size);
-                abort();
-            }
-        }*/
-    }
-
-    NonStupidBitField()
-    {
-        Clear();
-    }
-
-    Iterator End()
-    {
-        return Iterator{*this, DataLength, 0, 0};
-    }
-    Iterator Begin()
-    {
-        for (u32 i = 0; i < DataLength; i++)
-        {
-            u32 idx = __builtin_ctzll(Data[i]);
-            if (Data[i] && idx + i * 64 < Size)
-            {
-                return {*this, i, idx, Data[i] & ~(1ULL << idx)};
-            }
-        }
-        return End();
-    }
-
-    void Clear()
-    {
-        memset(Data, 0, sizeof(Data));
-    }
-
-    Ref operator[](u32 idx)
-    {
-        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;
-        u64 entriesCount = (((startBit + bitsCount + 0x3F) & ~0x3F) >> 6) - startEntry;
-
-        if (entriesCount > 1)
-        {
-            Data[startEntry] |= 0xFFFFFFFFFFFFFFFF << (startBit & 0x3F);
-            if ((startBit + bitsCount) & 0x3F)
-                Data[startEntry + entriesCount - 1] |= ~(0xFFFFFFFFFFFFFFFF << ((startBit + bitsCount) & 0x3F));
-            else
-                Data[startEntry + entriesCount - 1] = 0xFFFFFFFFFFFFFFFF;
-            for (u64 i = startEntry + 1; i < startEntry + entriesCount - 1; i++)
-                Data[i] = 0xFFFFFFFFFFFFFFFF;
-        }
-        else
-        {
-            Data[startEntry] |= ((1ULL << bitsCount) - 1) << (startBit & 0x3F);
-        }
-    }
-
-    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++)
-        {
-            Data[i] |= other.Data[i];
-        }
-        return *this;
-    }
-
-    NonStupidBitField& operator&=(const NonStupidBitField<Size>& other)
-    {
-        for (u32 i = 0; i < DataLength; i++)
-        {
-            Data[i] &= other.Data[i];
-        }
-        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;
-    }
-};
-
-
-#endif
+/*
+    Copyright 2016-2022 melonDS team, RSDuck
+
+    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 NONSTUPIDBITFIELD_H
+#define NONSTUPIDBITFIELD_H
+
+#include "types.h"
+
+#include <memory.h>
+
+#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)
+
+template <u32 Size>
+struct NonStupidBitField
+{
+    static constexpr u32 DataLength = (Size + 0x3F) >> 6;
+    u64 Data[DataLength];
+
+    struct Ref
+    {
+        NonStupidBitField<Size>& BitField;
+        u32 Idx;
+
+        operator bool()
+        {
+            return BitField.Data[Idx >> 6] & (1ULL << (Idx & 0x3F));
+        }
+
+        Ref& operator=(bool set)
+        {
+            BitField.Data[Idx >> 6] &= ~(1ULL << (Idx & 0x3F));
+            BitField.Data[Idx >> 6] |= ((u64)set << (Idx & 0x3F));
+            return *this;
+        }
+    };
+
+    struct Iterator
+    {
+        NonStupidBitField<Size>& BitField;
+        u32 DataIdx;
+        u32 BitIdx;
+        u64 RemainingBits;
+
+        u32 operator*() { return DataIdx * 64 + BitIdx; }
+
+        bool operator==(const Iterator& other)
+        {
+            return other.DataIdx == DataIdx;
+        }
+        bool operator!=(const Iterator& other)
+        {
+            return other.DataIdx != DataIdx;
+        }
+
+        void Next()
+        {
+            if (RemainingBits == 0)
+            {
+                for (u32 i = DataIdx + 1; i < DataLength; i++)
+                {
+                    if (BitField.Data[i])
+                    {
+                        DataIdx = i;
+                        RemainingBits = BitField.Data[i];
+                        goto done;
+                    }
+                }
+                DataIdx = DataLength;
+                return;
+            done:;
+            }
+
+            BitIdx = __builtin_ctzll(RemainingBits);
+            RemainingBits &= ~(1ULL << BitIdx);
+
+            if ((Size & 0x3F) && BitIdx >= Size)
+                DataIdx = DataLength;
+        }
+
+        Iterator operator++(int)
+        {
+            Iterator prev(*this);
+            ++*this;
+            return prev;
+        }
+
+        Iterator& operator++()
+        {
+            Next();
+            return *this;
+        }
+    };
+
+    NonStupidBitField(u32 startBit, u32 bitsCount)
+    {
+        Clear();
+
+        if (bitsCount == 0)
+            return;
+
+        SetRange(startBit, bitsCount);
+        /*for (int i = 0; i < Size; i++)
+        {
+            bool state = (*this)[i];
+            if (state != (i >= startBit && i < startBit + bitsCount))
+            {
+                for (u32 j = 0; j < DataLength; j++)
+                    printf("data %016lx\n", Data[j]);
+                printf("blarg %d %d %d %d\n", i, startBit, bitsCount, Size);
+                abort();
+            }
+        }*/
+    }
+
+    NonStupidBitField()
+    {
+        Clear();
+    }
+
+    Iterator End()
+    {
+        return Iterator{*this, DataLength, 0, 0};
+    }
+    Iterator Begin()
+    {
+        for (u32 i = 0; i < DataLength; i++)
+        {
+            u32 idx = __builtin_ctzll(Data[i]);
+            if (Data[i] && idx + i * 64 < Size)
+            {
+                return {*this, i, idx, Data[i] & ~(1ULL << idx)};
+            }
+        }
+        return End();
+    }
+
+    void Clear()
+    {
+        memset(Data, 0, sizeof(Data));
+    }
+
+    Ref operator[](u32 idx)
+    {
+        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;
+        u64 entriesCount = (((startBit + bitsCount + 0x3F) & ~0x3F) >> 6) - startEntry;
+
+        if (entriesCount > 1)
+        {
+            Data[startEntry] |= 0xFFFFFFFFFFFFFFFF << (startBit & 0x3F);
+            if ((startBit + bitsCount) & 0x3F)
+                Data[startEntry + entriesCount - 1] |= ~(0xFFFFFFFFFFFFFFFF << ((startBit + bitsCount) & 0x3F));
+            else
+                Data[startEntry + entriesCount - 1] = 0xFFFFFFFFFFFFFFFF;
+            for (u64 i = startEntry + 1; i < startEntry + entriesCount - 1; i++)
+                Data[i] = 0xFFFFFFFFFFFFFFFF;
+        }
+        else
+        {
+            Data[startEntry] |= ((1ULL << bitsCount) - 1) << (startBit & 0x3F);
+        }
+    }
+
+    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++)
+        {
+            Data[i] |= other.Data[i];
+        }
+        return *this;
+    }
+
+    NonStupidBitField& operator&=(const NonStupidBitField<Size>& other)
+    {
+        for (u32 i = 0; i < DataLength; i++)
+        {
+            Data[i] &= other.Data[i];
+        }
+        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;
+    }
+};
+
+
+#endif

Places

File melonds_compute-shader-renderer.patch of Package melonds (Revision 74e33aa9718c16ff82ce093e7db785b8)

Places