implemented SDL3 as an option for window manager

2026-03-23 19:00:56 +01:00
parent 226f60e9ae
commit a596028ed9
152 changed files with 84309 additions and 247 deletions
--- a/TSE_OpenGlImpl/src/CameraHelperOpenGL.hpp
+++ b/TSE_OpenGlImpl/src/CameraHelperOpenGL.hpp
@@ -0,0 +1,17 @@
+#pragma once 
+
+#include "BehaviourScripts/Camera.hpp"
+#include "GL/gl3w.h"
+#include "GL/gl.h"
+
+namespace TSE::OpenGL
+{
+    class CameraHelperOpenGL : public ICameraHelper
+    {
+    public:
+        inline void OnRenderTargetChanged(float width, float height) override
+        {
+            glViewport(0, 0, width, height);
+        };    
+    };
+} // namespace TSE::OpenGL
--- a/TSE_OpenGlImpl/src/DefaultRendererOpenGL.cpp
+++ b/TSE_OpenGlImpl/src/DefaultRendererOpenGL.cpp
@@ -0,0 +1,159 @@
+#include "DefaultRendererOpenGL.hpp"
+#include "BehaviourScripts/Camera.hpp"
+#include "BehaviourScripts/Renderable.hpp"
+#include "Debug.hpp"
+
+#define RENDERER_MAX_SPRITES 20000
+#define RENDERER_MAX_INDECIES 60000
+
+TSE::OpenGL::DefaultRendererOpenGL::DefaultRendererOpenGL(Shader &shader)
+{
+    iboData = new ushort[RENDERER_MAX_INDECIES];
+    InitShader(shader, true);
+}
+
+TSE::OpenGL::DefaultRendererOpenGL::~DefaultRendererOpenGL()
+{
+    if(vao != 0)
+        glDeleteVertexArrays(1, &vao);
+    delete[] iboData;
+    delete ibo;
+}
+
+void TSE::OpenGL::DefaultRendererOpenGL::InitShader(Shader &s, bool init)
+{
+    if(!init) End();
+    if(vao != 0)
+    {
+        glDeleteVertexArrays(1, &vao);
+        vao = 0;
+    }
+
+    s.Enable();
+
+    glGenVertexArrays(1, &vao);
+
+    glBindVertexArray(vao);
+    vbo.Bind();
+
+    int RENDERER_SPRITE_SIZE = s.packageSize() * 3;
+    int RENDERER_BUFFER_SIZE = RENDERER_SPRITE_SIZE * RENDERER_MAX_SPRITES;
+
+    vbo.SetData(RENDERER_BUFFER_SIZE, nullptr, GL_DYNAMIC_DRAW);
+
+    s.Enable(true);
+
+    vbo.Unbind();
+    glBindVertexArray(0);
+
+    lastShader = &s;
+
+    if(!init) Begin();
+}
+
+void TSE::OpenGL::DefaultRendererOpenGL::End()
+{
+    glUnmapBuffer(GL_ARRAY_BUFFER);
+    vbo.Unbind();
+}
+
+void TSE::OpenGL::DefaultRendererOpenGL::Flush()
+{
+    lastShader->Flush();
+
+    glBindVertexArray(vao);
+
+    bool ibobound = false;
+    if(!CreateIbo())
+    {
+        ibo->Bind();
+        ibobound = true;
+    }
+
+    for (int i = 0; i < camerasToRenderWith.size(); i++)
+    {
+        camerasToRenderWith[i]->PreDraw(lastShader);
+
+        lastShader->DrawCall(indexCount);
+
+        camerasToRenderWith[i]->PostDraw();
+    }
+
+    lastShader->PostDraw();
+    
+    if(ibobound)
+    {
+        ibo->Unbind();
+    }
+    glBindVertexArray(0);
+
+    indexCount = 0;
+    iboOffset = 0;
+}
+
+void TSE::OpenGL::DefaultRendererOpenGL::Begin()
+{
+    vbo.Bind();
+    bufferPointer = (float*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
+}
+
+void TSE::OpenGL::DefaultRendererOpenGL::Submit(const Transformable &trans, TransformationStack &stack)
+{
+    Submit(trans, (IShader*)lastShader, stack);
+}
+
+void TSE::OpenGL::DefaultRendererOpenGL::Submit(const Transformable &trans, IShader *shader, TransformationStack &stack)
+{
+        Shader* s = dynamic_cast<Shader*>(shader);
+        if(lastShader == nullptr) InitShader(*s, true);
+        if(!s->IsEnabled())
+        {
+            if(indexCount != 0)
+            {
+                End();
+                Flush();
+                Begin();
+            }
+            lastShader->Disable();
+            InitShader(*s);
+        } 
+        auto* r = dynamic_cast<Renderable*>(trans.GetBehaviourScript(RENDERABLE));
+        const std::vector<ushort> indecies = r->GetIndices();
+        
+        if(indexCount + indecies.size() > RENDERER_MAX_INDECIES)
+        {
+            End();
+            Flush();
+            Begin();
+        }
+        int i = 0;
+        for(ushort index : indecies)
+        {
+            iboData[indexCount + i++] = index + iboOffset;
+        }
+        iboOffset += r->GetVertexCount();
+        indexCount += indecies.size();
+        
+        lastShader->Submit(trans, bufferPointer, stack, Redraw, *this);
+}
+
+void TSE::OpenGL::DefaultRendererOpenGL::Redraw(IRenderer &rnd)
+{
+    rnd.End();
+    rnd.Flush();
+    rnd.Begin();
+}
+
+bool TSE::OpenGL::DefaultRendererOpenGL::CreateIbo()
+{
+    if(indexCount == 0) return true;
+    if(ibo != nullptr)
+    {
+        ibo->WriteData(iboData, indexCount);
+    }
+    else
+    {
+        ibo = new IndexBuffer(iboData, indexCount);
+    }
+    return false;
+}
--- a/TSE_OpenGlImpl/src/DefaultRendererOpenGL.hpp
+++ b/TSE_OpenGlImpl/src/DefaultRendererOpenGL.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include "shader/Shader.hpp"
+#include "buffer/VertexBuffer.hpp"
+#include "buffer/IndexBuffer.hpp"
+#include "interfaces/IRenderer.hpp"
+#include <vector>
+
+namespace TSE::OpenGL
+{
+    class DefaultRendererOpenGL : public IRenderer
+    {
+    private:
+        uint vao = 0;
+        VertexBuffer vbo;
+        Shader* lastShader;
+        IndexBuffer* ibo = nullptr; //idk why this needs to be a pointer but not the vbo, just don't question it. it works MAK 28.05.25
+        ushort* iboData;
+        int indexCount = 0;
+        ushort iboOffset = 0;
+        float* bufferPointer;
+        ushort* indexBufferPointer;
+    public:
+        DefaultRendererOpenGL(Shader& shader);
+        ~DefaultRendererOpenGL();
+
+        void InitShader(Shader& s, bool init = false);
+        void End() override;
+        void Flush() override;
+        void Begin() override;
+        void Submit(const Transformable& trans, TransformationStack& stack) override;
+        void Submit(const Transformable& trans, IShader* shader, TransformationStack& stack) override;
+
+    private:
+        static void Redraw(IRenderer& rnd);
+        bool CreateIbo();
+    };
+} // namespace TSE::OpenGL
--- a/TSE_OpenGlImpl/src/OpenGLRenderingBackend.cpp
+++ b/TSE_OpenGlImpl/src/OpenGLRenderingBackend.cpp
@@ -0,0 +1,241 @@
+#include "GL/gl3w.h"
+#include "GL/gl.h"
+#include "OpenGLRenderingBackend.hpp"
+#include "Debug.hpp"
+#include "imgui/imgui.h"
+#include "extern/imgui_impl_opengl3.h"
+#include "PathHelper.hpp"
+#include "elements/Texture.hpp"
+#include "TextureHelperOpenGL.hpp"
+#include "interfaces/IRenderer.hpp"
+#include "BehaviourScripts/Camera.hpp"
+#include "RenderTextureCreatorOpenGL.hpp"
+#include "CameraHelperOpenGL.hpp"
+
+#include "WindowManager.hpp"
+
+#if defined(TSE_GLFW)
+#include "GLFW/glfw3.h"
+#include "WindowGlfw.hpp"
+#include "extern/imgui_impl_glfw.h"
+using namespace TSE::GLFW;
+#elif defined(TSE_SDL3)
+#include "SDL3/SDL.h"
+#include "WindowSdl3.hpp"
+#include "extern/imgui_impl_sdl3.h"
+using namespace TSE::SDL3;
+#endif
+
+
+TSE::OpenGL::OpenGLRenderingBackend::OpenGLRenderingBackend(Color _backgroundColor, bool _vsync)
+: OpenGLRenderingBackend(_backgroundColor, _vsync, 0, false){ }
+
+TSE::OpenGL::OpenGLRenderingBackend::OpenGLRenderingBackend(Color _backgroundColor, bool _vsync, int _samples, bool _useseImGui)
+{
+    backgroundColor = _backgroundColor;
+    vsync = _vsync;
+    samples = _samples;
+    useseImGui = _useseImGui;
+}
+
+TSE::OpenGL::OpenGLRenderingBackend::~OpenGLRenderingBackend()
+{
+    if(useseImGui)
+    {
+        ImGui_ImplOpenGL3_Shutdown();
+#if defined(TSE_GLFW)
+        ImGui_ImplGlfw_Shutdown();
+#elif defined(TSE_SDL3)
+        ImGui_ImplSDL3_Shutdown();
+#endif
+        ImGui::DestroyContext();
+    }
+}
+
+void TSE::OpenGL::OpenGLRenderingBackend::InitPreWindow()
+{
+    IRenderTexture::factory = new RenderTextureCreatorOpenGL();
+    Texture::helper = new TextureHelperOpenGL();
+    Camera::helper = new CameraHelperOpenGL();
+
+#if defined(TSE_GLFW)
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, TSE_OPENGL_VERSION_MAJOR);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, TSE_OPENGL_VERSION_MINOR);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+    glfwWindowHint(GLFW_SAMPLES, samples);
+#elif defined(TSE_SDL3)
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, TSE_OPENGL_VERSION_MAJOR);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, TSE_OPENGL_VERSION_MINOR);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
+    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
+    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, samples);
+#endif
+}
+
+bool TSE::OpenGL::OpenGLRenderingBackend::InitPostWindow()
+{
+#if defined(TSE_GLFW)
+    WindowGlfw* wnd = static_cast<WindowGlfw*>(window);
+    glfwMakeContextCurrent(wnd->window);
+#elif defined(TSE_SDL3)
+    WindowSdl3* wnd = static_cast<WindowSdl3*>(window);
+    wnd->context = SDL_GL_CreateContext(wnd->window);
+    SDL_GL_MakeCurrent(wnd->window, wnd->context);
+#endif
+    if(gl3wInit())
+    {
+        Debug::Log("Failed to initialize gl3w.");
+        return false;
+    }
+    if(!gl3wIsSupported(TSE_OPENGL_VERSION_MAJOR, TSE_OPENGL_VERSION_MINOR))
+    {
+        Debug::Log("gl3w dose not support the selected version of OpenGL.");
+        return false;
+    }
+#if defined(TSE_GLFW)
+    if(vsync) glfwSwapInterval(1);
+    else glfwSwapInterval(0);
+#elif defined(TSE_SDL3)
+    if(vsync)
+        {
+            if(!SDL_GL_SetSwapInterval(-1))
+                SDL_GL_SetSwapInterval(1);
+        }
+        else SDL_GL_SetSwapInterval(0);
+#endif
+
+    Debug::Log("OpenGL:" + std::string((const char*)glGetString(GL_VERSION)));
+    Debug::Log("GLSL:" + std::string((const char*)glGetString(GL_SHADING_LANGUAGE_VERSION)));
+
+    glEnable(GL_BLEND);
+    glClearDepth(0.0);
+    glEnable(GL_DEPTH_TEST);
+    glDepthFunc(GL_GEQUAL);
+    glEnable(GL_MULTISAMPLE);
+    glEnable(GL_CULL_FACE);
+    glCullFace(GL_FRONT);
+    glFrontFace(GL_CW);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glClearColor(backgroundColor.r, backgroundColor.g, backgroundColor.b, backgroundColor.a);
+    glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, GL_LOWER_LEFT);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+    return true;
+}
+
+std::string imguiIniPath;
+
+bool TSE::OpenGL::OpenGLRenderingBackend::InitEnd()
+{
+    if(useseImGui)
+    {
+        GetAppDataPath(imguiIniPath);
+        imguiIniPath += "/UI.cfg";
+        IMGUI_CHECKVERSION();
+        ImGui::CreateContext();
+        ImGuiIO& io = ImGui::GetIO(); (void)io;
+        io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
+        io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;
+        io.IniFilename = imguiIniPath.c_str();
+        ImGui::StyleColorsDark();
+
+#if defined(TSE_GLFW)
+        WindowGlfw* wnd = static_cast<WindowGlfw*>(window);
+        wnd->useImGui = true;
+        ImGui_ImplGlfw_InitForOpenGL(wnd->window, true);
+#elif defined(TSE_SDL3)
+        WindowSdl3* wnd = static_cast<WindowSdl3*>(window);
+        wnd->useImGui = true;
+        ImGui_ImplSDL3_InitForOpenGL(wnd->window, wnd->context);
+#endif
+        ImGui_ImplOpenGL3_Init("#version 130");
+        
+        Debug::Log("ImGui:" + std::string(ImGui::GetVersion()));
+    }
+    return true;
+}
+
+void TSE::OpenGL::OpenGLRenderingBackend::onResize(int width, int height)
+{
+    glViewport(0,0,width, height);
+}
+
+void TSE::OpenGL::OpenGLRenderingBackend::onUpdate() const
+{
+    int error = glGetError();
+    if(error != GL_NO_ERROR)
+    {
+        Debug::Log("OpenGL Error: " + std::to_string(error));
+    }
+
+#if defined(TSE_GLFW)
+    WindowGlfw* wnd = static_cast<WindowGlfw*>(window);
+#elif defined(TSE_SDL3)
+    WindowSdl3* wnd = static_cast<WindowSdl3*>(window);
+#endif
+
+    if(useseImGui)
+    {
+        ImGui::Render();
+        ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+
+        
+        if(ImGui::GetIO().ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+        {
+#if defined(TSE_GLFW)
+            GLFWwindow* backup_current_context = glfwGetCurrentContext();
+#elif defined(TSE_SDL3)
+            SDL_GLContext backup_current_context = SDL_GL_GetCurrentContext();
+#endif
+            ImGui::UpdatePlatformWindows();
+            ImGui::RenderPlatformWindowsDefault();
+#if defined(TSE_GLFW)
+            glfwMakeContextCurrent(backup_current_context);
+#elif defined(TSE_SDL3)
+            SDL_GL_MakeCurrent(wnd->window, backup_current_context);
+#endif
+        }
+
+    }
+
+#if defined(TSE_GLFW)
+    glfwSwapBuffers(wnd->window);
+#elif defined(TSE_SDL3)
+    SDL_GL_SwapWindow(wnd->window);
+#endif
+}
+
+void TSE::OpenGL::OpenGLRenderingBackend::onClear() const
+{
+    for (int i = 0; i < IRenderer::camerasToRenderWith.size(); i++)
+    {
+        IRenderer::camerasToRenderWith[i]->Bind();
+        IRenderer::camerasToRenderWith[i]->UpdateRenderTarget();
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        IRenderer::camerasToRenderWith[i]->Unbind();
+    }
+
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    if(useseImGui)
+    {
+        ImGui_ImplOpenGL3_NewFrame();
+#if defined(TSE_GLFW)
+        ImGui_ImplGlfw_NewFrame();
+#elif defined(TSE_SDL3)
+        ImGui_ImplSDL3_NewFrame();
+#endif
+        ImGui::NewFrame();
+    }
+}
+
+void TSE::OpenGL::OpenGLRenderingBackend::onClearDepthBuffer() const
+{
+    for (int i = 0; i < IRenderer::camerasToRenderWith.size(); i++)
+    {
+        IRenderer::camerasToRenderWith[i]->Bind();
+        glClear(GL_DEPTH_BUFFER_BIT);
+        IRenderer::camerasToRenderWith[i]->Unbind();
+    }
+    
+    glClear(GL_DEPTH_BUFFER_BIT);
+}
--- a/TSE_OpenGlImpl/src/OpenGLRenderingBackend.hpp
+++ b/TSE_OpenGlImpl/src/OpenGLRenderingBackend.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "interfaces/IRenderingBackend.hpp"
+
+#define TSE_OPENGL_VERSION_MAJOR 3
+#define TSE_OPENGL_VERSION_MINOR 3
+
+namespace TSE::OpenGL
+{
+    class OpenGLRenderingBackend : public IRenderingBackend
+    {
+        private:
+
+        public:
+        OpenGLRenderingBackend(Color _backgroundColor, bool _vsync);
+        OpenGLRenderingBackend(Color _backgroundColor, bool _vsync, int _samples, bool _useseImGui);
+        ~OpenGLRenderingBackend();
+
+        void InitPreWindow() override;
+        bool InitPostWindow() override;
+        bool InitEnd() override;
+
+        void onResize(int width, int height) override;
+        void onUpdate() const override;
+        void onClear() const override;
+        void onClearDepthBuffer() const override;
+    };
+} // namespace OpenGL
--- a/TSE_OpenGlImpl/src/RenderTexture.cpp
+++ b/TSE_OpenGlImpl/src/RenderTexture.cpp
@@ -0,0 +1,59 @@
+#include "RenderTexture.hpp"
+
+TSE::OpenGL::RenderTexture::RenderTexture(Vector2 v, uint textureCount) : buffer(v, textureCount)
+{
+    buffer.AddResizeNotifiable(this);
+}
+
+TSE::Vector2 TSE::OpenGL::RenderTexture::size() const
+{
+    return buffer.GetSize();
+}
+
+void TSE::OpenGL::RenderTexture::SetSize(Vector2 v)
+{
+    buffer.Resize(v);
+}
+
+float TSE::OpenGL::RenderTexture::Width() const
+{
+    return buffer.GetSize().x;
+}
+
+float TSE::OpenGL::RenderTexture::Height() const
+{
+    return buffer.GetSize().y;
+}
+
+TSE::uint TSE::OpenGL::RenderTexture::GetTextureId() const
+{
+    return buffer.GetTextureId();
+}
+
+TSE::uint TSE::OpenGL::RenderTexture::GetTextureId(uint id) const
+{
+    return buffer.GetTextureId(id);
+}
+
+void TSE::OpenGL::RenderTexture::Update()
+{
+    buffer.Update();
+}
+
+void TSE::OpenGL::RenderTexture::Bind()
+{
+    buffer.Bind();
+}
+
+void TSE::OpenGL::RenderTexture::Unbind()
+{
+    buffer.Unbind();
+}
+
+void TSE::OpenGL::RenderTexture::OnResize(float width, float height, IResizable *wnd)
+{
+    for (auto const& i : objectsToResize)
+    {
+        i->OnResize(width, height, this);
+    }
+}
--- a/TSE_OpenGlImpl/src/RenderTexture.hpp
+++ b/TSE_OpenGlImpl/src/RenderTexture.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include "buffer/FrameBuffer.hpp"
+#include "interfaces/IRenderTarget.hpp"
+#include "interfaces/ITexture.hpp"
+#include "interfaces/IResizeNotifiable.hpp"
+#include "interfaces/IRenderTexture.hpp"
+
+namespace TSE::OpenGL
+{
+    class RenderTexture : public IRenderTexture
+    {
+    public:
+        FrameBuffer buffer;
+
+        RenderTexture(Vector2 v, uint textureCount = 1);
+
+        Vector2 size() const override;
+        void SetSize(Vector2 v) override;
+        float Width() const override;
+        float Height() const override;
+        uint GetTextureId() const override;
+        uint GetTextureId(uint id) const override;
+
+        void Update() override;
+        void Bind() override;
+        void Unbind() override;
+
+        void OnResize(float width, float height, IResizable* wnd) override;
+    };
+} // namespace TSE::OpenGL
--- a/TSE_OpenGlImpl/src/RenderTextureCreatorOpenGL.hpp
+++ b/TSE_OpenGlImpl/src/RenderTextureCreatorOpenGL.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "interfaces/IRenderTexture.hpp"
+#include "RenderTexture.hpp"
+
+namespace TSE::OpenGL
+{
+    class RenderTextureCreatorOpenGL : public IRenderTextureCreator
+    {
+    public:
+        inline IRenderTexture* CreateTextureHeap(Vector2 v, uint textureCount = 1) override
+        {
+            return new RenderTexture(v, textureCount);
+        };
+    };
+} // namespace OpenGL
--- a/TSE_OpenGlImpl/src/TextureHelperOpenGL.cpp
+++ b/TSE_OpenGlImpl/src/TextureHelperOpenGL.cpp
@@ -0,0 +1,61 @@
+#include "GL/gl3w.h"
+#include "GL/gl.h"
+#include "TextureHelperOpenGL.hpp"
+
+void TSE::OpenGL::TextureHelperOpenGL::Bind(const Texture *tex)
+{
+    glBindTexture(GL_TEXTURE_2D, tex->GetTextureId());
+}
+
+void TSE::OpenGL::TextureHelperOpenGL::UnBind(const Texture *tex)
+{
+    glBindTexture(GL_TEXTURE_2D, 0);
+}
+
+void TSE::OpenGL::TextureHelperOpenGL::Apply(Texture *tex)
+{
+    glBindTexture(GL_TEXTURE_2D, tex->GetTextureId());
+        if(tex->Chanels() == 1)
+        {
+            if (tex->bpp() == 8)
+                glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA, tex->Width(), tex->Height(), 0, GL_RED, GL_UNSIGNED_BYTE, tex->GetImagePtr());
+        }
+        if(tex->Chanels() == 3)
+        {
+            if(tex->bpp() == 24)
+                glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA, tex->Width(), tex->Height(), 0, GL_BGR, GL_UNSIGNED_BYTE, tex->GetImagePtr());
+        }
+        else if(tex->Chanels() == 4)
+        {
+            if(tex->bpp() == 32)
+                glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA, tex->Width(), tex->Height(), 0, GL_BGRA, GL_UNSIGNED_BYTE, tex->GetImagePtr());
+            if (tex->bpp() == 8) //need to decode it with bitwise operations in shader
+                glTexImage2D(GL_TEXTURE_2D, 0,GL_RGBA, tex->Width(), tex->Height(), 0, GL_RED, GL_UNSIGNED_BYTE, tex->GetImagePtr());
+        }
+
+        glGenerateMipmap(GL_TEXTURE_2D);
+
+        glBindTexture(GL_TEXTURE_2D, 0);
+}
+
+void TSE::OpenGL::TextureHelperOpenGL::Regist(Texture *tex)
+{
+    uint TextureID;
+
+    glGenTextures(1, &TextureID);
+    glBindTexture(GL_TEXTURE_2D, TextureID);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    
+    tex->SetTextureId(TextureID);
+
+    tex->Apply();
+}
+
+void TSE::OpenGL::TextureHelperOpenGL::PlatromDestroy(Texture *tex)
+{
+    uint id = tex->GetTextureId();
+    glDeleteTextures(1, &id);
+}
--- a/TSE_OpenGlImpl/src/TextureHelperOpenGL.hpp
+++ b/TSE_OpenGlImpl/src/TextureHelperOpenGL.hpp
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "interfaces/ITextureHelper.hpp"
+#include "elements/Texture.hpp"
+
+namespace TSE::OpenGL
+{
+    class TextureHelperOpenGL : public ITextureHelper
+    {
+    public:
+        void Bind(const Texture* tex) override;
+        void UnBind(const Texture* tex) override;
+        void Apply(Texture* tex) override;
+        void Regist(Texture* tex) override;
+        void PlatromDestroy(Texture* tex) override;
+    };
+} // namespace TSE::OpenGL
--- a/TSE_OpenGlImpl/src/buffer/FrameBuffer.cpp
+++ b/TSE_OpenGlImpl/src/buffer/FrameBuffer.cpp
@@ -0,0 +1,119 @@
+#include "FrameBuffer.hpp"
+#include "Debug.hpp"
+
+TSE::OpenGL::FrameBuffer::FrameBuffer(const Vector2 &size, uint textureCount)
+{
+    textureOutputCount = textureCount;
+    width = size.x;
+    height = size.y;
+    CreateFBTexture();
+    for (auto const& i : objectsToResize)
+    {
+        i->OnResize(size.x, size.y, this);
+    }
+    Initialize();
+}
+
+void TSE::OpenGL::FrameBuffer::Bind()
+{
+    glBindFramebuffer(GL_FRAMEBUFFER, bufferID);
+}
+
+void TSE::OpenGL::FrameBuffer::Unbind()
+{
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+}
+
+TSE::OpenGL::FrameBuffer::~FrameBuffer()
+{
+    glDeleteFramebuffers(1,&bufferID);
+    for (int i = 0; i < textureOutputCount; i++)
+    {
+        glDeleteTextures(1, &(textureIDs[i]));
+    }
+    glDeleteRenderbuffers(1, &depthRboID);
+}
+
+void TSE::OpenGL::FrameBuffer::Resize(Vector2 size)
+{
+    width = size.x;
+    height = size.y;
+    shouldResize = true;
+}
+
+void TSE::OpenGL::FrameBuffer::Update()
+{
+    if (!shouldResize) return;
+    shouldResize = false;
+    CreateFBTexture();
+    for (auto const& i : objectsToResize)
+    {
+        i->OnResize(width, height, this);
+    }
+}
+
+TSE::uint TSE::OpenGL::FrameBuffer::GetTextureId(uint id) const
+{
+    return textureIDs[id];
+}
+
+TSE::Vector2 TSE::OpenGL::FrameBuffer::GetSize() const
+{
+    return {width, height};
+}
+
+void TSE::OpenGL::FrameBuffer::Initialize()
+{
+    glGenFramebuffers(1, &bufferID);
+    Bind();
+    uint bufs[32];
+    for (int i = 0; i < textureOutputCount; i++)
+    {
+        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D, textureIDs[i], 0);
+        bufs[i] = GL_COLOR_ATTACHMENT0 + i;
+    }
+    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthRboID);
+    
+    if(textureOutputCount > 1)
+        glDrawBuffers(textureOutputCount, bufs);
+
+    if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
+    {
+        TSE_ERROR("Failed to create OpenGL FBO.");
+        TSE_LOG(std::to_string(glGetError()));
+    }
+    Unbind();
+}
+
+void TSE::OpenGL::FrameBuffer::LoadFBTexture()
+{
+    for (int i = 0; i < textureOutputCount; i++)
+    {
+        glBindTexture(GL_TEXTURE_2D, textureIDs[i]);
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
+
+        glBindRenderbuffer(GL_RENDERBUFFER, depthRboID);
+        glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, width, height);
+    }
+}
+
+void TSE::OpenGL::FrameBuffer::CreateFBTexture()
+{
+    glViewport(0,0, width, height);
+    //resize
+    for (int i = 0; i < textureOutputCount; i++)
+    {
+        if(textureIDs[i] == 0)
+            glGenTextures(1, &(textureIDs[i]));
+    }
+    if(depthRboID == 0)
+        glGenRenderbuffers(1, &depthRboID);
+    LoadFBTexture();
+}
--- a/TSE_OpenGlImpl/src/buffer/FrameBuffer.hpp
+++ b/TSE_OpenGlImpl/src/buffer/FrameBuffer.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "buffer.hpp"
+#include "interfaces/IResizable.hpp"
+#include "Vector2.hpp"
+
+namespace TSE::OpenGL
+{
+    class FrameBuffer : public buffer, public IResizable
+    {
+    private:
+        uint textureOutputCount = 1;
+        uint textureIDs[32] = {0};
+        uint depthRboID = 0;
+        bool shouldResize = false;
+
+    public:
+        FrameBuffer(const Vector2& size, uint textureCount = 1);
+        void Bind() override;
+        void Unbind() override;
+        ~FrameBuffer() override;
+        void Resize(Vector2 size);
+        void Update();
+        uint GetTextureId(uint id = 0) const;
+        Vector2 GetSize() const;
+
+    private:
+        void Initialize();
+        void LoadFBTexture();
+        void CreateFBTexture();
+    };
+} // namespace TSE
--- a/TSE_OpenGlImpl/src/buffer/IndexBuffer.cpp
+++ b/TSE_OpenGlImpl/src/buffer/IndexBuffer.cpp
@@ -0,0 +1,24 @@
+#include "IndexBuffer.hpp"
+
+TSE::OpenGL::IndexBuffer::IndexBuffer(ushort *data, ushort count)
+{
+    glGenBuffers(1, &bufferID);
+    WriteData(data, count);
+}
+
+void TSE::OpenGL::IndexBuffer::WriteData(ushort *data, ushort count)
+{
+    Bind();
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(ushort) * count, data, GL_DYNAMIC_DRAW);
+    Unbind();
+}
+
+void TSE::OpenGL::IndexBuffer::Bind()
+{
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferID);
+}
+
+void TSE::OpenGL::IndexBuffer::Unbind()
+{
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+}
--- a/TSE_OpenGlImpl/src/buffer/IndexBuffer.hpp
+++ b/TSE_OpenGlImpl/src/buffer/IndexBuffer.hpp
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "buffer.hpp"
+#include "Types.hpp"
+
+namespace TSE::OpenGL
+{
+    class IndexBuffer : public buffer
+    {
+    public:
+        IndexBuffer(ushort* data, ushort count);
+        inline IndexBuffer() = default;
+        void WriteData(ushort* data, ushort count);
+        void Bind() override;
+        void Unbind() override;
+    };
+} // namespace TSE::GLFW
--- a/TSE_OpenGlImpl/src/buffer/VertexBuffer.cpp
+++ b/TSE_OpenGlImpl/src/buffer/VertexBuffer.cpp
@@ -0,0 +1,39 @@
+#include "VertexBuffer.hpp"
+
+TSE::uint TSE::OpenGL::VertexBuffer::boundBuffer = 0;
+
+TSE::OpenGL::VertexBuffer::VertexBuffer()
+{
+    glGenBuffers(1, &bufferID);
+}
+
+void TSE::OpenGL::VertexBuffer::SetData(int size, void *buffer, GLenum usage)
+{
+    glBufferData(GL_ARRAY_BUFFER, size, buffer, usage);
+}
+
+void TSE::OpenGL::VertexBuffer::Bind()
+{
+    glBindBuffer(GL_ARRAY_BUFFER, bufferID);
+    boundBuffer = bufferID;
+}
+
+void TSE::OpenGL::VertexBuffer::Unbind()
+{
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    boundBuffer = 0;
+}
+
+bool TSE::OpenGL::VertexBuffer::IsBound()
+{
+    return boundBuffer == bufferID;
+}
+
+TSE::OpenGL::VertexBuffer::~VertexBuffer()
+{
+    if(bufferID != 0)
+    {
+        if(IsBound()) Unbind();
+        glDeleteBuffers(1, &bufferID);
+    }
+}
--- a/TSE_OpenGlImpl/src/buffer/VertexBuffer.hpp
+++ b/TSE_OpenGlImpl/src/buffer/VertexBuffer.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "buffer.hpp"
+
+namespace TSE::OpenGL
+{
+    class VertexBuffer : public buffer
+    {
+    public:
+        static uint boundBuffer;
+        VertexBuffer();
+        void SetData(int size, void* buffer, GLenum usage);
+        void Bind() override;
+        void Unbind() override;
+        bool IsBound();
+        ~VertexBuffer();
+    };
+} // namespace TSE::GLFW
--- a/TSE_OpenGlImpl/src/buffer/buffer.hpp
+++ b/TSE_OpenGlImpl/src/buffer/buffer.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "GL/gl3w.h"
+#include "GL/gl.h"
+#include "Types.hpp"
+
+namespace TSE::OpenGL
+{
+    class buffer
+    {
+    protected:
+        uint bufferID = 0;
+
+    public:
+        inline bool Initialized()
+        {
+            return bufferID != 0;
+        }
+        virtual void Bind() = 0;
+        virtual void Unbind() = 0;
+
+        inline virtual ~buffer()
+        {
+            glDeleteBuffers(1, &bufferID);
+        }
+    };
+} // namespace TSE
--- a/TSE_OpenGlImpl/src/extern/gl3w.c
+++ b/TSE_OpenGlImpl/src/extern/gl3w.c
@@ -0,0 +1,926 @@
+/*
+ * This file was generated with gl3w_gen.py, part of gl3w
+ * (hosted at https://github.com/skaslev/gl3w)
+ *
+ * This is free and unencumbered software released into the public domain.
+ *
+ * Anyone is free to copy, modify, publish, use, compile, sell, or
+ * distribute this software, either in source code form or as a compiled
+ * binary, for any purpose, commercial or non-commercial, and by any
+ * means.
+ *
+ * In jurisdictions that recognize copyright laws, the author or authors
+ * of this software dedicate any and all copyright interest in the
+ * software to the public domain. We make this dedication for the benefit
+ * of the public at large and to the detriment of our heirs and
+ * successors. We intend this dedication to be an overt act of
+ * relinquishment in perpetuity of all present and future rights to this
+ * software under copyright law.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <GL/gl3w.h>
+#include <stdlib.h>
+
+#define ARRAY_SIZE(x)  (sizeof(x) / sizeof((x)[0]))
+
+#if defined(_WIN32)
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN 1
+#endif
+#include <windows.h>
+
+static HMODULE libgl;
+typedef PROC(__stdcall* GL3WglGetProcAddr)(LPCSTR);
+static GL3WglGetProcAddr wgl_get_proc_address;
+
+static int open_libgl(void)
+{
+	libgl = LoadLibraryA("opengl32.dll");
+	if (!libgl)
+		return GL3W_ERROR_LIBRARY_OPEN;
+
+	wgl_get_proc_address = (GL3WglGetProcAddr)GetProcAddress(libgl, "wglGetProcAddress");
+	return GL3W_OK;
+}
+
+static void close_libgl(void)
+{
+	FreeLibrary(libgl);
+}
+
+static GL3WglProc get_proc(const char *proc)
+{
+	GL3WglProc res;
+
+	res = (GL3WglProc)wgl_get_proc_address(proc);
+	if (!res)
+		res = (GL3WglProc)GetProcAddress(libgl, proc);
+	return res;
+}
+#elif defined(__APPLE__)
+#include <dlfcn.h>
+
+static void *libgl;
+
+static int open_libgl(void)
+{
+	libgl = dlopen("/System/Library/Frameworks/OpenGL.framework/OpenGL", RTLD_LAZY | RTLD_LOCAL);
+	if (!libgl)
+		return GL3W_ERROR_LIBRARY_OPEN;
+
+	return GL3W_OK;
+}
+
+static void close_libgl(void)
+{
+	dlclose(libgl);
+}
+
+static GL3WglProc get_proc(const char *proc)
+{
+	GL3WglProc res;
+
+	*(void **)(&res) = dlsym(libgl, proc);
+	return res;
+}
+#else
+#include <dlfcn.h>
+
+static void *libgl;  /* OpenGL library */
+static void *libglx;  /* GLX library */
+static void *libegl;  /* EGL library */
+static GL3WGetProcAddressProc gl_get_proc_address;
+
+static void close_libgl(void)
+{
+	if (libgl) {
+		dlclose(libgl);
+		libgl = NULL;
+	}
+	if (libegl) {
+		dlclose(libegl);
+		libegl = NULL;
+	}
+	if (libglx) {
+		dlclose(libglx);
+		libglx = NULL;
+	}
+}
+
+static int is_library_loaded(const char *name, void **lib)
+{
+	*lib = dlopen(name, RTLD_LAZY | RTLD_LOCAL | RTLD_NOLOAD);
+	return *lib != NULL;
+}
+
+static int open_libs(void)
+{
+	/* On Linux we have two APIs to get process addresses: EGL and GLX.
+	 * EGL is supported under both X11 and Wayland, whereas GLX is X11-specific.
+	 * First check what's already loaded, the windowing library might have
+	 * already loaded either EGL or GLX and we want to use the same one.
+	 */
+
+	if (is_library_loaded("libEGL.so.1", &libegl) ||
+			is_library_loaded("libGLX.so.0", &libglx)) {
+		libgl = dlopen("libOpenGL.so.0", RTLD_LAZY | RTLD_LOCAL);
+		if (libgl)
+			return GL3W_OK;
+		else
+			close_libgl();
+	}
+
+	if (is_library_loaded("libGL.so.1", &libgl))
+		return GL3W_OK;
+
+	/* Neither is already loaded, so we have to load one. Try EGL first
+	 * because it is supported under both X11 and Wayland.
+	 */
+
+	/* Load OpenGL + EGL */
+	libgl = dlopen("libOpenGL.so.0", RTLD_LAZY | RTLD_LOCAL);
+	libegl = dlopen("libEGL.so.1", RTLD_LAZY | RTLD_LOCAL);
+	if (libgl && libegl)
+		return GL3W_OK;
+
+	/* Fall back to legacy libGL, which includes GLX */
+	close_libgl();
+	libgl = dlopen("libGL.so.1", RTLD_LAZY | RTLD_LOCAL);
+	if (libgl)
+		return GL3W_OK;
+
+	return GL3W_ERROR_LIBRARY_OPEN;
+}
+
+static int open_libgl(void)
+{
+	int res = open_libs();
+	if (res)
+		return res;
+
+	if (libegl)
+		*(void **)(&gl_get_proc_address) = dlsym(libegl, "eglGetProcAddress");
+	else if (libglx)
+		*(void **)(&gl_get_proc_address) = dlsym(libglx, "glXGetProcAddressARB");
+	else
+		*(void **)(&gl_get_proc_address) = dlsym(libgl, "glXGetProcAddressARB");
+
+	if (!gl_get_proc_address) {
+		close_libgl();
+		return GL3W_ERROR_LIBRARY_OPEN;
+	}
+
+	return GL3W_OK;
+}
+
+static GL3WglProc get_proc(const char *proc)
+{
+	GL3WglProc res = NULL;
+
+	/* Before EGL version 1.5, eglGetProcAddress doesn't support querying core
+	 * functions and may return a dummy function if we try, so try to load the
+	 * function from the GL library directly first.
+	 */
+	if (libegl)
+		*(void **)(&res) = dlsym(libgl, proc);
+
+	if (!res)
+		res = gl_get_proc_address(proc);
+
+	if (!libegl && !res)
+		*(void **)(&res) = dlsym(libgl, proc);
+
+	return res;
+}
+#endif
+
+static struct {
+	int major, minor;
+} version;
+
+static int parse_version(void)
+{
+	if (!glGetIntegerv)
+		return GL3W_ERROR_INIT;
+
+	glGetIntegerv(GL_MAJOR_VERSION, &version.major);
+	glGetIntegerv(GL_MINOR_VERSION, &version.minor);
+
+	if (version.major < 3)
+		return GL3W_ERROR_OPENGL_VERSION;
+	return GL3W_OK;
+}
+
+static void load_procs(GL3WGetProcAddressProc proc);
+
+int gl3wInit(void)
+{
+	int res;
+
+	res = open_libgl();
+	if (res)
+		return res;
+
+	atexit(close_libgl);
+	return gl3wInit2(get_proc);
+}
+
+int gl3wInit2(GL3WGetProcAddressProc proc)
+{
+	load_procs(proc);
+	return parse_version();
+}
+
+int gl3wIsSupported(int major, int minor)
+{
+	if (major < 3)
+		return 0;
+	if (version.major == major)
+		return version.minor >= minor;
+	return version.major >= major;
+}
+
+GL3WglProc gl3wGetProcAddress(const char *proc)
+{
+	return get_proc(proc);
+}
+
+static const char *proc_names[] = {
+	"glActiveShaderProgram",
+	"glActiveTexture",
+	"glAttachShader",
+	"glBeginConditionalRender",
+	"glBeginQuery",
+	"glBeginQueryIndexed",
+	"glBeginTransformFeedback",
+	"glBindAttribLocation",
+	"glBindBuffer",
+	"glBindBufferBase",
+	"glBindBufferRange",
+	"glBindBuffersBase",
+	"glBindBuffersRange",
+	"glBindFragDataLocation",
+	"glBindFragDataLocationIndexed",
+	"glBindFramebuffer",
+	"glBindImageTexture",
+	"glBindImageTextures",
+	"glBindProgramPipeline",
+	"glBindRenderbuffer",
+	"glBindSampler",
+	"glBindSamplers",
+	"glBindTexture",
+	"glBindTextureUnit",
+	"glBindTextures",
+	"glBindTransformFeedback",
+	"glBindVertexArray",
+	"glBindVertexBuffer",
+	"glBindVertexBuffers",
+	"glBlendColor",
+	"glBlendEquation",
+	"glBlendEquationSeparate",
+	"glBlendEquationSeparatei",
+	"glBlendEquationi",
+	"glBlendFunc",
+	"glBlendFuncSeparate",
+	"glBlendFuncSeparatei",
+	"glBlendFunci",
+	"glBlitFramebuffer",
+	"glBlitNamedFramebuffer",
+	"glBufferData",
+	"glBufferStorage",
+	"glBufferSubData",
+	"glCheckFramebufferStatus",
+	"glCheckNamedFramebufferStatus",
+	"glClampColor",
+	"glClear",
+	"glClearBufferData",
+	"glClearBufferSubData",
+	"glClearBufferfi",
+	"glClearBufferfv",
+	"glClearBufferiv",
+	"glClearBufferuiv",
+	"glClearColor",
+	"glClearDepth",
+	"glClearDepthf",
+	"glClearNamedBufferData",
+	"glClearNamedBufferSubData",
+	"glClearNamedFramebufferfi",
+	"glClearNamedFramebufferfv",
+	"glClearNamedFramebufferiv",
+	"glClearNamedFramebufferuiv",
+	"glClearStencil",
+	"glClearTexImage",
+	"glClearTexSubImage",
+	"glClientWaitSync",
+	"glClipControl",
+	"glColorMask",
+	"glColorMaski",
+	"glCompileShader",
+	"glCompressedTexImage1D",
+	"glCompressedTexImage2D",
+	"glCompressedTexImage3D",
+	"glCompressedTexSubImage1D",
+	"glCompressedTexSubImage2D",
+	"glCompressedTexSubImage3D",
+	"glCompressedTextureSubImage1D",
+	"glCompressedTextureSubImage2D",
+	"glCompressedTextureSubImage3D",
+	"glCopyBufferSubData",
+	"glCopyImageSubData",
+	"glCopyNamedBufferSubData",
+	"glCopyTexImage1D",
+	"glCopyTexImage2D",
+	"glCopyTexSubImage1D",
+	"glCopyTexSubImage2D",
+	"glCopyTexSubImage3D",
+	"glCopyTextureSubImage1D",
+	"glCopyTextureSubImage2D",
+	"glCopyTextureSubImage3D",
+	"glCreateBuffers",
+	"glCreateFramebuffers",
+	"glCreateProgram",
+	"glCreateProgramPipelines",
+	"glCreateQueries",
+	"glCreateRenderbuffers",
+	"glCreateSamplers",
+	"glCreateShader",
+	"glCreateShaderProgramv",
+	"glCreateTextures",
+	"glCreateTransformFeedbacks",
+	"glCreateVertexArrays",
+	"glCullFace",
+	"glDebugMessageCallback",
+	"glDebugMessageControl",
+	"glDebugMessageInsert",
+	"glDeleteBuffers",
+	"glDeleteFramebuffers",
+	"glDeleteProgram",
+	"glDeleteProgramPipelines",
+	"glDeleteQueries",
+	"glDeleteRenderbuffers",
+	"glDeleteSamplers",
+	"glDeleteShader",
+	"glDeleteSync",
+	"glDeleteTextures",
+	"glDeleteTransformFeedbacks",
+	"glDeleteVertexArrays",
+	"glDepthFunc",
+	"glDepthMask",
+	"glDepthRange",
+	"glDepthRangeArrayv",
+	"glDepthRangeIndexed",
+	"glDepthRangef",
+	"glDetachShader",
+	"glDisable",
+	"glDisableVertexArrayAttrib",
+	"glDisableVertexAttribArray",
+	"glDisablei",
+	"glDispatchCompute",
+	"glDispatchComputeIndirect",
+	"glDrawArrays",
+	"glDrawArraysIndirect",
+	"glDrawArraysInstanced",
+	"glDrawArraysInstancedBaseInstance",
+	"glDrawBuffer",
+	"glDrawBuffers",
+	"glDrawElements",
+	"glDrawElementsBaseVertex",
+	"glDrawElementsIndirect",
+	"glDrawElementsInstanced",
+	"glDrawElementsInstancedBaseInstance",
+	"glDrawElementsInstancedBaseVertex",
+	"glDrawElementsInstancedBaseVertexBaseInstance",
+	"glDrawRangeElements",
+	"glDrawRangeElementsBaseVertex",
+	"glDrawTransformFeedback",
+	"glDrawTransformFeedbackInstanced",
+	"glDrawTransformFeedbackStream",
+	"glDrawTransformFeedbackStreamInstanced",
+	"glEnable",
+	"glEnableVertexArrayAttrib",
+	"glEnableVertexAttribArray",
+	"glEnablei",
+	"glEndConditionalRender",
+	"glEndQuery",
+	"glEndQueryIndexed",
+	"glEndTransformFeedback",
+	"glFenceSync",
+	"glFinish",
+	"glFlush",
+	"glFlushMappedBufferRange",
+	"glFlushMappedNamedBufferRange",
+	"glFramebufferParameteri",
+	"glFramebufferParameteriMESA",
+	"glFramebufferRenderbuffer",
+	"glFramebufferTexture",
+	"glFramebufferTexture1D",
+	"glFramebufferTexture2D",
+	"glFramebufferTexture3D",
+	"glFramebufferTextureLayer",
+	"glFrontFace",
+	"glGenBuffers",
+	"glGenFramebuffers",
+	"glGenProgramPipelines",
+	"glGenQueries",
+	"glGenRenderbuffers",
+	"glGenSamplers",
+	"glGenTextures",
+	"glGenTransformFeedbacks",
+	"glGenVertexArrays",
+	"glGenerateMipmap",
+	"glGenerateTextureMipmap",
+	"glGetActiveAtomicCounterBufferiv",
+	"glGetActiveAttrib",
+	"glGetActiveSubroutineName",
+	"glGetActiveSubroutineUniformName",
+	"glGetActiveSubroutineUniformiv",
+	"glGetActiveUniform",
+	"glGetActiveUniformBlockName",
+	"glGetActiveUniformBlockiv",
+	"glGetActiveUniformName",
+	"glGetActiveUniformsiv",
+	"glGetAttachedShaders",
+	"glGetAttribLocation",
+	"glGetBooleani_v",
+	"glGetBooleanv",
+	"glGetBufferParameteri64v",
+	"glGetBufferParameteriv",
+	"glGetBufferPointerv",
+	"glGetBufferSubData",
+	"glGetCompressedTexImage",
+	"glGetCompressedTextureImage",
+	"glGetCompressedTextureSubImage",
+	"glGetDebugMessageLog",
+	"glGetDoublei_v",
+	"glGetDoublev",
+	"glGetError",
+	"glGetFloati_v",
+	"glGetFloatv",
+	"glGetFragDataIndex",
+	"glGetFragDataLocation",
+	"glGetFramebufferAttachmentParameteriv",
+	"glGetFramebufferParameteriv",
+	"glGetFramebufferParameterivMESA",
+	"glGetGraphicsResetStatus",
+	"glGetInteger64i_v",
+	"glGetInteger64v",
+	"glGetIntegeri_v",
+	"glGetIntegerv",
+	"glGetInternalformati64v",
+	"glGetInternalformativ",
+	"glGetMultisamplefv",
+	"glGetNamedBufferParameteri64v",
+	"glGetNamedBufferParameteriv",
+	"glGetNamedBufferPointerv",
+	"glGetNamedBufferSubData",
+	"glGetNamedFramebufferAttachmentParameteriv",
+	"glGetNamedFramebufferParameteriv",
+	"glGetNamedRenderbufferParameteriv",
+	"glGetObjectLabel",
+	"glGetObjectPtrLabel",
+	"glGetPointerv",
+	"glGetProgramBinary",
+	"glGetProgramInfoLog",
+	"glGetProgramInterfaceiv",
+	"glGetProgramPipelineInfoLog",
+	"glGetProgramPipelineiv",
+	"glGetProgramResourceIndex",
+	"glGetProgramResourceLocation",
+	"glGetProgramResourceLocationIndex",
+	"glGetProgramResourceName",
+	"glGetProgramResourceiv",
+	"glGetProgramStageiv",
+	"glGetProgramiv",
+	"glGetQueryBufferObjecti64v",
+	"glGetQueryBufferObjectiv",
+	"glGetQueryBufferObjectui64v",
+	"glGetQueryBufferObjectuiv",
+	"glGetQueryIndexediv",
+	"glGetQueryObjecti64v",
+	"glGetQueryObjectiv",
+	"glGetQueryObjectui64v",
+	"glGetQueryObjectuiv",
+	"glGetQueryiv",
+	"glGetRenderbufferParameteriv",
+	"glGetSamplerParameterIiv",
+	"glGetSamplerParameterIuiv",
+	"glGetSamplerParameterfv",
+	"glGetSamplerParameteriv",
+	"glGetShaderInfoLog",
+	"glGetShaderPrecisionFormat",
+	"glGetShaderSource",
+	"glGetShaderiv",
+	"glGetString",
+	"glGetStringi",
+	"glGetSubroutineIndex",
+	"glGetSubroutineUniformLocation",
+	"glGetSynciv",
+	"glGetTexImage",
+	"glGetTexLevelParameterfv",
+	"glGetTexLevelParameteriv",
+	"glGetTexParameterIiv",
+	"glGetTexParameterIuiv",
+	"glGetTexParameterfv",
+	"glGetTexParameteriv",
+	"glGetTextureImage",
+	"glGetTextureLevelParameterfv",
+	"glGetTextureLevelParameteriv",
+	"glGetTextureParameterIiv",
+	"glGetTextureParameterIuiv",
+	"glGetTextureParameterfv",
+	"glGetTextureParameteriv",
+	"glGetTextureSubImage",
+	"glGetTransformFeedbackVarying",
+	"glGetTransformFeedbacki64_v",
+	"glGetTransformFeedbacki_v",
+	"glGetTransformFeedbackiv",
+	"glGetUniformBlockIndex",
+	"glGetUniformIndices",
+	"glGetUniformLocation",
+	"glGetUniformSubroutineuiv",
+	"glGetUniformdv",
+	"glGetUniformfv",
+	"glGetUniformiv",
+	"glGetUniformuiv",
+	"glGetVertexArrayIndexed64iv",
+	"glGetVertexArrayIndexediv",
+	"glGetVertexArrayiv",
+	"glGetVertexAttribIiv",
+	"glGetVertexAttribIuiv",
+	"glGetVertexAttribLdv",
+	"glGetVertexAttribPointerv",
+	"glGetVertexAttribdv",
+	"glGetVertexAttribfv",
+	"glGetVertexAttribiv",
+	"glGetnCompressedTexImage",
+	"glGetnTexImage",
+	"glGetnUniformdv",
+	"glGetnUniformfv",
+	"glGetnUniformiv",
+	"glGetnUniformuiv",
+	"glHint",
+	"glInvalidateBufferData",
+	"glInvalidateBufferSubData",
+	"glInvalidateFramebuffer",
+	"glInvalidateNamedFramebufferData",
+	"glInvalidateNamedFramebufferSubData",
+	"glInvalidateSubFramebuffer",
+	"glInvalidateTexImage",
+	"glInvalidateTexSubImage",
+	"glIsBuffer",
+	"glIsEnabled",
+	"glIsEnabledi",
+	"glIsFramebuffer",
+	"glIsProgram",
+	"glIsProgramPipeline",
+	"glIsQuery",
+	"glIsRenderbuffer",
+	"glIsSampler",
+	"glIsShader",
+	"glIsSync",
+	"glIsTexture",
+	"glIsTransformFeedback",
+	"glIsVertexArray",
+	"glLineWidth",
+	"glLinkProgram",
+	"glLogicOp",
+	"glMapBuffer",
+	"glMapBufferRange",
+	"glMapNamedBuffer",
+	"glMapNamedBufferRange",
+	"glMemoryBarrier",
+	"glMemoryBarrierByRegion",
+	"glMinSampleShading",
+	"glMultiDrawArrays",
+	"glMultiDrawArraysIndirect",
+	"glMultiDrawArraysIndirectCount",
+	"glMultiDrawElements",
+	"glMultiDrawElementsBaseVertex",
+	"glMultiDrawElementsIndirect",
+	"glMultiDrawElementsIndirectCount",
+	"glNamedBufferData",
+	"glNamedBufferStorage",
+	"glNamedBufferSubData",
+	"glNamedFramebufferDrawBuffer",
+	"glNamedFramebufferDrawBuffers",
+	"glNamedFramebufferParameteri",
+	"glNamedFramebufferReadBuffer",
+	"glNamedFramebufferRenderbuffer",
+	"glNamedFramebufferTexture",
+	"glNamedFramebufferTextureLayer",
+	"glNamedRenderbufferStorage",
+	"glNamedRenderbufferStorageMultisample",
+	"glObjectLabel",
+	"glObjectPtrLabel",
+	"glPatchParameterfv",
+	"glPatchParameteri",
+	"glPauseTransformFeedback",
+	"glPixelStoref",
+	"glPixelStorei",
+	"glPointParameterf",
+	"glPointParameterfv",
+	"glPointParameteri",
+	"glPointParameteriv",
+	"glPointSize",
+	"glPolygonMode",
+	"glPolygonOffset",
+	"glPolygonOffsetClamp",
+	"glPopDebugGroup",
+	"glPrimitiveRestartIndex",
+	"glProgramBinary",
+	"glProgramParameteri",
+	"glProgramUniform1d",
+	"glProgramUniform1dv",
+	"glProgramUniform1f",
+	"glProgramUniform1fv",
+	"glProgramUniform1i",
+	"glProgramUniform1iv",
+	"glProgramUniform1ui",
+	"glProgramUniform1uiv",
+	"glProgramUniform2d",
+	"glProgramUniform2dv",
+	"glProgramUniform2f",
+	"glProgramUniform2fv",
+	"glProgramUniform2i",
+	"glProgramUniform2iv",
+	"glProgramUniform2ui",
+	"glProgramUniform2uiv",
+	"glProgramUniform3d",
+	"glProgramUniform3dv",
+	"glProgramUniform3f",
+	"glProgramUniform3fv",
+	"glProgramUniform3i",
+	"glProgramUniform3iv",
+	"glProgramUniform3ui",
+	"glProgramUniform3uiv",
+	"glProgramUniform4d",
+	"glProgramUniform4dv",
+	"glProgramUniform4f",
+	"glProgramUniform4fv",
+	"glProgramUniform4i",
+	"glProgramUniform4iv",
+	"glProgramUniform4ui",
+	"glProgramUniform4uiv",
+	"glProgramUniformMatrix2dv",
+	"glProgramUniformMatrix2fv",
+	"glProgramUniformMatrix2x3dv",
+	"glProgramUniformMatrix2x3fv",
+	"glProgramUniformMatrix2x4dv",
+	"glProgramUniformMatrix2x4fv",
+	"glProgramUniformMatrix3dv",
+	"glProgramUniformMatrix3fv",
+	"glProgramUniformMatrix3x2dv",
+	"glProgramUniformMatrix3x2fv",
+	"glProgramUniformMatrix3x4dv",
+	"glProgramUniformMatrix3x4fv",
+	"glProgramUniformMatrix4dv",
+	"glProgramUniformMatrix4fv",
+	"glProgramUniformMatrix4x2dv",
+	"glProgramUniformMatrix4x2fv",
+	"glProgramUniformMatrix4x3dv",
+	"glProgramUniformMatrix4x3fv",
+	"glProvokingVertex",
+	"glPushDebugGroup",
+	"glQueryCounter",
+	"glReadBuffer",
+	"glReadPixels",
+	"glReadnPixels",
+	"glReleaseShaderCompiler",
+	"glRenderbufferStorage",
+	"glRenderbufferStorageMultisample",
+	"glResumeTransformFeedback",
+	"glSampleCoverage",
+	"glSampleMaski",
+	"glSamplerParameterIiv",
+	"glSamplerParameterIuiv",
+	"glSamplerParameterf",
+	"glSamplerParameterfv",
+	"glSamplerParameteri",
+	"glSamplerParameteriv",
+	"glScissor",
+	"glScissorArrayv",
+	"glScissorIndexed",
+	"glScissorIndexedv",
+	"glShaderBinary",
+	"glShaderSource",
+	"glShaderStorageBlockBinding",
+	"glSpecializeShader",
+	"glStencilFunc",
+	"glStencilFuncSeparate",
+	"glStencilMask",
+	"glStencilMaskSeparate",
+	"glStencilOp",
+	"glStencilOpSeparate",
+	"glTexBuffer",
+	"glTexBufferRange",
+	"glTexImage1D",
+	"glTexImage2D",
+	"glTexImage2DMultisample",
+	"glTexImage3D",
+	"glTexImage3DMultisample",
+	"glTexParameterIiv",
+	"glTexParameterIuiv",
+	"glTexParameterf",
+	"glTexParameterfv",
+	"glTexParameteri",
+	"glTexParameteriv",
+	"glTexStorage1D",
+	"glTexStorage2D",
+	"glTexStorage2DMultisample",
+	"glTexStorage3D",
+	"glTexStorage3DMultisample",
+	"glTexSubImage1D",
+	"glTexSubImage2D",
+	"glTexSubImage3D",
+	"glTextureBarrier",
+	"glTextureBuffer",
+	"glTextureBufferRange",
+	"glTextureParameterIiv",
+	"glTextureParameterIuiv",
+	"glTextureParameterf",
+	"glTextureParameterfv",
+	"glTextureParameteri",
+	"glTextureParameteriv",
+	"glTextureStorage1D",
+	"glTextureStorage2D",
+	"glTextureStorage2DMultisample",
+	"glTextureStorage3D",
+	"glTextureStorage3DMultisample",
+	"glTextureSubImage1D",
+	"glTextureSubImage2D",
+	"glTextureSubImage3D",
+	"glTextureView",
+	"glTransformFeedbackBufferBase",
+	"glTransformFeedbackBufferRange",
+	"glTransformFeedbackVaryings",
+	"glUniform1d",
+	"glUniform1dv",
+	"glUniform1f",
+	"glUniform1fv",
+	"glUniform1i",
+	"glUniform1iv",
+	"glUniform1ui",
+	"glUniform1uiv",
+	"glUniform2d",
+	"glUniform2dv",
+	"glUniform2f",
+	"glUniform2fv",
+	"glUniform2i",
+	"glUniform2iv",
+	"glUniform2ui",
+	"glUniform2uiv",
+	"glUniform3d",
+	"glUniform3dv",
+	"glUniform3f",
+	"glUniform3fv",
+	"glUniform3i",
+	"glUniform3iv",
+	"glUniform3ui",
+	"glUniform3uiv",
+	"glUniform4d",
+	"glUniform4dv",
+	"glUniform4f",
+	"glUniform4fv",
+	"glUniform4i",
+	"glUniform4iv",
+	"glUniform4ui",
+	"glUniform4uiv",
+	"glUniformBlockBinding",
+	"glUniformMatrix2dv",
+	"glUniformMatrix2fv",
+	"glUniformMatrix2x3dv",
+	"glUniformMatrix2x3fv",
+	"glUniformMatrix2x4dv",
+	"glUniformMatrix2x4fv",
+	"glUniformMatrix3dv",
+	"glUniformMatrix3fv",
+	"glUniformMatrix3x2dv",
+	"glUniformMatrix3x2fv",
+	"glUniformMatrix3x4dv",
+	"glUniformMatrix3x4fv",
+	"glUniformMatrix4dv",
+	"glUniformMatrix4fv",
+	"glUniformMatrix4x2dv",
+	"glUniformMatrix4x2fv",
+	"glUniformMatrix4x3dv",
+	"glUniformMatrix4x3fv",
+	"glUniformSubroutinesuiv",
+	"glUnmapBuffer",
+	"glUnmapNamedBuffer",
+	"glUseProgram",
+	"glUseProgramStages",
+	"glValidateProgram",
+	"glValidateProgramPipeline",
+	"glVertexArrayAttribBinding",
+	"glVertexArrayAttribFormat",
+	"glVertexArrayAttribIFormat",
+	"glVertexArrayAttribLFormat",
+	"glVertexArrayBindingDivisor",
+	"glVertexArrayElementBuffer",
+	"glVertexArrayVertexBuffer",
+	"glVertexArrayVertexBuffers",
+	"glVertexAttrib1d",
+	"glVertexAttrib1dv",
+	"glVertexAttrib1f",
+	"glVertexAttrib1fv",
+	"glVertexAttrib1s",
+	"glVertexAttrib1sv",
+	"glVertexAttrib2d",
+	"glVertexAttrib2dv",
+	"glVertexAttrib2f",
+	"glVertexAttrib2fv",
+	"glVertexAttrib2s",
+	"glVertexAttrib2sv",
+	"glVertexAttrib3d",
+	"glVertexAttrib3dv",
+	"glVertexAttrib3f",
+	"glVertexAttrib3fv",
+	"glVertexAttrib3s",
+	"glVertexAttrib3sv",
+	"glVertexAttrib4Nbv",
+	"glVertexAttrib4Niv",
+	"glVertexAttrib4Nsv",
+	"glVertexAttrib4Nub",
+	"glVertexAttrib4Nubv",
+	"glVertexAttrib4Nuiv",
+	"glVertexAttrib4Nusv",
+	"glVertexAttrib4bv",
+	"glVertexAttrib4d",
+	"glVertexAttrib4dv",
+	"glVertexAttrib4f",
+	"glVertexAttrib4fv",
+	"glVertexAttrib4iv",
+	"glVertexAttrib4s",
+	"glVertexAttrib4sv",
+	"glVertexAttrib4ubv",
+	"glVertexAttrib4uiv",
+	"glVertexAttrib4usv",
+	"glVertexAttribBinding",
+	"glVertexAttribDivisor",
+	"glVertexAttribFormat",
+	"glVertexAttribI1i",
+	"glVertexAttribI1iv",
+	"glVertexAttribI1ui",
+	"glVertexAttribI1uiv",
+	"glVertexAttribI2i",
+	"glVertexAttribI2iv",
+	"glVertexAttribI2ui",
+	"glVertexAttribI2uiv",
+	"glVertexAttribI3i",
+	"glVertexAttribI3iv",
+	"glVertexAttribI3ui",
+	"glVertexAttribI3uiv",
+	"glVertexAttribI4bv",
+	"glVertexAttribI4i",
+	"glVertexAttribI4iv",
+	"glVertexAttribI4sv",
+	"glVertexAttribI4ubv",
+	"glVertexAttribI4ui",
+	"glVertexAttribI4uiv",
+	"glVertexAttribI4usv",
+	"glVertexAttribIFormat",
+	"glVertexAttribIPointer",
+	"glVertexAttribL1d",
+	"glVertexAttribL1dv",
+	"glVertexAttribL2d",
+	"glVertexAttribL2dv",
+	"glVertexAttribL3d",
+	"glVertexAttribL3dv",
+	"glVertexAttribL4d",
+	"glVertexAttribL4dv",
+	"glVertexAttribLFormat",
+	"glVertexAttribLPointer",
+	"glVertexAttribP1ui",
+	"glVertexAttribP1uiv",
+	"glVertexAttribP2ui",
+	"glVertexAttribP2uiv",
+	"glVertexAttribP3ui",
+	"glVertexAttribP3uiv",
+	"glVertexAttribP4ui",
+	"glVertexAttribP4uiv",
+	"glVertexAttribPointer",
+	"glVertexBindingDivisor",
+	"glViewport",
+	"glViewportArrayv",
+	"glViewportIndexedf",
+	"glViewportIndexedfv",
+	"glWaitSync",
+};
+
+GL3W_API union GL3WProcs gl3wProcs;
+
+static void load_procs(GL3WGetProcAddressProc proc)
+{
+	size_t i;
+
+	for (i = 0; i < ARRAY_SIZE(proc_names); i++)
+		gl3wProcs.ptr[i] = proc(proc_names[i]);
+}
--- a/TSE_OpenGlImpl/src/extern/imgui_impl_opengl3.cpp
+++ b/TSE_OpenGlImpl/src/extern/imgui_impl_opengl3.cpp
--- a/TSE_OpenGlImpl/src/extern/imgui_impl_opengl3.h
+++ b/TSE_OpenGlImpl/src/extern/imgui_impl_opengl3.h
@@ -0,0 +1,67 @@
+// dear imgui: Renderer Backend for modern OpenGL with shaders / programmatic pipeline
+// - Desktop GL: 2.x 3.x 4.x
+// - Embedded GL: ES 2.0 (WebGL 1.0), ES 3.0 (WebGL 2.0)
+// This needs to be used along with a Platform Backend (e.g. GLFW, SDL, Win32, custom..)
+
+// Implemented features:
+//  [X] Renderer: User texture binding. Use 'GLuint' OpenGL texture identifier as void*/ImTextureID. Read the FAQ about ImTextureID!
+//  [x] Renderer: Large meshes support (64k+ vertices) even with 16-bit indices (ImGuiBackendFlags_RendererHasVtxOffset) [Desktop OpenGL only!]
+//  [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
+
+// About WebGL/ES:
+// - You need to '#define IMGUI_IMPL_OPENGL_ES2' or '#define IMGUI_IMPL_OPENGL_ES3' to use WebGL or OpenGL ES.
+// - This is done automatically on iOS, Android and Emscripten targets.
+// - For other targets, the define needs to be visible from the imgui_impl_opengl3.cpp compilation unit. If unsure, define globally or in imconfig.h.
+
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
+// Learn about Dear ImGui:
+// - FAQ                  https://dearimgui.com/faq
+// - Getting Started      https://dearimgui.com/getting-started
+// - Documentation        https://dearimgui.com/docs (same as your local docs/ folder).
+// - Introduction, links and more at the top of imgui.cpp
+
+// About GLSL version:
+//  The 'glsl_version' initialization parameter should be nullptr (default) or a "#version XXX" string.
+//  On computer platform the GLSL version default to "#version 130". On OpenGL ES 3 platform it defaults to "#version 300 es"
+//  Only override if your GL version doesn't handle this GLSL version. See GLSL version table at the top of imgui_impl_opengl3.cpp.
+
+#pragma once
+#include "imgui/imgui.h"      // IMGUI_IMPL_API
+#ifndef IMGUI_DISABLE
+
+// Follow "Getting Started" link and check examples/ folder to learn about using backends!
+IMGUI_IMPL_API bool     ImGui_ImplOpenGL3_Init(const char* glsl_version = nullptr);
+IMGUI_IMPL_API void     ImGui_ImplOpenGL3_Shutdown();
+IMGUI_IMPL_API void     ImGui_ImplOpenGL3_NewFrame();
+IMGUI_IMPL_API void     ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
+
+// (Optional) Called by Init/NewFrame/Shutdown
+IMGUI_IMPL_API bool     ImGui_ImplOpenGL3_CreateFontsTexture();
+IMGUI_IMPL_API void     ImGui_ImplOpenGL3_DestroyFontsTexture();
+IMGUI_IMPL_API bool     ImGui_ImplOpenGL3_CreateDeviceObjects();
+IMGUI_IMPL_API void     ImGui_ImplOpenGL3_DestroyDeviceObjects();
+
+// Configuration flags to add in your imconfig file:
+//#define IMGUI_IMPL_OPENGL_ES2     // Enable ES 2 (Auto-detected on Emscripten)
+//#define IMGUI_IMPL_OPENGL_ES3     // Enable ES 3 (Auto-detected on iOS/Android)
+
+// You can explicitly select GLES2 or GLES3 API by using one of the '#define IMGUI_IMPL_OPENGL_LOADER_XXX' in imconfig.h or compiler command-line.
+#if !defined(IMGUI_IMPL_OPENGL_ES2) \
+ && !defined(IMGUI_IMPL_OPENGL_ES3)
+
+// Try to detect GLES on matching platforms
+#if defined(__APPLE__)
+#include <TargetConditionals.h>
+#endif
+#if (defined(__APPLE__) && (TARGET_OS_IOS || TARGET_OS_TV)) || (defined(__ANDROID__))
+#define IMGUI_IMPL_OPENGL_ES3               // iOS, Android  -> GL ES 3, "#version 300 es"
+#elif defined(__EMSCRIPTEN__) || defined(__amigaos4__)
+#define IMGUI_IMPL_OPENGL_ES2               // Emscripten    -> GL ES 2, "#version 100"
+#else
+// Otherwise imgui_impl_opengl3_loader.h will be used.
+#endif
+
+#endif
+
+#endif // #ifndef IMGUI_DISABLE
--- a/TSE_OpenGlImpl/src/extern/imgui_impl_opengl3_loader.h
+++ b/TSE_OpenGlImpl/src/extern/imgui_impl_opengl3_loader.h
@@ -0,0 +1,916 @@
+//-----------------------------------------------------------------------------
+// About imgui_impl_opengl3_loader.h:
+//
+// We embed our own OpenGL loader to not require user to provide their own or to have to use ours,
+// which proved to be endless problems for users.
+// Our loader is custom-generated, based on gl3w but automatically filtered to only include
+// enums/functions that we use in our imgui_impl_opengl3.cpp source file in order to be small.
+//
+// YOU SHOULD NOT NEED TO INCLUDE/USE THIS DIRECTLY. THIS IS USED BY imgui_impl_opengl3.cpp ONLY.
+// THE REST OF YOUR APP SHOULD USE A DIFFERENT GL LOADER: ANY GL LOADER OF YOUR CHOICE.
+//
+// IF YOU GET BUILD ERRORS IN THIS FILE (commonly macro redefinitions or function redefinitions):
+// IT LIKELY MEANS THAT YOU ARE BUILDING 'imgui_impl_opengl3.cpp' OR INCLUDING 'imgui_impl_opengl3_loader.h'
+// IN THE SAME COMPILATION UNIT AS ONE OF YOUR FILE WHICH IS USING A THIRD-PARTY OPENGL LOADER.
+// (e.g. COULD HAPPEN IF YOU ARE DOING A UNITY/JUMBO BUILD, OR INCLUDING .CPP FILES FROM OTHERS)
+// YOU SHOULD NOT BUILD BOTH IN THE SAME COMPILATION UNIT.
+// BUT IF YOU REALLY WANT TO, you can '#define IMGUI_IMPL_OPENGL_LOADER_CUSTOM' and imgui_impl_opengl3.cpp
+// WILL NOT BE USING OUR LOADER, AND INSTEAD EXPECT ANOTHER/YOUR LOADER TO BE AVAILABLE IN THE COMPILATION UNIT.
+//
+// Regenerate with:
+//   python3 gl3w_gen.py --output ../imgui/backends/imgui_impl_opengl3_loader.h --ref ../imgui/backends/imgui_impl_opengl3.cpp ./extra_symbols.txt
+//
+// More info:
+//   https://github.com/dearimgui/gl3w_stripped
+//   https://github.com/ocornut/imgui/issues/4445
+//-----------------------------------------------------------------------------
+
+/*
+ * This file was generated with gl3w_gen.py, part of imgl3w
+ * (hosted at https://github.com/dearimgui/gl3w_stripped)
+ *
+ * This is free and unencumbered software released into the public domain.
+ *
+ * Anyone is free to copy, modify, publish, use, compile, sell, or
+ * distribute this software, either in source code form or as a compiled
+ * binary, for any purpose, commercial or non-commercial, and by any
+ * means.
+ *
+ * In jurisdictions that recognize copyright laws, the author or authors
+ * of this software dedicate any and all copyright interest in the
+ * software to the public domain. We make this dedication for the benefit
+ * of the public at large and to the detriment of our heirs and
+ * successors. We intend this dedication to be an overt act of
+ * relinquishment in perpetuity of all present and future rights to this
+ * software under copyright law.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __gl3w_h_
+#define __gl3w_h_
+
+// Adapted from KHR/khrplatform.h to avoid including entire file.
+#ifndef __khrplatform_h_
+typedef          float         khronos_float_t;
+typedef signed   char          khronos_int8_t;
+typedef unsigned char          khronos_uint8_t;
+typedef signed   short int     khronos_int16_t;
+typedef unsigned short int     khronos_uint16_t;
+#ifdef _WIN64
+typedef signed   long long int khronos_intptr_t;
+typedef signed   long long int khronos_ssize_t;
+#else
+typedef signed   long  int     khronos_intptr_t;
+typedef signed   long  int     khronos_ssize_t;
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+typedef signed   __int64       khronos_int64_t;
+typedef unsigned __int64       khronos_uint64_t;
+#elif (defined(__clang__) || defined(__GNUC__)) && (__cplusplus < 201100)
+#include <stdint.h>
+typedef          int64_t       khronos_int64_t;
+typedef          uint64_t      khronos_uint64_t;
+#else
+typedef signed   long long     khronos_int64_t;
+typedef unsigned long long     khronos_uint64_t;
+#endif
+#endif  // __khrplatform_h_
+
+#ifndef __gl_glcorearb_h_
+#define __gl_glcorearb_h_ 1
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+** Copyright 2013-2020 The Khronos Group Inc.
+** SPDX-License-Identifier: MIT
+**
+** This header is generated from the Khronos OpenGL / OpenGL ES XML
+** API Registry. The current version of the Registry, generator scripts
+** used to make the header, and the header can be found at
+**   https://github.com/KhronosGroup/OpenGL-Registry
+*/
+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN 1
+#endif
+#include <windows.h>
+#endif
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef APIENTRYP
+#define APIENTRYP APIENTRY *
+#endif
+#ifndef GLAPI
+#define GLAPI extern
+#endif
+/* glcorearb.h is for use with OpenGL core profile implementations.
+** It should should be placed in the same directory as gl.h and
+** included as <GL/glcorearb.h>.
+**
+** glcorearb.h includes only APIs in the latest OpenGL core profile
+** implementation together with APIs in newer ARB extensions which 
+** can be supported by the core profile. It does not, and never will
+** include functionality removed from the core profile, such as
+** fixed-function vertex and fragment processing.
+**
+** Do not #include both <GL/glcorearb.h> and either of <GL/gl.h> or
+** <GL/glext.h> in the same source file.
+*/
+/* Generated C header for:
+ * API: gl
+ * Profile: core
+ * Versions considered: .*
+ * Versions emitted: .*
+ * Default extensions included: glcore
+ * Additional extensions included: _nomatch_^
+ * Extensions removed: _nomatch_^
+ */
+#ifndef GL_VERSION_1_0
+typedef void GLvoid;
+typedef unsigned int GLenum;
+
+typedef khronos_float_t GLfloat;
+typedef int GLint;
+typedef int GLsizei;
+typedef unsigned int GLbitfield;
+typedef double GLdouble;
+typedef unsigned int GLuint;
+typedef unsigned char GLboolean;
+typedef khronos_uint8_t GLubyte;
+#define GL_COLOR_BUFFER_BIT               0x00004000
+#define GL_FALSE                          0
+#define GL_TRUE                           1
+#define GL_TRIANGLES                      0x0004
+#define GL_ONE                            1
+#define GL_SRC_ALPHA                      0x0302
+#define GL_ONE_MINUS_SRC_ALPHA            0x0303
+#define GL_FRONT                          0x0404
+#define GL_BACK                           0x0405
+#define GL_FRONT_AND_BACK                 0x0408
+#define GL_POLYGON_MODE                   0x0B40
+#define GL_CULL_FACE                      0x0B44
+#define GL_DEPTH_TEST                     0x0B71
+#define GL_STENCIL_TEST                   0x0B90
+#define GL_VIEWPORT                       0x0BA2
+#define GL_BLEND                          0x0BE2
+#define GL_SCISSOR_BOX                    0x0C10
+#define GL_SCISSOR_TEST                   0x0C11
+#define GL_UNPACK_ROW_LENGTH              0x0CF2
+#define GL_PACK_ALIGNMENT                 0x0D05
+#define GL_TEXTURE_2D                     0x0DE1
+#define GL_UNSIGNED_BYTE                  0x1401
+#define GL_UNSIGNED_SHORT                 0x1403
+#define GL_UNSIGNED_INT                   0x1405
+#define GL_FLOAT                          0x1406
+#define GL_RGBA                           0x1908
+#define GL_FILL                           0x1B02
+#define GL_VENDOR                         0x1F00
+#define GL_RENDERER                       0x1F01
+#define GL_VERSION                        0x1F02
+#define GL_EXTENSIONS                     0x1F03
+#define GL_LINEAR                         0x2601
+#define GL_TEXTURE_MAG_FILTER             0x2800
+#define GL_TEXTURE_MIN_FILTER             0x2801
+#define GL_TEXTURE_WRAP_S                 0x2802
+#define GL_TEXTURE_WRAP_T                 0x2803
+#define GL_REPEAT                         0x2901
+typedef void (APIENTRYP PFNGLPOLYGONMODEPROC) (GLenum face, GLenum mode);
+typedef void (APIENTRYP PFNGLSCISSORPROC) (GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC) (GLenum target, GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
+typedef void (APIENTRYP PFNGLCLEARPROC) (GLbitfield mask);
+typedef void (APIENTRYP PFNGLCLEARCOLORPROC) (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+typedef void (APIENTRYP PFNGLDISABLEPROC) (GLenum cap);
+typedef void (APIENTRYP PFNGLENABLEPROC) (GLenum cap);
+typedef void (APIENTRYP PFNGLFLUSHPROC) (void);
+typedef void (APIENTRYP PFNGLPIXELSTOREIPROC) (GLenum pname, GLint param);
+typedef void (APIENTRYP PFNGLREADPIXELSPROC) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
+typedef GLenum (APIENTRYP PFNGLGETERRORPROC) (void);
+typedef void (APIENTRYP PFNGLGETINTEGERVPROC) (GLenum pname, GLint *data);
+typedef const GLubyte *(APIENTRYP PFNGLGETSTRINGPROC) (GLenum name);
+typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC) (GLenum cap);
+typedef void (APIENTRYP PFNGLVIEWPORTPROC) (GLint x, GLint y, GLsizei width, GLsizei height);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glPolygonMode (GLenum face, GLenum mode);
+GLAPI void APIENTRY glScissor (GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glTexParameteri (GLenum target, GLenum pname, GLint param);
+GLAPI void APIENTRY glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
+GLAPI void APIENTRY glClear (GLbitfield mask);
+GLAPI void APIENTRY glClearColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+GLAPI void APIENTRY glDisable (GLenum cap);
+GLAPI void APIENTRY glEnable (GLenum cap);
+GLAPI void APIENTRY glFlush (void);
+GLAPI void APIENTRY glPixelStorei (GLenum pname, GLint param);
+GLAPI void APIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
+GLAPI GLenum APIENTRY glGetError (void);
+GLAPI void APIENTRY glGetIntegerv (GLenum pname, GLint *data);
+GLAPI const GLubyte *APIENTRY glGetString (GLenum name);
+GLAPI GLboolean APIENTRY glIsEnabled (GLenum cap);
+GLAPI void APIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height);
+#endif
+#endif /* GL_VERSION_1_0 */
+#ifndef GL_VERSION_1_1
+typedef khronos_float_t GLclampf;
+typedef double GLclampd;
+#define GL_TEXTURE_BINDING_2D             0x8069
+typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices);
+typedef void (APIENTRYP PFNGLBINDTEXTUREPROC) (GLenum target, GLuint texture);
+typedef void (APIENTRYP PFNGLDELETETEXTURESPROC) (GLsizei n, const GLuint *textures);
+typedef void (APIENTRYP PFNGLGENTEXTURESPROC) (GLsizei n, GLuint *textures);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDrawElements (GLenum mode, GLsizei count, GLenum type, const void *indices);
+GLAPI void APIENTRY glBindTexture (GLenum target, GLuint texture);
+GLAPI void APIENTRY glDeleteTextures (GLsizei n, const GLuint *textures);
+GLAPI void APIENTRY glGenTextures (GLsizei n, GLuint *textures);
+#endif
+#endif /* GL_VERSION_1_1 */
+#ifndef GL_VERSION_1_2
+#define GL_CLAMP_TO_EDGE                  0x812F
+#endif /* GL_VERSION_1_2 */
+#ifndef GL_VERSION_1_3
+#define GL_TEXTURE0                       0x84C0
+#define GL_ACTIVE_TEXTURE                 0x84E0
+typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC) (GLenum texture);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glActiveTexture (GLenum texture);
+#endif
+#endif /* GL_VERSION_1_3 */
+#ifndef GL_VERSION_1_4
+#define GL_BLEND_DST_RGB                  0x80C8
+#define GL_BLEND_SRC_RGB                  0x80C9
+#define GL_BLEND_DST_ALPHA                0x80CA
+#define GL_BLEND_SRC_ALPHA                0x80CB
+#define GL_FUNC_ADD                       0x8006
+typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC) (GLenum mode);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+GLAPI void APIENTRY glBlendEquation (GLenum mode);
+#endif
+#endif /* GL_VERSION_1_4 */
+#ifndef GL_VERSION_1_5
+typedef khronos_ssize_t GLsizeiptr;
+typedef khronos_intptr_t GLintptr;
+#define GL_ARRAY_BUFFER                   0x8892
+#define GL_ELEMENT_ARRAY_BUFFER           0x8893
+#define GL_ARRAY_BUFFER_BINDING           0x8894
+#define GL_ELEMENT_ARRAY_BUFFER_BINDING   0x8895
+#define GL_STREAM_DRAW                    0x88E0
+typedef void (APIENTRYP PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer);
+typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers);
+typedef void (APIENTRYP PFNGLGENBUFFERSPROC) (GLsizei n, GLuint *buffers);
+typedef void (APIENTRYP PFNGLBUFFERDATAPROC) (GLenum target, GLsizeiptr size, const void *data, GLenum usage);
+typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const void *data);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBindBuffer (GLenum target, GLuint buffer);
+GLAPI void APIENTRY glDeleteBuffers (GLsizei n, const GLuint *buffers);
+GLAPI void APIENTRY glGenBuffers (GLsizei n, GLuint *buffers);
+GLAPI void APIENTRY glBufferData (GLenum target, GLsizeiptr size, const void *data, GLenum usage);
+GLAPI void APIENTRY glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const void *data);
+#endif
+#endif /* GL_VERSION_1_5 */
+#ifndef GL_VERSION_2_0
+typedef char GLchar;
+typedef khronos_int16_t GLshort;
+typedef khronos_int8_t GLbyte;
+typedef khronos_uint16_t GLushort;
+#define GL_BLEND_EQUATION_RGB             0x8009
+#define GL_VERTEX_ATTRIB_ARRAY_ENABLED    0x8622
+#define GL_VERTEX_ATTRIB_ARRAY_SIZE       0x8623
+#define GL_VERTEX_ATTRIB_ARRAY_STRIDE     0x8624
+#define GL_VERTEX_ATTRIB_ARRAY_TYPE       0x8625
+#define GL_VERTEX_ATTRIB_ARRAY_POINTER    0x8645
+#define GL_BLEND_EQUATION_ALPHA           0x883D
+#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A
+#define GL_FRAGMENT_SHADER                0x8B30
+#define GL_VERTEX_SHADER                  0x8B31
+#define GL_COMPILE_STATUS                 0x8B81
+#define GL_LINK_STATUS                    0x8B82
+#define GL_INFO_LOG_LENGTH                0x8B84
+#define GL_CURRENT_PROGRAM                0x8B8D
+#define GL_UPPER_LEFT                     0x8CA2
+typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC) (GLenum modeRGB, GLenum modeAlpha);
+typedef void (APIENTRYP PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader);
+typedef void (APIENTRYP PFNGLCOMPILESHADERPROC) (GLuint shader);
+typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC) (void);
+typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC) (GLenum type);
+typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC) (GLuint program);
+typedef void (APIENTRYP PFNGLDELETESHADERPROC) (GLuint shader);
+typedef void (APIENTRYP PFNGLDETACHSHADERPROC) (GLuint program, GLuint shader);
+typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC) (GLuint index);
+typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC) (GLuint index);
+typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC) (GLuint program, const GLchar *name);
+typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+typedef void (APIENTRYP PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const GLchar *name);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC) (GLuint index, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC) (GLuint index, GLenum pname, void **pointer);
+typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC) (GLuint program);
+typedef void (APIENTRYP PFNGLLINKPROGRAMPROC) (GLuint program);
+typedef void (APIENTRYP PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length);
+typedef void (APIENTRYP PFNGLUSEPROGRAMPROC) (GLuint program);
+typedef void (APIENTRYP PFNGLUNIFORM1IPROC) (GLint location, GLint v0);
+typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha);
+GLAPI void APIENTRY glAttachShader (GLuint program, GLuint shader);
+GLAPI void APIENTRY glCompileShader (GLuint shader);
+GLAPI GLuint APIENTRY glCreateProgram (void);
+GLAPI GLuint APIENTRY glCreateShader (GLenum type);
+GLAPI void APIENTRY glDeleteProgram (GLuint program);
+GLAPI void APIENTRY glDeleteShader (GLuint shader);
+GLAPI void APIENTRY glDetachShader (GLuint program, GLuint shader);
+GLAPI void APIENTRY glDisableVertexAttribArray (GLuint index);
+GLAPI void APIENTRY glEnableVertexAttribArray (GLuint index);
+GLAPI GLint APIENTRY glGetAttribLocation (GLuint program, const GLchar *name);
+GLAPI void APIENTRY glGetProgramiv (GLuint program, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+GLAPI void APIENTRY glGetShaderiv (GLuint shader, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetShaderInfoLog (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+GLAPI GLint APIENTRY glGetUniformLocation (GLuint program, const GLchar *name);
+GLAPI void APIENTRY glGetVertexAttribiv (GLuint index, GLenum pname, GLint *params);
+GLAPI void APIENTRY glGetVertexAttribPointerv (GLuint index, GLenum pname, void **pointer);
+GLAPI GLboolean APIENTRY glIsProgram (GLuint program);
+GLAPI void APIENTRY glLinkProgram (GLuint program);
+GLAPI void APIENTRY glShaderSource (GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length);
+GLAPI void APIENTRY glUseProgram (GLuint program);
+GLAPI void APIENTRY glUniform1i (GLint location, GLint v0);
+GLAPI void APIENTRY glUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+GLAPI void APIENTRY glVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
+#endif
+#endif /* GL_VERSION_2_0 */
+#ifndef GL_VERSION_2_1
+#define GL_PIXEL_UNPACK_BUFFER            0x88EC
+#define GL_PIXEL_UNPACK_BUFFER_BINDING    0x88EF
+#endif /* GL_VERSION_2_1 */
+#ifndef GL_VERSION_3_0
+typedef khronos_uint16_t GLhalf;
+#define GL_MAJOR_VERSION                  0x821B
+#define GL_MINOR_VERSION                  0x821C
+#define GL_NUM_EXTENSIONS                 0x821D
+#define GL_FRAMEBUFFER_SRGB               0x8DB9
+#define GL_VERTEX_ARRAY_BINDING           0x85B5
+typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC) (GLenum target, GLuint index, GLboolean *data);
+typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC) (GLenum target, GLuint index, GLint *data);
+typedef const GLubyte *(APIENTRYP PFNGLGETSTRINGIPROC) (GLenum name, GLuint index);
+typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC) (GLuint array);
+typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC) (GLsizei n, const GLuint *arrays);
+typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC) (GLsizei n, GLuint *arrays);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI const GLubyte *APIENTRY glGetStringi (GLenum name, GLuint index);
+GLAPI void APIENTRY glBindVertexArray (GLuint array);
+GLAPI void APIENTRY glDeleteVertexArrays (GLsizei n, const GLuint *arrays);
+GLAPI void APIENTRY glGenVertexArrays (GLsizei n, GLuint *arrays);
+#endif
+#endif /* GL_VERSION_3_0 */
+#ifndef GL_VERSION_3_1
+#define GL_VERSION_3_1 1
+#define GL_PRIMITIVE_RESTART              0x8F9D
+#endif /* GL_VERSION_3_1 */
+#ifndef GL_VERSION_3_2
+#define GL_VERSION_3_2 1
+typedef struct __GLsync *GLsync;
+typedef khronos_uint64_t GLuint64;
+typedef khronos_int64_t GLint64;
+#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
+#define GL_CONTEXT_PROFILE_MASK           0x9126
+typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex);
+typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC) (GLenum target, GLuint index, GLint64 *data);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glDrawElementsBaseVertex (GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex);
+#endif
+#endif /* GL_VERSION_3_2 */
+#ifndef GL_VERSION_3_3
+#define GL_VERSION_3_3 1
+#define GL_SAMPLER_BINDING                0x8919
+typedef void (APIENTRYP PFNGLBINDSAMPLERPROC) (GLuint unit, GLuint sampler);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void APIENTRY glBindSampler (GLuint unit, GLuint sampler);
+#endif
+#endif /* GL_VERSION_3_3 */
+#ifndef GL_VERSION_4_1
+typedef void (APIENTRYP PFNGLGETFLOATI_VPROC) (GLenum target, GLuint index, GLfloat *data);
+typedef void (APIENTRYP PFNGLGETDOUBLEI_VPROC) (GLenum target, GLuint index, GLdouble *data);
+#endif /* GL_VERSION_4_1 */
+#ifndef GL_VERSION_4_3
+typedef void (APIENTRY  *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+#endif /* GL_VERSION_4_3 */
+#ifndef GL_VERSION_4_5
+#define GL_CLIP_ORIGIN                    0x935C
+typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKI_VPROC) (GLuint xfb, GLenum pname, GLuint index, GLint *param);
+typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKI64_VPROC) (GLuint xfb, GLenum pname, GLuint index, GLint64 *param);
+#endif /* GL_VERSION_4_5 */
+#ifndef GL_ARB_bindless_texture
+typedef khronos_uint64_t GLuint64EXT;
+#endif /* GL_ARB_bindless_texture */
+#ifndef GL_ARB_cl_event
+struct _cl_context;
+struct _cl_event;
+#endif /* GL_ARB_cl_event */
+#ifndef GL_ARB_clip_control
+#define GL_ARB_clip_control 1
+#endif /* GL_ARB_clip_control */
+#ifndef GL_ARB_debug_output
+typedef void (APIENTRY  *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
+#endif /* GL_ARB_debug_output */
+#ifndef GL_EXT_EGL_image_storage
+typedef void *GLeglImageOES;
+#endif /* GL_EXT_EGL_image_storage */
+#ifndef GL_EXT_direct_state_access
+typedef void (APIENTRYP PFNGLGETFLOATI_VEXTPROC) (GLenum pname, GLuint index, GLfloat *params);
+typedef void (APIENTRYP PFNGLGETDOUBLEI_VEXTPROC) (GLenum pname, GLuint index, GLdouble *params);
+typedef void (APIENTRYP PFNGLGETPOINTERI_VEXTPROC) (GLenum pname, GLuint index, void **params);
+typedef void (APIENTRYP PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC) (GLuint vaobj, GLuint index, GLenum pname, GLint *param);
+typedef void (APIENTRYP PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC) (GLuint vaobj, GLuint index, GLenum pname, void **param);
+#endif /* GL_EXT_direct_state_access */
+#ifndef GL_NV_draw_vulkan_image
+typedef void (APIENTRY  *GLVULKANPROCNV)(void);
+#endif /* GL_NV_draw_vulkan_image */
+#ifndef GL_NV_gpu_shader5
+typedef khronos_int64_t GLint64EXT;
+#endif /* GL_NV_gpu_shader5 */
+#ifndef GL_NV_vertex_buffer_unified_memory
+typedef void (APIENTRYP PFNGLGETINTEGERUI64I_VNVPROC) (GLenum value, GLuint index, GLuint64EXT *result);
+#endif /* GL_NV_vertex_buffer_unified_memory */
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+#ifndef GL3W_API
+#define GL3W_API
+#endif
+
+#ifndef __gl_h_
+#define __gl_h_
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GL3W_OK 0
+#define GL3W_ERROR_INIT -1
+#define GL3W_ERROR_LIBRARY_OPEN -2
+#define GL3W_ERROR_OPENGL_VERSION -3
+
+typedef void (*GL3WglProc)(void);
+typedef GL3WglProc (*GL3WGetProcAddressProc)(const char *proc);
+
+/* gl3w api */
+GL3W_API int imgl3wInit(void);
+GL3W_API int imgl3wInit2(GL3WGetProcAddressProc proc);
+GL3W_API int imgl3wIsSupported(int major, int minor);
+GL3W_API GL3WglProc imgl3wGetProcAddress(const char *proc);
+
+/* gl3w internal state */
+union ImGL3WProcs {
+    GL3WglProc ptr[59];
+    struct {
+        PFNGLACTIVETEXTUREPROC            ActiveTexture;
+        PFNGLATTACHSHADERPROC             AttachShader;
+        PFNGLBINDBUFFERPROC               BindBuffer;
+        PFNGLBINDSAMPLERPROC              BindSampler;
+        PFNGLBINDTEXTUREPROC              BindTexture;
+        PFNGLBINDVERTEXARRAYPROC          BindVertexArray;
+        PFNGLBLENDEQUATIONPROC            BlendEquation;
+        PFNGLBLENDEQUATIONSEPARATEPROC    BlendEquationSeparate;
+        PFNGLBLENDFUNCSEPARATEPROC        BlendFuncSeparate;
+        PFNGLBUFFERDATAPROC               BufferData;
+        PFNGLBUFFERSUBDATAPROC            BufferSubData;
+        PFNGLCLEARPROC                    Clear;
+        PFNGLCLEARCOLORPROC               ClearColor;
+        PFNGLCOMPILESHADERPROC            CompileShader;
+        PFNGLCREATEPROGRAMPROC            CreateProgram;
+        PFNGLCREATESHADERPROC             CreateShader;
+        PFNGLDELETEBUFFERSPROC            DeleteBuffers;
+        PFNGLDELETEPROGRAMPROC            DeleteProgram;
+        PFNGLDELETESHADERPROC             DeleteShader;
+        PFNGLDELETETEXTURESPROC           DeleteTextures;
+        PFNGLDELETEVERTEXARRAYSPROC       DeleteVertexArrays;
+        PFNGLDETACHSHADERPROC             DetachShader;
+        PFNGLDISABLEPROC                  Disable;
+        PFNGLDISABLEVERTEXATTRIBARRAYPROC DisableVertexAttribArray;
+        PFNGLDRAWELEMENTSPROC             DrawElements;
+        PFNGLDRAWELEMENTSBASEVERTEXPROC   DrawElementsBaseVertex;
+        PFNGLENABLEPROC                   Enable;
+        PFNGLENABLEVERTEXATTRIBARRAYPROC  EnableVertexAttribArray;
+        PFNGLFLUSHPROC                    Flush;
+        PFNGLGENBUFFERSPROC               GenBuffers;
+        PFNGLGENTEXTURESPROC              GenTextures;
+        PFNGLGENVERTEXARRAYSPROC          GenVertexArrays;
+        PFNGLGETATTRIBLOCATIONPROC        GetAttribLocation;
+        PFNGLGETERRORPROC                 GetError;
+        PFNGLGETINTEGERVPROC              GetIntegerv;
+        PFNGLGETPROGRAMINFOLOGPROC        GetProgramInfoLog;
+        PFNGLGETPROGRAMIVPROC             GetProgramiv;
+        PFNGLGETSHADERINFOLOGPROC         GetShaderInfoLog;
+        PFNGLGETSHADERIVPROC              GetShaderiv;
+        PFNGLGETSTRINGPROC                GetString;
+        PFNGLGETSTRINGIPROC               GetStringi;
+        PFNGLGETUNIFORMLOCATIONPROC       GetUniformLocation;
+        PFNGLGETVERTEXATTRIBPOINTERVPROC  GetVertexAttribPointerv;
+        PFNGLGETVERTEXATTRIBIVPROC        GetVertexAttribiv;
+        PFNGLISENABLEDPROC                IsEnabled;
+        PFNGLISPROGRAMPROC                IsProgram;
+        PFNGLLINKPROGRAMPROC              LinkProgram;
+        PFNGLPIXELSTOREIPROC              PixelStorei;
+        PFNGLPOLYGONMODEPROC              PolygonMode;
+        PFNGLREADPIXELSPROC               ReadPixels;
+        PFNGLSCISSORPROC                  Scissor;
+        PFNGLSHADERSOURCEPROC             ShaderSource;
+        PFNGLTEXIMAGE2DPROC               TexImage2D;
+        PFNGLTEXPARAMETERIPROC            TexParameteri;
+        PFNGLUNIFORM1IPROC                Uniform1i;
+        PFNGLUNIFORMMATRIX4FVPROC         UniformMatrix4fv;
+        PFNGLUSEPROGRAMPROC               UseProgram;
+        PFNGLVERTEXATTRIBPOINTERPROC      VertexAttribPointer;
+        PFNGLVIEWPORTPROC                 Viewport;
+    } gl;
+};
+
+GL3W_API extern union ImGL3WProcs imgl3wProcs;
+
+/* OpenGL functions */
+#define glActiveTexture                   imgl3wProcs.gl.ActiveTexture
+#define glAttachShader                    imgl3wProcs.gl.AttachShader
+#define glBindBuffer                      imgl3wProcs.gl.BindBuffer
+#define glBindSampler                     imgl3wProcs.gl.BindSampler
+#define glBindTexture                     imgl3wProcs.gl.BindTexture
+#define glBindVertexArray                 imgl3wProcs.gl.BindVertexArray
+#define glBlendEquation                   imgl3wProcs.gl.BlendEquation
+#define glBlendEquationSeparate           imgl3wProcs.gl.BlendEquationSeparate
+#define glBlendFuncSeparate               imgl3wProcs.gl.BlendFuncSeparate
+#define glBufferData                      imgl3wProcs.gl.BufferData
+#define glBufferSubData                   imgl3wProcs.gl.BufferSubData
+#define glClear                           imgl3wProcs.gl.Clear
+#define glClearColor                      imgl3wProcs.gl.ClearColor
+#define glCompileShader                   imgl3wProcs.gl.CompileShader
+#define glCreateProgram                   imgl3wProcs.gl.CreateProgram
+#define glCreateShader                    imgl3wProcs.gl.CreateShader
+#define glDeleteBuffers                   imgl3wProcs.gl.DeleteBuffers
+#define glDeleteProgram                   imgl3wProcs.gl.DeleteProgram
+#define glDeleteShader                    imgl3wProcs.gl.DeleteShader
+#define glDeleteTextures                  imgl3wProcs.gl.DeleteTextures
+#define glDeleteVertexArrays              imgl3wProcs.gl.DeleteVertexArrays
+#define glDetachShader                    imgl3wProcs.gl.DetachShader
+#define glDisable                         imgl3wProcs.gl.Disable
+#define glDisableVertexAttribArray        imgl3wProcs.gl.DisableVertexAttribArray
+#define glDrawElements                    imgl3wProcs.gl.DrawElements
+#define glDrawElementsBaseVertex          imgl3wProcs.gl.DrawElementsBaseVertex
+#define glEnable                          imgl3wProcs.gl.Enable
+#define glEnableVertexAttribArray         imgl3wProcs.gl.EnableVertexAttribArray
+#define glFlush                           imgl3wProcs.gl.Flush
+#define glGenBuffers                      imgl3wProcs.gl.GenBuffers
+#define glGenTextures                     imgl3wProcs.gl.GenTextures
+#define glGenVertexArrays                 imgl3wProcs.gl.GenVertexArrays
+#define glGetAttribLocation               imgl3wProcs.gl.GetAttribLocation
+#define glGetError                        imgl3wProcs.gl.GetError
+#define glGetIntegerv                     imgl3wProcs.gl.GetIntegerv
+#define glGetProgramInfoLog               imgl3wProcs.gl.GetProgramInfoLog
+#define glGetProgramiv                    imgl3wProcs.gl.GetProgramiv
+#define glGetShaderInfoLog                imgl3wProcs.gl.GetShaderInfoLog
+#define glGetShaderiv                     imgl3wProcs.gl.GetShaderiv
+#define glGetString                       imgl3wProcs.gl.GetString
+#define glGetStringi                      imgl3wProcs.gl.GetStringi
+#define glGetUniformLocation              imgl3wProcs.gl.GetUniformLocation
+#define glGetVertexAttribPointerv         imgl3wProcs.gl.GetVertexAttribPointerv
+#define glGetVertexAttribiv               imgl3wProcs.gl.GetVertexAttribiv
+#define glIsEnabled                       imgl3wProcs.gl.IsEnabled
+#define glIsProgram                       imgl3wProcs.gl.IsProgram
+#define glLinkProgram                     imgl3wProcs.gl.LinkProgram
+#define glPixelStorei                     imgl3wProcs.gl.PixelStorei
+#define glPolygonMode                     imgl3wProcs.gl.PolygonMode
+#define glReadPixels                      imgl3wProcs.gl.ReadPixels
+#define glScissor                         imgl3wProcs.gl.Scissor
+#define glShaderSource                    imgl3wProcs.gl.ShaderSource
+#define glTexImage2D                      imgl3wProcs.gl.TexImage2D
+#define glTexParameteri                   imgl3wProcs.gl.TexParameteri
+#define glUniform1i                       imgl3wProcs.gl.Uniform1i
+#define glUniformMatrix4fv                imgl3wProcs.gl.UniformMatrix4fv
+#define glUseProgram                      imgl3wProcs.gl.UseProgram
+#define glVertexAttribPointer             imgl3wProcs.gl.VertexAttribPointer
+#define glViewport                        imgl3wProcs.gl.Viewport
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+#ifdef IMGL3W_IMPL
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+
+#define GL3W_ARRAY_SIZE(x)  (sizeof(x) / sizeof((x)[0]))
+
+#if defined(_WIN32)
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN 1
+#endif
+#include <windows.h>
+
+static HMODULE libgl;
+typedef PROC(__stdcall* GL3WglGetProcAddr)(LPCSTR);
+static GL3WglGetProcAddr wgl_get_proc_address;
+
+static int open_libgl(void)
+{
+    libgl = LoadLibraryA("opengl32.dll");
+    if (!libgl)
+        return GL3W_ERROR_LIBRARY_OPEN;
+    wgl_get_proc_address = (GL3WglGetProcAddr)GetProcAddress(libgl, "wglGetProcAddress");
+    return GL3W_OK;
+}
+
+static void close_libgl(void) { FreeLibrary(libgl); }
+static GL3WglProc get_proc(const char *proc)
+{
+    GL3WglProc res;
+    res = (GL3WglProc)wgl_get_proc_address(proc);
+    if (!res)
+        res = (GL3WglProc)GetProcAddress(libgl, proc);
+    return res;
+}
+#elif defined(__APPLE__)
+#include <dlfcn.h>
+
+static void *libgl;
+static int open_libgl(void)
+{
+    libgl = dlopen("/System/Library/Frameworks/OpenGL.framework/OpenGL", RTLD_LAZY | RTLD_LOCAL);
+    if (!libgl)
+        return GL3W_ERROR_LIBRARY_OPEN;
+    return GL3W_OK;
+}
+
+static void close_libgl(void) { dlclose(libgl); }
+
+static GL3WglProc get_proc(const char *proc)
+{
+    GL3WglProc res;
+    *(void **)(&res) = dlsym(libgl, proc);
+    return res;
+}
+#else
+#include <dlfcn.h>
+
+static void* libgl;  // OpenGL library
+static void* libglx;  // GLX library
+static void* libegl;  // EGL library
+static GL3WGetProcAddressProc gl_get_proc_address;
+
+static void close_libgl(void)
+{
+    if (libgl) {
+        dlclose(libgl);
+        libgl = NULL;
+    }
+    if (libegl) {
+        dlclose(libegl);
+        libegl = NULL;
+    }
+    if (libglx) {
+        dlclose(libglx);
+        libglx = NULL;
+    }
+}
+
+static int is_library_loaded(const char* name, void** lib)
+{
+    *lib = dlopen(name, RTLD_LAZY | RTLD_LOCAL | RTLD_NOLOAD);
+    return *lib != NULL;
+}
+
+static int open_libs(void)
+{
+    // On Linux we have two APIs to get process addresses: EGL and GLX.
+    // EGL is supported under both X11 and Wayland, whereas GLX is X11-specific.
+
+    libgl = NULL;
+    libegl = NULL;
+    libglx = NULL;
+
+    // First check what's already loaded, the windowing library might have
+    // already loaded either EGL or GLX and we want to use the same one.
+
+    if (is_library_loaded("libEGL.so.1", &libegl) ||
+        is_library_loaded("libGLX.so.0", &libglx)) {
+        libgl = dlopen("libOpenGL.so.0", RTLD_LAZY | RTLD_LOCAL);
+        if (libgl)
+            return GL3W_OK;
+        else
+            close_libgl();
+    }
+
+    if (is_library_loaded("libGL.so", &libgl))
+        return GL3W_OK;
+    if (is_library_loaded("libGL.so.1", &libgl))
+        return GL3W_OK;
+    if (is_library_loaded("libGL.so.3", &libgl))
+        return GL3W_OK;
+
+    // Neither is already loaded, so we have to load one.  Try EGL first
+    // because it is supported under both X11 and Wayland.
+
+    // Load OpenGL + EGL
+    libgl = dlopen("libOpenGL.so.0", RTLD_LAZY | RTLD_LOCAL);
+    libegl = dlopen("libEGL.so.1", RTLD_LAZY | RTLD_LOCAL);
+    if (libgl && libegl)
+        return GL3W_OK;
+    else
+        close_libgl();
+
+    // Fall back to legacy libGL, which includes GLX
+    // While most systems use libGL.so.1, NetBSD seems to use that libGL.so.3. See https://github.com/ocornut/imgui/issues/6983
+    libgl = dlopen("libGL.so", RTLD_LAZY | RTLD_LOCAL);
+    if (!libgl)
+        libgl = dlopen("libGL.so.1", RTLD_LAZY | RTLD_LOCAL);
+    if (!libgl)
+        libgl = dlopen("libGL.so.3", RTLD_LAZY | RTLD_LOCAL);
+
+    if (libgl)
+        return GL3W_OK;
+
+    return GL3W_ERROR_LIBRARY_OPEN;
+}
+
+static int open_libgl(void)
+{
+    int res = open_libs();
+    if (res)
+        return res;
+
+    if (libegl)
+        *(void**)(&gl_get_proc_address) = dlsym(libegl, "eglGetProcAddress");
+    else if (libglx)
+        *(void**)(&gl_get_proc_address) = dlsym(libglx, "glXGetProcAddressARB");
+    else
+        *(void**)(&gl_get_proc_address) = dlsym(libgl, "glXGetProcAddressARB");
+
+    if (!gl_get_proc_address) {
+        close_libgl();
+        return GL3W_ERROR_LIBRARY_OPEN;
+    }
+
+    return GL3W_OK;
+}
+
+static GL3WglProc get_proc(const char* proc)
+{
+    GL3WglProc res = NULL;
+
+    // Before EGL version 1.5, eglGetProcAddress doesn't support querying core
+    // functions and may return a dummy function if we try, so try to load the
+    // function from the GL library directly first.
+    if (libegl)
+        *(void**)(&res) = dlsym(libgl, proc);
+
+    if (!res)
+        res = gl_get_proc_address(proc);
+
+    if (!libegl && !res)
+        *(void**)(&res) = dlsym(libgl, proc);
+
+    return res;
+}
+#endif
+
+static struct { int major, minor; } version;
+
+static int parse_version(void)
+{
+    if (!glGetIntegerv)
+        return GL3W_ERROR_INIT;
+    glGetIntegerv(GL_MAJOR_VERSION, &version.major);
+    glGetIntegerv(GL_MINOR_VERSION, &version.minor);
+    if (version.major == 0 && version.minor == 0)
+    {
+        // Query GL_VERSION in desktop GL 2.x, the string will start with "<major>.<minor>"
+        if (const char* gl_version = (const char*)glGetString(GL_VERSION))
+            sscanf(gl_version, "%d.%d", &version.major, &version.minor);
+    }
+    if (version.major < 2)
+        return GL3W_ERROR_OPENGL_VERSION;
+    return GL3W_OK;
+}
+
+static void load_procs(GL3WGetProcAddressProc proc);
+
+int imgl3wInit(void)
+{
+    int res = open_libgl();
+    if (res)
+        return res;
+    atexit(close_libgl);
+    return imgl3wInit2(get_proc);
+}
+
+int imgl3wInit2(GL3WGetProcAddressProc proc)
+{
+    load_procs(proc);
+    return parse_version();
+}
+
+int imgl3wIsSupported(int major, int minor)
+{
+    if (major < 2)
+        return 0;
+    if (version.major == major)
+        return version.minor >= minor;
+    return version.major >= major;
+}
+
+GL3WglProc imgl3wGetProcAddress(const char *proc) { return get_proc(proc); }
+
+static const char *proc_names[] = {
+    "glActiveTexture",
+    "glAttachShader",
+    "glBindBuffer",
+    "glBindSampler",
+    "glBindTexture",
+    "glBindVertexArray",
+    "glBlendEquation",
+    "glBlendEquationSeparate",
+    "glBlendFuncSeparate",
+    "glBufferData",
+    "glBufferSubData",
+    "glClear",
+    "glClearColor",
+    "glCompileShader",
+    "glCreateProgram",
+    "glCreateShader",
+    "glDeleteBuffers",
+    "glDeleteProgram",
+    "glDeleteShader",
+    "glDeleteTextures",
+    "glDeleteVertexArrays",
+    "glDetachShader",
+    "glDisable",
+    "glDisableVertexAttribArray",
+    "glDrawElements",
+    "glDrawElementsBaseVertex",
+    "glEnable",
+    "glEnableVertexAttribArray",
+    "glFlush",
+    "glGenBuffers",
+    "glGenTextures",
+    "glGenVertexArrays",
+    "glGetAttribLocation",
+    "glGetError",
+    "glGetIntegerv",
+    "glGetProgramInfoLog",
+    "glGetProgramiv",
+    "glGetShaderInfoLog",
+    "glGetShaderiv",
+    "glGetString",
+    "glGetStringi",
+    "glGetUniformLocation",
+    "glGetVertexAttribPointerv",
+    "glGetVertexAttribiv",
+    "glIsEnabled",
+    "glIsProgram",
+    "glLinkProgram",
+    "glPixelStorei",
+    "glPolygonMode",
+    "glReadPixels",
+    "glScissor",
+    "glShaderSource",
+    "glTexImage2D",
+    "glTexParameteri",
+    "glUniform1i",
+    "glUniformMatrix4fv",
+    "glUseProgram",
+    "glVertexAttribPointer",
+    "glViewport",
+};
+
+GL3W_API union ImGL3WProcs imgl3wProcs;
+
+static void load_procs(GL3WGetProcAddressProc proc)
+{
+    size_t i;
+    for (i = 0; i < GL3W_ARRAY_SIZE(proc_names); i++)
+        imgl3wProcs.ptr[i] = proc(proc_names[i]);
+}
+
+#ifdef __cplusplus
+}
+#endif
+#endif
--- a/TSE_OpenGlImpl/src/shader/Shader.cpp
+++ b/TSE_OpenGlImpl/src/shader/Shader.cpp
@@ -0,0 +1,143 @@
+#include "GL/gl3w.h"
+#include "GL/gl.h"
+#include "Shader.hpp"
+#include "Debug.hpp"
+
+TSE::uint TSE::OpenGL::Shader::activeProgramID = 0;
+
+void TSE::OpenGL::Shader::Bind() const
+{
+    Enable(true);
+}
+
+void TSE::OpenGL::Shader::Unbind() const
+{
+    Disable(true);
+}
+
+void TSE::OpenGL::Shader::Enable(bool notify) const
+{
+    activeProgramID = programID;
+    glUseProgram(programID);
+    if(notify) OnEnable();
+}
+
+void TSE::OpenGL::Shader::Disable(bool notify) const
+{
+    activeProgramID = 0;
+    glUseProgram(0);
+    if(notify) OnDisable();
+}
+
+void TSE::OpenGL::Shader::Flush()
+{
+    OnFlush();
+}
+
+void TSE::OpenGL::Shader::DrawCall(int indexCount)
+{
+    OnDrawCall(indexCount);
+}
+
+void TSE::OpenGL::Shader::PostDraw()
+{
+    OnPostDraw();
+}
+
+void TSE::OpenGL::Shader::Submit(const Transformable &t, float *&target, TransformationStack &stack, void (*restartDrawcall)(IRenderer &), IRenderer &rnd)
+{
+    OnSubmit(t, target, stack, restartDrawcall, rnd);
+}
+
+bool TSE::OpenGL::Shader::IsEnabled() const
+{
+    return programID == activeProgramID;
+}
+
+int TSE::OpenGL::Shader::packageSize()
+{
+    return PackageSize;
+}
+
+TSE::OpenGL::Shader::Shader(const std::vector<std::unique_ptr<ShaderPart>> &parts)
+{
+    programID = glCreateProgram();
+
+    for (const auto& part : parts) {
+        glAttachShader(programID, part->shaderPartID);
+    }
+
+    glLinkProgram(programID);
+
+    int success;
+
+    glGetProgramiv(programID, GL_LINK_STATUS, &success);
+
+    if(!success)
+    {
+        char log[512];
+        glGetProgramInfoLog(programID, 512, nullptr, log);
+        TSE_ERROR(log);
+    }
+
+    for (const auto& part : parts) {
+        glDetachShader(programID, part->shaderPartID);
+    }
+}
+
+TSE::OpenGL::Shader::~Shader()
+{
+    glDeleteProgram(programID);
+}
+
+int TSE::OpenGL::Shader::GetUniformLocation(const char *name)
+{
+    auto it = uniformLocations.find(name);
+    if (it != uniformLocations.end()) return it->second;
+
+    int loc = glGetUniformLocation(programID, name);
+    uniformLocations[name] = loc;
+    return loc;
+}
+
+void TSE::OpenGL::Shader::SetUniform(const char *name, int value)
+{
+    glUniform1i(GetUniformLocation(name), value);
+}
+
+void TSE::OpenGL::Shader::SetUniform(const char *name, const int *value, const int count)
+{
+    glUniform1iv(GetUniformLocation(name), count, value);
+}
+
+void TSE::OpenGL::Shader::SetUniform(const char *name, const Matrix4x4 *value)
+{
+    float colmbMajor[16];
+    value->ToArrayColumnMajor(colmbMajor);
+    glUniformMatrix4fv(GetUniformLocation(name),1, false, colmbMajor);
+}
+
+void TSE::OpenGL::Shader::SetUniform(const char *name, float value)
+{
+    glUniform1f(GetUniformLocation(name), value);
+}
+
+void TSE::OpenGL::Shader::SetUniform(const char *name, const float *value, const int count)
+{
+    glUniform1fv(GetUniformLocation(name), count, value);
+}
+
+void TSE::OpenGL::Shader::SetUniform(const char *name, const Vector2 *value)
+{
+    glUniform2f(GetUniformLocation(name), value->x, value->y);
+}
+
+void TSE::OpenGL::Shader::SetUniform(const char *name, const Vector3 *value)
+{
+    glUniform3f(GetUniformLocation(name), value->x, value->y, value->z);
+}
+
+void TSE::OpenGL::Shader::SetUniform(const char *name, const Vector4 *value)
+{
+    glUniform4f(GetUniformLocation(name), value->x, value->y, value->z, value->w);
+}
--- a/TSE_OpenGlImpl/src/shader/Shader.hpp
+++ b/TSE_OpenGlImpl/src/shader/Shader.hpp
@@ -0,0 +1,57 @@
+#pragma once
+
+#include "ShaderPart.hpp"
+#include <unordered_map>
+#include <vector>
+#include "Types.hpp"
+#include "interfaces/IShader.hpp"
+#include "elements/Transformable.hpp"
+#include "TransformationStack.hpp"
+#include "interfaces/IRenderer.hpp"
+
+namespace TSE::OpenGL
+{
+    class Shader : public IShader
+    {
+    private:
+        static uint activeProgramID;
+        uint programID;
+        mutable std::unordered_map<std::string, int> uniformLocations;
+
+    protected:
+        int PackageSize;
+        virtual void OnEnable() const {};
+        virtual void OnDisable() const {};
+        virtual void OnFlush() {};
+        virtual void OnDrawCall(int indexCount) {};
+        virtual void OnPostDraw() {};
+        virtual void OnSubmit(const Transformable& t, float*& target, TransformationStack& stack, void (*restartDrawcall)(IRenderer&), IRenderer& rnd) {};
+
+    public:
+        void Bind() const override;
+        void Unbind() const override;
+        void Enable(bool notify = false) const;
+        void Disable(bool notify = false) const;
+        void Flush();
+        void DrawCall(int indexCount);
+        void PostDraw();
+        void Submit(const Transformable& t, float*& target, TransformationStack& stack, void (*restartDrawcall)(IRenderer&), IRenderer& rnd);
+        bool IsEnabled() const;
+        int packageSize();
+        Shader(const std::vector<std::unique_ptr<ShaderPart>>& parts);
+        virtual ~Shader();
+
+    protected:
+        int GetUniformLocation(const char* name);
+
+    public:
+        void SetUniform(const char* name, int value) override;
+        void SetUniform(const char* name, const int* value, const int count) override;
+        void SetUniform(const char* name, const Matrix4x4* value) override;
+        void SetUniform(const char* name, float value) override;
+        void SetUniform(const char* name, const float* value, const int count) override;
+        void SetUniform(const char* name, const Vector2* value) override;
+        void SetUniform(const char* name, const Vector3* value) override;
+        void SetUniform(const char* name, const Vector4* value) override;
+    };
+} // namespace TSE::OpenGL
--- a/TSE_OpenGlImpl/src/shader/ShaderPart.cpp
+++ b/TSE_OpenGlImpl/src/shader/ShaderPart.cpp
@@ -0,0 +1,49 @@
+#include "GL/gl3w.h"
+#include "GL/gl.h"
+#include "ShaderPart.hpp"
+
+#include "Debug.hpp"
+#include <fstream>
+#include "PathHelper.hpp"
+
+void TSE::OpenGL::ShaderPart::Init(const string &str, int shaderType)
+{
+    shaderPartID = glCreateShader(shaderType);
+    const char * cstr = str.c_str();
+    int length = str.length();
+    glShaderSource(shaderPartID, 1, &cstr, &length);
+    glCompileShader(shaderPartID);
+
+    int success;
+    glGetShaderiv(shaderPartID, GL_COMPILE_STATUS, &success);
+
+    if(success == GL_FALSE)
+    {
+        int errorLength = 255;
+        char* log = new char[errorLength];
+        glGetShaderInfoLog(shaderPartID, errorLength, &errorLength, log);
+
+        TSE_ERROR(log);
+    }
+}
+
+TSE::OpenGL::ShaderPart::~ShaderPart()
+{
+    glDeleteShader(shaderPartID);
+}
+
+std::unique_ptr<TSE::OpenGL::ShaderPart> TSE::OpenGL::ShaderPart::LoadFromString(const std::string &str, int shaderType)
+{
+    if (str.length() == 0) throw;
+    std::unique_ptr<ShaderPart> shader = std::make_unique<ShaderPart>();
+    shader->Init(str, shaderType);
+    return shader;
+}
+
+std::unique_ptr<TSE::OpenGL::ShaderPart> TSE::OpenGL::ShaderPart::LoadFromPath(const std::string &path, int shaderType)
+{
+    std::ifstream stream;
+    OpenFileReading(stream, path);
+    std::string filecontent((std::istreambuf_iterator<char>(stream)), std::istreambuf_iterator<char>());
+    return LoadFromString(filecontent, shaderType);
+}
--- a/TSE_OpenGlImpl/src/shader/ShaderPart.hpp
+++ b/TSE_OpenGlImpl/src/shader/ShaderPart.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "Types.hpp"
+#include <memory>
+
+namespace TSE::OpenGL
+{
+    class ShaderPart
+    {
+    public:
+        uint shaderPartID = 0;
+
+        ShaderPart() = default;
+
+    private:
+        void Init(const string& str, int shaderType);
+
+    public:
+        ~ShaderPart();
+        static std::unique_ptr<ShaderPart> LoadFromString(const std::string& str, int shaderType);
+        static std::unique_ptr<ShaderPart> LoadFromPath(const std::string& path, int shaderType);
+    };
+} // namespace OpenGL
--- a/TSE_OpenGlImpl/src/shader/basicOrderedSpriteSetShader.cpp
+++ b/TSE_OpenGlImpl/src/shader/basicOrderedSpriteSetShader.cpp
@@ -0,0 +1,238 @@
+#include "basicOrderedSpriteSetShader.hpp"
+#include "BehaviourScripts/Renderable.hpp"
+#include "BehaviourScripts/OrdererSpriteSet.hpp"
+#include "Color.hpp"
+#include "basicOrderedSpriteSetShaderGLSL.hpp"
+
+using namespace TSE;
+using namespace TSE::OpenGL;
+
+#define SHADER_MESH_INDEX 0
+#define SHADER_POS_INDEX 1
+#define SHADER_LAYER_HEIGHT_INDEX 2
+#define SHADER_SPRITE_INDEX 3
+#define SHADER_NORMAL_INDEX 4
+#define SHADER_SCALE_INDEX 5
+
+#define SHADER_PACKAGE_SIZE sizeof(float) * (3 + 1 + 1 + 1 + 2)
+
+
+TSE::OpenGL::BasicOrderedSpriteSetShader* BasicOrderedSpriteSetShader::instance = nullptr;
+
+TSE::OpenGL::BasicOrderedSpriteSetShader *TSE::OpenGL::BasicOrderedSpriteSetShader::Instance()
+{
+    return instance;
+}
+
+void TSE::OpenGL::BasicOrderedSpriteSetShader::Destroy()
+{
+    if(instance != nullptr)
+    delete instance;
+    instance = nullptr;
+}
+
+void TSE::OpenGL::BasicOrderedSpriteSetShader::Init(float width, float height)
+{
+    std::vector<std::unique_ptr<ShaderPart>> parts;
+    parts.push_back(ShaderPart::LoadFromString(vertOrderedSet, GL_VERTEX_SHADER));
+    parts.push_back(ShaderPart::LoadFromString(fragOrderedSet, GL_FRAGMENT_SHADER));
+    instance = new BasicOrderedSpriteSetShader(std::move(parts));
+
+    instance->Enable();
+    int texIDs[] = { 0 };
+    instance->SetUniform("atlas", 0);
+    instance->Disable();
+}
+
+TSE::OpenGL::BasicOrderedSpriteSetShader::BasicOrderedSpriteSetShader(std::vector<std::unique_ptr<ShaderPart>> &&parts) : Shader(parts)
+{
+    PackageSize = SHADER_PACKAGE_SIZE;
+}
+
+TSE::OpenGL::BasicOrderedSpriteSetShader::~BasicOrderedSpriteSetShader()
+{
+    if (meshVBO) glDeleteBuffers(1, &meshVBO);
+    if (meshIBO) glDeleteBuffers(1, &meshIBO);
+}
+
+void TSE::OpenGL::BasicOrderedSpriteSetShader::SetMesh(const void *verts, int vertCount, int stride, int floatCountPerVertex, int posOffsetBytes, GLenum primitive, const void *indices, int indexCount, GLenum indexType)
+{
+    GLint prevVAO = 0, prevArrayBuffer = 0, prevElementBuffer = 0;
+    glGetIntegerv(GL_VERTEX_ARRAY_BINDING,         &prevVAO);
+    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &prevArrayBuffer);
+    glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &prevElementBuffer);
+
+    if (!meshVBO) glGenBuffers(1, &meshVBO);
+    glBindBuffer(GL_ARRAY_BUFFER, meshVBO);
+    glBufferData(GL_ARRAY_BUFFER, vertCount * stride, verts, GL_STATIC_DRAW);
+
+    if (indices && indexCount > 0)
+    {
+        if (!meshIBO) glGenBuffers(1, &meshIBO);
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, meshIBO);
+        GLsizeiptr idxSize =
+            (indexType == GL_UNSIGNED_INT  ? 4 :
+             indexType == GL_UNSIGNED_SHORT? 2 : 1) * indexCount;
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, idxSize, indices, GL_STATIC_DRAW);
+        meshIndexCount = indexCount;
+        meshIndexType  = indexType;
+    }
+    else
+    {
+        // Kein Index-Buffer
+        if (meshIBO) { glDeleteBuffers(1, &meshIBO); meshIBO = 0; }
+        meshIndexCount  = 0;
+    }
+
+    meshVertexCount = vertCount;
+    meshStride      = stride;
+    meshPosOffset   = posOffsetBytes;
+    meshPosSize     = floatCountPerVertex;
+    meshPrimitive   = primitive;
+    meshReady       = true;
+
+    glBindBuffer(GL_ARRAY_BUFFER, prevArrayBuffer);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, prevElementBuffer);
+    glBindVertexArray(prevVAO);
+}
+
+void TSE::OpenGL::BasicOrderedSpriteSetShader::OnEnable() const
+{
+    if (!meshReady)
+    {
+        // Fallback: unit-Quad als TRIANGLE_FAN (4 Vertices, 2D Positionen)
+        const float quad[8] = { -0.5f,0,  0.5f,0,  0.5f,1,  -0.5f,1 };
+        const_cast<BasicOrderedSpriteSetShader*>(this)->SetMesh(
+            quad, 4, sizeof(float)*2, 2, 0, GL_TRIANGLE_FAN
+        );
+    }
+
+    GLint prevArrayBuffer = 0;
+    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &prevArrayBuffer);
+
+    glBindBuffer(GL_ARRAY_BUFFER, meshVBO);
+    glEnableVertexAttribArray(SHADER_MESH_INDEX); // LOC_QUAD/pos
+    glVertexAttribPointer(SHADER_MESH_INDEX, meshPosSize, GL_FLOAT, GL_FALSE, meshStride, (void*)meshPosOffset);
+    glVertexAttribDivisor(SHADER_MESH_INDEX, 0);  // per-vertex (Mesh)
+
+    glBindBuffer(GL_ARRAY_BUFFER, prevArrayBuffer);
+
+    glEnableVertexAttribArray(SHADER_POS_INDEX);
+    glVertexAttribPointer(SHADER_POS_INDEX, 3, GL_FLOAT, GL_FALSE, PackageSize, (void*)0);
+    glVertexAttribDivisor(SHADER_POS_INDEX, 1);
+
+    glEnableVertexAttribArray(SHADER_LAYER_HEIGHT_INDEX);
+    glVertexAttribPointer(SHADER_LAYER_HEIGHT_INDEX, 1, GL_FLOAT, GL_FALSE, PackageSize, (void*)(sizeof(float)*3));
+    glVertexAttribDivisor(SHADER_LAYER_HEIGHT_INDEX, 1);
+
+    glEnableVertexAttribArray(SHADER_SPRITE_INDEX);
+    glVertexAttribPointer(SHADER_SPRITE_INDEX, 1, GL_FLOAT, GL_FALSE, PackageSize, (void*)(sizeof(float)*4));
+    glVertexAttribDivisor(SHADER_SPRITE_INDEX, 1);
+
+    glEnableVertexAttribArray(SHADER_NORMAL_INDEX);
+    glVertexAttribPointer(SHADER_NORMAL_INDEX, 1, GL_FLOAT, GL_FALSE, PackageSize, (void*)(sizeof(float)*5));
+    glVertexAttribDivisor(SHADER_NORMAL_INDEX, 1);
+
+    glEnableVertexAttribArray(SHADER_SCALE_INDEX);
+    glVertexAttribPointer(SHADER_SCALE_INDEX, 2, GL_FLOAT, GL_FALSE, PackageSize, (void*)(sizeof(float)*6));
+    glVertexAttribDivisor(SHADER_SCALE_INDEX, 1);
+}
+
+void TSE::OpenGL::BasicOrderedSpriteSetShader::OnDisable() const
+{
+    glDisableVertexAttribArray(SHADER_MESH_INDEX);
+    glDisableVertexAttribArray(SHADER_POS_INDEX);
+    glDisableVertexAttribArray(SHADER_LAYER_HEIGHT_INDEX);
+    glDisableVertexAttribArray(SHADER_SPRITE_INDEX);
+    glDisableVertexAttribArray(SHADER_NORMAL_INDEX);
+    glDisableVertexAttribArray(SHADER_SCALE_INDEX);
+}
+
+void TSE::OpenGL::BasicOrderedSpriteSetShader::OnFlush()
+{
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, TextureID);
+    glDisable(GL_BLEND);
+}
+
+void TSE::OpenGL::BasicOrderedSpriteSetShader::OnDrawCall(int indexCount)
+{
+    if (instanceCount <= 0) return;
+    SetUniform("spriteCount", &SpriteCount);
+
+    GLint prevElementBuffer = 0;
+    glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &prevElementBuffer);
+
+    if (meshIBO && meshIndexCount > 0)
+    {
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, meshIBO);
+        glDrawElementsInstanced(meshPrimitive, meshIndexCount, meshIndexType, (void*)0, instanceCount);
+    }
+    else
+    {
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+        glDrawArraysInstanced(meshPrimitive, 0, meshVertexCount, instanceCount);
+    }
+
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, (GLuint)prevElementBuffer);
+}
+
+void TSE::OpenGL::BasicOrderedSpriteSetShader::OnPostDraw()
+{
+    glEnable(GL_BLEND);
+    instanceCount = 0;
+}
+
+void TSE::OpenGL::BasicOrderedSpriteSetShader::OnSubmit(const Transformable &t, float *&target, TransformationStack &stack, void (*restartDrawcall)(IRenderer &), IRenderer &rnd)
+{
+    auto* r = dynamic_cast<Renderable*>(t.GetBehaviourScript(RENDERABLE));
+    if (!r) return;
+
+    auto* tm = dynamic_cast<OrdererSpriteSet*>(t.GetBehaviourScript(ORDERERSPRITESET));
+    if (!tm) return;
+
+    auto tileSet = tm->GetTileSet();
+    TextureID = tileSet->GetTextueID();
+    SpriteCount = tileSet->GetCount();
+
+    const std::vector<Vector2> orderedChunks = *tm->GetChunkPositionsInOrder();
+
+    Matrix4x4 matr = t.GetLocalMatrix();
+
+    stack.Push(matr);
+
+    for(auto chunkPos : orderedChunks)
+    {
+        auto chunk = tm->GetChunk(chunkPos);
+        const int spriteCount = chunk->GetSpriteCount();
+        const std::vector<Vector3> spritePositions = *chunk->GetOrderedPositions();
+        const std::vector<Vector2i> spriteIds = *chunk->GetOrderedSpriteIds();
+        const std::vector<Vector2> spriteScales = *chunk->GetOrderedScales();
+        int chunkSize = chunk->GetChunksize();
+
+        for (int i = 0; i < spriteCount; i++)
+        {
+            Matrix4x4 mat = Matrix4x4::ToTranslationMatrix(chunkPos + spritePositions[i].ToVector2()) * Matrix4x4::ToRotationMatrix(Quaternion()) * Matrix4x4::ToScaleMatrix({1,1,1});
+            stack.Push(mat);
+            Vector3 pos = stack.Top() * Vector3(0,0,0);
+
+            *target++ = pos.x;
+            *target++ = pos.y;
+            *target++ = pos.z;
+            *target++ = spritePositions[i].z;
+            *target++ = spriteIds[i].x;
+            *target++ = spriteIds[i].y;
+            *target++ = spriteScales[i].x;
+            *target++ = spriteScales[i].y;
+
+            ++instanceCount;
+            stack.Pop();
+
+            if(instanceCount >= 16000)
+                restartDrawcall(rnd);
+        }
+    }
+
+    stack.Pop();
+    restartDrawcall(rnd);
+}
--- a/TSE_OpenGlImpl/src/shader/basicOrderedSpriteSetShader.hpp
+++ b/TSE_OpenGlImpl/src/shader/basicOrderedSpriteSetShader.hpp
@@ -0,0 +1,44 @@
+#pragma once
+
+#include "GL/gl3w.h"
+#include "GL/gl.h"
+#include "Shader.hpp"
+#include "Types.hpp"
+
+namespace TSE::OpenGL
+{
+    class BasicOrderedSpriteSetShader : public Shader
+    {
+    private:
+        static BasicOrderedSpriteSetShader* instance;
+        mutable bool meshReady = false;
+        GLuint meshVBO = 0;
+        GLuint meshIBO = 0;
+        GLsizei meshVertexCount = 0;   // für DrawArraysInstanced
+        GLsizei meshIndexCount  = 0;   // für DrawElementsInstanced
+        GLenum  meshPrimitive   = GL_TRIANGLES;
+        GLenum meshIndexType = GL_UNSIGNED_SHORT;
+        int instanceCount = 0; // eigener Instanzzähler
+        GLint   meshPosSize   = 2;         // 2D (Billboard-Formen), für 3D Meshes: 3
+        GLsizei meshStride    = sizeof(float) * 2;
+        size_t  meshPosOffset = 0;
+        GLuint TextureID;
+        Vector2 SpriteCount;
+
+    public:
+        static BasicOrderedSpriteSetShader* Instance();
+        static void Destroy();
+        static void Init(float width, float height);
+        BasicOrderedSpriteSetShader(std::vector<std::unique_ptr<ShaderPart>>&& parts);
+        ~BasicOrderedSpriteSetShader();
+        void SetMesh(const void* verts, int vertCount, int stride, int floatCountPerVertex, int posOffsetBytes, GLenum primitive, const void* indices = nullptr, int indexCount = 0, GLenum indexType = GL_UNSIGNED_SHORT);
+
+    protected:
+        void OnEnable() const override;
+        void OnDisable() const override;
+        void OnFlush() override;
+        void OnDrawCall(int indexCount) override;
+        void OnPostDraw() override;
+        void OnSubmit(const Transformable& t, float*& target, TransformationStack& stack, void (*restartDrawcall)(IRenderer&), IRenderer& rnd) override;
+    };
+} // namespace TSE::GLFW
--- a/TSE_OpenGlImpl/src/shader/basicOrderedSpriteSetShaderGLSL.hpp
+++ b/TSE_OpenGlImpl/src/shader/basicOrderedSpriteSetShaderGLSL.hpp
@@ -0,0 +1,95 @@
+#pragma once
+
+inline const char* vertOrderedSet = R"(
+    #version 330 core
+
+    layout(location = 0) in vec2 aPos;
+
+    layout(location = 1) in vec3 iTilePos;
+    layout(location = 2) in float height;
+    layout(location = 3) in float iSpriteId;
+    layout(location = 4) in float iNormalId;
+    layout(location = 5) in vec2 spriteScale;
+
+    uniform mat4 prMatrix;
+    uniform mat4 camMatrix;
+
+    out vec2 vUV;
+    flat out int vSpriteId;
+    flat out int vNormalId;
+    flat out float vTileNdcY;
+    flat out float layerHeight;
+
+    void main()
+    {
+        vec3 local = vec3(aPos.x, aPos.y, 0);
+        vec2 baseUV = aPos + vec2(0.5, 0);
+        vec3 tileSize = vec3(spriteScale.x, spriteScale.y, 1);
+
+        vec3 worldPos = (iTilePos * tileSize) + (local * tileSize);
+
+        vec4 clip = prMatrix * camMatrix * vec4(worldPos, 1.0);
+        gl_Position = clip;
+
+        vUV = baseUV;
+        vSpriteId = int(iSpriteId + 0.5);
+        vNormalId = int(iNormalId + 0.5);
+        layerHeight = height;
+
+        vec3 localbottom = vec3(0.5, 0, 0);
+        vec3 worldPosBottom = (iTilePos * tileSize) + (localbottom * tileSize);
+        vec4 clipbottom = prMatrix * camMatrix * vec4(worldPosBottom, 1.0);
+        float ndcY = clipbottom.y / clipbottom.w;
+        vTileNdcY = ndcY * 0.5 + 0.5;
+    }
+)";
+
+inline const char* fragOrderedSet = R"(
+    #version 330 core
+
+    in vec2 vUV;
+    flat in int vSpriteId;
+    flat in int vNormalId;
+    flat in float vTileNdcY;
+    flat in float layerHeight;
+
+    uniform sampler2D atlas;
+    uniform vec2 spriteCount;
+
+    layout(location = 0) out vec4 FragColor;
+    layout(location = 1) out vec4 FragHeight;
+    layout(location = 2) out vec4 FragDepth;
+
+    void main()
+    {
+        float t = (vTileNdcY + 1.0) * 0.5 *0.8;
+        FragDepth = vec4(t, 0, 0, 1.0);
+
+        vec2 tileUVSize = 1.0 / spriteCount;
+
+        int cols = int(spriteCount.x);
+        int sx = vSpriteId % cols;
+        int sy = vSpriteId / cols;
+        
+        vec2 atlasOffset = vec2(float(sx), float(sy)) * tileUVSize;
+        vec2 atlasUV = atlasOffset + (vUV * tileUVSize);
+        vec4 c = texture(atlas, atlasUV);
+        if (c.a < 0.01) discard;
+        float colorScaler = 1 - ((layerHeight - 1) * -1) * 0.3;
+        c = vec4(c.x * colorScaler,c.y * colorScaler,c.z * colorScaler,c.w);
+        
+        FragColor = c;
+
+        if(vNormalId != -1)
+        {
+            int sx2 = vNormalId % cols;
+            int sy2 = vNormalId / cols;
+            vec2 atlasOffsetNormal = vec2(float(sx2), float(sy2)) * tileUVSize;
+            vec2 atlasUVNormal = atlasOffsetNormal + (vUV * tileUVSize);
+            vec4 cNormal = texture(atlas, atlasUVNormal);
+            cNormal.w = layerHeight;
+            
+            FragHeight = cNormal;
+        }
+    }
+)";
--- a/TSE_OpenGlImpl/src/shader/basicParticleShader.cpp
+++ b/TSE_OpenGlImpl/src/shader/basicParticleShader.cpp
@@ -0,0 +1,190 @@
+#include "basicParticleShader.hpp"
+#include "basicParticleShaderGLSL.hpp"
+#include "BehaviourScripts/Renderable.hpp"
+#include "BehaviourScripts/ParticleSystem.hpp"
+#include "Color.hpp"
+
+#define SHADER_MESH_INDEX 0
+#define SHADER_POS_INDEX 1
+#define SHADER_SIZE_INDEX 2
+#define SHADER_ROT_INDEX 3
+#define SHADER_COLOR_INDEX 4
+
+#define SHADER_PACKAGE_SIZE sizeof(float) * (3 + 1 + 1 + 4)
+
+TSE::OpenGL::BasicParticleShader* TSE::OpenGL::BasicParticleShader::instance = nullptr;
+
+TSE::OpenGL::BasicParticleShader *TSE::OpenGL::BasicParticleShader::Instance()
+{
+    return instance;
+}
+
+void TSE::OpenGL::BasicParticleShader::Destroy()
+{
+    if(instance != nullptr)
+    delete instance;
+    instance = nullptr;
+}
+
+void TSE::OpenGL::BasicParticleShader::Init(float width, float height)
+{
+    std::vector<std::unique_ptr<ShaderPart>> parts;
+    parts.push_back(ShaderPart::LoadFromString(vertPart, GL_VERTEX_SHADER));
+    parts.push_back(ShaderPart::LoadFromString(fragPart, GL_FRAGMENT_SHADER));
+    instance = new BasicParticleShader(std::move(parts));
+}
+
+TSE::OpenGL::BasicParticleShader::BasicParticleShader(std::vector<std::unique_ptr<ShaderPart>> &&parts) : Shader(parts)
+{
+    PackageSize = SHADER_PACKAGE_SIZE;
+}
+
+TSE::OpenGL::BasicParticleShader::~BasicParticleShader()
+{
+    if (meshVBO) glDeleteBuffers(1, &meshVBO);
+    if (meshIBO) glDeleteBuffers(1, &meshIBO);
+}
+
+void TSE::OpenGL::BasicParticleShader::SetMesh(const void *verts, int vertCount, int stride, int floatCountPerVertex, int posOffsetBytes, GLenum primitive, const void *indices, int indexCount, GLenum indexType)
+{
+    GLint prevVAO = 0, prevArrayBuffer = 0, prevElementBuffer = 0;
+    glGetIntegerv(GL_VERTEX_ARRAY_BINDING,         &prevVAO);
+    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &prevArrayBuffer);
+    glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &prevElementBuffer);
+
+    if (!meshVBO) glGenBuffers(1, &meshVBO);
+    glBindBuffer(GL_ARRAY_BUFFER, meshVBO);
+    glBufferData(GL_ARRAY_BUFFER, vertCount * stride, verts, GL_STATIC_DRAW);
+
+    if (indices && indexCount > 0)
+    {
+        if (!meshIBO) glGenBuffers(1, &meshIBO);
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, meshIBO);
+        GLsizeiptr idxSize =
+            (indexType == GL_UNSIGNED_INT  ? 4 :
+             indexType == GL_UNSIGNED_SHORT? 2 : 1) * indexCount;
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, idxSize, indices, GL_STATIC_DRAW);
+        meshIndexCount = indexCount;
+        meshIndexType  = indexType;
+    }
+    else
+    {
+        // Kein Index-Buffer
+        if (meshIBO) { glDeleteBuffers(1, &meshIBO); meshIBO = 0; }
+        meshIndexCount  = 0;
+    }
+
+    meshVertexCount = vertCount;
+    meshStride      = stride;
+    meshPosOffset   = posOffsetBytes;
+    meshPosSize     = floatCountPerVertex;
+    meshPrimitive   = primitive;
+    meshReady       = true;
+
+    glBindBuffer(GL_ARRAY_BUFFER, prevArrayBuffer);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, prevElementBuffer);
+    glBindVertexArray(prevVAO);
+}
+
+void TSE::OpenGL::BasicParticleShader::OnEnable() const
+{
+    if (!meshReady)
+    {
+        // Fallback: unit-Quad als TRIANGLE_FAN (4 Vertices, 2D Positionen)
+        const float quad[8] = { -0.5f,-0.5f,  0.5f,-0.5f,  0.5f,0.5f,  -0.5f,0.5f };
+        const_cast<BasicParticleShader*>(this)->SetMesh(
+            quad, 4, sizeof(float)*2, 2, 0, GL_TRIANGLE_FAN
+        );
+    }
+
+    GLint prevArrayBuffer = 0;
+    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &prevArrayBuffer);
+
+    glBindBuffer(GL_ARRAY_BUFFER, meshVBO);
+    glEnableVertexAttribArray(SHADER_MESH_INDEX); // LOC_QUAD/pos
+    glVertexAttribPointer(SHADER_MESH_INDEX, meshPosSize, GL_FLOAT, GL_FALSE, meshStride, (void*)meshPosOffset);
+    glVertexAttribDivisor(SHADER_MESH_INDEX, 0);  // per-vertex (Mesh)
+
+    glBindBuffer(GL_ARRAY_BUFFER, prevArrayBuffer);
+
+    //   layout 1: position (vec3)
+    glEnableVertexAttribArray(SHADER_POS_INDEX);
+    glVertexAttribPointer(SHADER_POS_INDEX, 3, GL_FLOAT, GL_FALSE, PackageSize, (void*)0);
+    glVertexAttribDivisor(SHADER_POS_INDEX, 1);
+
+    //   layout 2: size (float)
+    glEnableVertexAttribArray(SHADER_SIZE_INDEX);
+    glVertexAttribPointer(SHADER_SIZE_INDEX, 1, GL_FLOAT, GL_FALSE, PackageSize, (void*)(sizeof(float)*3));
+    glVertexAttribDivisor(SHADER_SIZE_INDEX, 1);
+
+    //   layout 3: rotationRad (float)
+    glEnableVertexAttribArray(SHADER_ROT_INDEX);
+    glVertexAttribPointer(SHADER_ROT_INDEX, 1, GL_FLOAT, GL_FALSE, PackageSize, (void*)(sizeof(float)*4));
+    glVertexAttribDivisor(SHADER_ROT_INDEX, 1);
+
+    //   layout 4: color (vec4)
+    glEnableVertexAttribArray(SHADER_COLOR_INDEX);
+    glVertexAttribPointer(SHADER_COLOR_INDEX, 4, GL_FLOAT, GL_FALSE, PackageSize, (void*)(sizeof(float)*5));
+    glVertexAttribDivisor(SHADER_COLOR_INDEX, 1);
+}
+
+void TSE::OpenGL::BasicParticleShader::OnDisable() const
+{
+    glDisableVertexAttribArray(SHADER_MESH_INDEX);
+    glDisableVertexAttribArray(SHADER_POS_INDEX);
+    glDisableVertexAttribArray(SHADER_SIZE_INDEX);
+    glDisableVertexAttribArray(SHADER_ROT_INDEX);
+    glDisableVertexAttribArray(SHADER_COLOR_INDEX);
+}
+
+void TSE::OpenGL::BasicParticleShader::OnFlush()
+{
+}
+
+void TSE::OpenGL::BasicParticleShader::OnDrawCall(int indexCount)
+{
+    if (instanceCount <= 0) return;
+
+    GLint prevElementBuffer = 0;
+    glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &prevElementBuffer);
+
+    if (meshIBO && meshIndexCount > 0)
+    {
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, meshIBO);
+        glDrawElementsInstanced(meshPrimitive, meshIndexCount, meshIndexType, (void*)0, instanceCount);
+    }
+    else
+    {
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+        glDrawArraysInstanced(meshPrimitive, 0, meshVertexCount, instanceCount);
+    }
+
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, (GLuint)prevElementBuffer);
+    instanceCount = 0;
+}
+
+void TSE::OpenGL::BasicParticleShader::OnSubmit(const Transformable &t, float *&target, TransformationStack &stack, void (*restartDrawcall)(IRenderer &), IRenderer &rnd)
+{
+    auto* r = dynamic_cast<Renderable*>(t.GetBehaviourScript(RENDERABLE));
+    if (!r) return;
+
+    auto* ps = dynamic_cast<ParticleSystem*>(t.GetBehaviourScript(PARTICLESYSTEM));
+    if (!ps) return;
+
+    const std::vector<TSE::Particle*>& particles = ps->GetParticles();
+
+    for(auto particle : particles)
+    {
+        *target++ = particle->position.x;
+        *target++ = particle->position.y;
+        *target++ = particle->position.z;
+        *target++ = particle->size;
+        *target++ = particle->rotationRad;
+        *target++ = particle->color.r;
+        *target++ = particle->color.g;
+        *target++ = particle->color.b;
+        *target++ = particle->color.a;
+
+        ++instanceCount;
+    }
+}
--- a/TSE_OpenGlImpl/src/shader/basicParticleShader.hpp
+++ b/TSE_OpenGlImpl/src/shader/basicParticleShader.hpp
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "GL/gl3w.h"
+#include "GL/gl.h"
+#include "Shader.hpp"
+#include "Types.hpp"
+
+namespace TSE::OpenGL
+{
+    class BasicParticleShader : public Shader
+    {
+    private:
+        static BasicParticleShader* instance;
+        mutable bool meshReady = false;
+        GLuint meshVBO = 0;
+        GLuint meshIBO = 0;
+        GLsizei meshVertexCount = 0;   // für DrawArraysInstanced
+        GLsizei meshIndexCount  = 0;   // für DrawElementsInstanced
+        GLenum  meshPrimitive   = GL_TRIANGLES;
+        GLenum meshIndexType = GL_UNSIGNED_SHORT;
+        int instanceCount = 0; // eigener Instanzzähler
+        GLint   meshPosSize   = 2;         // 2D (Billboard-Formen), für 3D Meshes: 3
+        GLsizei meshStride    = sizeof(float) * 2;
+        size_t  meshPosOffset = 0;
+
+    public:
+        static BasicParticleShader* Instance();
+        static void Destroy();
+        static void Init(float width, float height);
+        BasicParticleShader(std::vector<std::unique_ptr<ShaderPart>>&& parts);
+        ~BasicParticleShader();
+        void SetMesh(const void* verts, int vertCount, int stride, int floatCountPerVertex, int posOffsetBytes, GLenum primitive, const void* indices = nullptr, int indexCount = 0, GLenum indexType = GL_UNSIGNED_SHORT);
+
+    protected:
+        void OnEnable() const override;
+        void OnDisable() const override;
+        void OnFlush() override;
+        void OnDrawCall(int indexCount) override;
+        void OnSubmit(const Transformable& t, float*& target, TransformationStack& stack, void (*restartDrawcall)(IRenderer&), IRenderer& rnd) override;
+    };
+} // namespace TSE::GLFW
--- a/TSE_OpenGlImpl/src/shader/basicParticleShaderGLSL.hpp
+++ b/TSE_OpenGlImpl/src/shader/basicParticleShaderGLSL.hpp
@@ -0,0 +1,101 @@
+#pragma once
+
+inline const char* vertPart = R"(
+    #version 330 core
+
+    #ifndef USE_2D_BILLBOARD
+    #define USE_2D_BILLBOARD 1 //2D mesh => 1 ; 3D mesh => 0
+    #endif
+
+    // Mesh-Positions-Stream (per-vertex)
+    #if USE_2D_BILLBOARD
+    layout(location = 0) in vec2 meshPos;   // z.B. Quad-Ecken (-0.5..0.5)
+    #else
+    layout(location = 0) in vec3 meshPos;   // echte 3D-Mesh-Position
+    #endif
+
+    // Instanz-Attribute
+    layout(location = 1) in vec3 inPosition;      // Partikelzentrum (Welt)
+    layout(location = 2) in float inSize;         // Uniform-Scale
+    layout(location = 3) in float inRotation;     // Rotation (nur im Billboard-Modus genutzt)
+    layout(location = 4) in vec4 inColor;         // RGBA
+
+    uniform mat4 prMatrix;
+    uniform mat4 camMatrix;
+
+    out VS_OUT {
+        vec4 color;
+    #if USE_2D_BILLBOARD
+        vec2 uv;            // optional: für runde Maske im FS
+    #endif
+    } vs;
+
+    // Kameraachsen aus View-Matrix (Spalten 0/1)
+    vec3 CameraRight(mat4 view) { return vec3(view[0][0], view[1][0], view[2][0]); }
+    vec3 CameraUp   (mat4 view) { return vec3(view[0][1], view[1][1], view[2][1]); }
+
+
+    void main()
+    {
+        vs.color = inColor;
+
+    #if USE_2D_BILLBOARD
+        // 2D-Rotation im Billboard-Raum
+        float c = cos(inRotation);
+        float s = sin(inRotation);
+        vec2 q = vec2(c * meshPos.x - s * meshPos.y,
+                    s * meshPos.x + c * meshPos.y);
+
+        vec3 right = CameraRight(camMatrix);
+        vec3 up    = CameraUp(camMatrix);
+
+        // Uniform-Scaling über inSize
+        vec3 worldPos = inPosition + (q.x * inSize) * right
+                                    + (q.y * inSize) * up;
+
+        // optionales UV für Kreis-Maske
+        vs.uv = meshPos * 0.5 + 0.5; // falls meshPos in -1..1: nimm (meshPos*0.5+0.5)
+    #else
+        // echtes 3D-Mesh: nur uniform Scale + Translation
+        vec3 worldPos = inPosition + meshPos * inSize;
+    #endif
+
+        gl_Position = prMatrix * camMatrix * vec4(worldPos, 1.0);
+    }
+)";
+
+inline const char* fragPart = R"(
+    #version 330 core
+
+    #ifndef USE_2D_BILLBOARD
+    #define USE_2D_BILLBOARD 1
+    #endif
+
+    // Optional runde Maske an/aus (nur sinnvoll im Billboard-Modus mit z.B. Quad)
+    #ifndef USE_ROUND_MASK
+    #define USE_ROUND_MASK 0
+    #endif
+
+    in VS_OUT {
+        vec4 color;
+    #if USE_2D_BILLBOARD
+        vec2 uv;
+    #endif
+    } fs;
+
+    layout(location = 0) out vec4 outColor;
+
+    void main()
+    {
+    #if USE_2D_BILLBOARD && USE_ROUND_MASK
+        // weiche Kreis-Maske (aus uv ~ 0..1)
+        vec2 c = fs.uv * 2.0 - 1.0;              // nach [-1..1]
+        float r = length(c);
+        if (r > 1.0) discard;
+        float alpha = 1.0 - smoothstep(0.95, 1.0, r);
+        outColor = vec4(fs.color.rgb, fs.color.a * alpha);
+    #else
+        outColor = fs.color;
+    #endif
+    }
+)";
--- a/TSE_OpenGlImpl/src/shader/basicShader.cpp
+++ b/TSE_OpenGlImpl/src/shader/basicShader.cpp
@@ -0,0 +1,92 @@
+#include "GL/gl3w.h"
+#include "GL/gl.h"
+#include "basicShader.hpp"
+
+#include "basicShaderGLSL.hpp"
+#include "BehaviourScripts/Renderable.hpp"
+#include "Color.hpp"
+
+#define SHADER_VERTEX_INDEX 0
+#define SHADER_COLOR_INDEX 1
+
+#define SHADER_PACKAGE_SIZE sizeof(float) * (3 + 4)
+
+TSE::OpenGL::BasicShader* TSE::OpenGL::BasicShader::instance = nullptr;
+
+TSE::OpenGL::BasicShader *TSE::OpenGL::BasicShader::Instance()
+{
+    return instance;
+}
+
+void TSE::OpenGL::BasicShader::Destroy()
+{
+    if(instance != nullptr)
+        delete instance;
+    instance = nullptr;
+}
+
+void TSE::OpenGL::BasicShader::Init(float width, float height)
+{
+    std::vector<std::unique_ptr<ShaderPart>> parts;
+    parts.push_back(ShaderPart::LoadFromString(vert, GL_VERTEX_SHADER));
+    parts.push_back(ShaderPart::LoadFromString(frag, GL_FRAGMENT_SHADER));
+    instance = new BasicShader(std::move(parts));
+}
+
+TSE::OpenGL::BasicShader::BasicShader(std::vector<std::unique_ptr<ShaderPart>> &&parts) : Shader(parts)
+{
+    PackageSize = SHADER_PACKAGE_SIZE;
+}
+
+void TSE::OpenGL::BasicShader::OnEnable() const
+{
+    glEnableVertexAttribArray(SHADER_VERTEX_INDEX);
+    glVertexAttribPointer(SHADER_VERTEX_INDEX, 3, GL_FLOAT, false, SHADER_PACKAGE_SIZE, (void*)0);
+    glEnableVertexAttribArray(SHADER_COLOR_INDEX);
+    glVertexAttribPointer(SHADER_COLOR_INDEX, 4, GL_FLOAT, false, SHADER_PACKAGE_SIZE, (void*)(sizeof(float) * 3));
+}
+
+void TSE::OpenGL::BasicShader::OnDisable() const
+{
+    glDisableVertexAttribArray(SHADER_VERTEX_INDEX);
+    glDisableVertexAttribArray(SHADER_COLOR_INDEX);
+}
+
+void TSE::OpenGL::BasicShader::OnFlush()
+{
+}
+
+void TSE::OpenGL::BasicShader::OnDrawCall(int indexCount)
+{
+    glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_SHORT, NULL);
+}
+
+void TSE::OpenGL::BasicShader::OnSubmit(const Transformable &t, float *&target, TransformationStack &stack, void (*restartDrawcall)(IRenderer &), IRenderer &rnd)
+{
+    auto* r = dynamic_cast<Renderable*>(t.GetBehaviourScript(RENDERABLE));
+    if (!r) return;
+
+
+    const Vector3* verts = r->GetVertices();
+    ushort vCount = r->GetVertexCount();
+    const Color color = r->GetMaterial()->GetValue<Color>("mainColor");
+    Matrix4x4 matr = t.GetLocalMatrix();
+
+    stack.Push(matr);
+    const Matrix4x4& top = stack.Top();
+
+    //Todo transformable.lastmatrix hier ergänzen
+
+    for (ushort i = 0; i < vCount; i++) {
+        Vector3 p = top * verts[i];
+        *target++ = p.x;
+        *target++ = p.y;
+        *target++ = p.z;
+        *target++ = color.r;
+        *target++ = color.g;
+        *target++ = color.b;
+        *target++ = color.a;
+    }
+
+    stack.Pop();
+}
--- a/TSE_OpenGlImpl/src/shader/basicShader.hpp
+++ b/TSE_OpenGlImpl/src/shader/basicShader.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Shader.hpp"
+
+namespace TSE::OpenGL
+{
+    class BasicShader : public Shader
+    {
+    private:
+        static BasicShader* instance;
+
+    public:
+        static BasicShader* Instance();
+        static void Destroy();
+        static void Init(float width, float height);
+        BasicShader(std::vector<std::unique_ptr<ShaderPart>>&& parts);
+
+    protected:
+        void OnEnable() const override;
+        void OnDisable() const override;
+        void OnFlush() override;
+        void OnDrawCall(int indexCount) override;
+        void OnSubmit(const Transformable& t, float*& target, TransformationStack& stack, void (*restartDrawcall)(IRenderer&), IRenderer& rnd) override;
+    };
+} // namespace TSE::OpenGL
--- a/TSE_OpenGlImpl/src/shader/basicShaderGLSL.hpp
+++ b/TSE_OpenGlImpl/src/shader/basicShaderGLSL.hpp
@@ -0,0 +1,42 @@
+#pragma once
+
+
+inline const char* vert = R"(
+    #version 330 core
+
+    layout (location = 0) in vec3 position;
+    layout (location = 1) in vec4 color;
+
+
+    uniform mat4 prMatrix;
+    uniform mat4 camMatrix;
+
+    out DATA
+    {
+        vec4 color_out;
+    } vs_out;
+
+
+    void main()
+    {
+        gl_Position = prMatrix * camMatrix * vec4(position.x, position.y, position.z, 1.0);
+        vs_out.color_out = color;
+    }
+)";
+
+inline const char* frag = R"(
+    #version 330 core
+    layout (location = 0) out vec4 color;
+    in DATA
+    {
+        vec4 color_out;
+    } fs_in;
+    void main()
+    {
+        if(fs_in.color_out.a < 0.1)
+        {
+            discard;
+        }
+        color = fs_in.color_out;
+    } 
+)";
--- a/TSE_OpenGlImpl/src/shader/basicTextureShader.cpp
+++ b/TSE_OpenGlImpl/src/shader/basicTextureShader.cpp
@@ -0,0 +1,135 @@
+#include "GL/gl3w.h"
+#include "GL/gl.h"
+#include "basicTextureShader.hpp"
+#include "basicTextureShaderGLSL.hpp"
+#include "BehaviourScripts/Renderable.hpp"
+#include "Color.hpp"
+#include "interfaces/ITexture.hpp"
+
+#define SHADER_VERTEX_INDEX 0
+#define SHADER_COLOR_INDEX 1
+#define SHADER_UV_INDEX 2
+#define SHADER_TID_INDEX 3
+
+#define SHADER_PACKAGE_SIZE (sizeof(float) * (3 + 4 + 2 + 1))
+
+TSE::OpenGL::BasicTextureShader* TSE::OpenGL::BasicTextureShader::instance = nullptr;
+std::map<TSE::uint, float> TSE::OpenGL::BasicTextureShader::textureSlots;
+
+TSE::OpenGL::BasicTextureShader *TSE::OpenGL::BasicTextureShader::Instance()
+{
+    return instance;
+}
+
+void TSE::OpenGL::BasicTextureShader::Destroy()
+{
+    if(instance != nullptr)
+        delete instance;
+    instance = nullptr;
+}
+
+void TSE::OpenGL::BasicTextureShader::Init(float width, float height)
+{
+    std::vector<std::unique_ptr<ShaderPart>> parts;
+    parts.push_back(ShaderPart::LoadFromString(vertT, GL_VERTEX_SHADER));
+    parts.push_back(ShaderPart::LoadFromString(fragT, GL_FRAGMENT_SHADER));
+    instance = new BasicTextureShader(std::move(parts));
+
+    instance->Enable();
+    int texIDs[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32 };
+    instance->SetUniform("textures", &texIDs[0], 33);
+    instance->Disable();
+}
+
+TSE::OpenGL::BasicTextureShader::BasicTextureShader(std::vector<std::unique_ptr<ShaderPart>> &&parts) : Shader(parts)
+{
+    PackageSize = SHADER_PACKAGE_SIZE;
+}
+
+void TSE::OpenGL::BasicTextureShader::OnEnable() const
+{
+    glEnableVertexAttribArray(SHADER_VERTEX_INDEX);
+    glVertexAttribPointer(SHADER_VERTEX_INDEX, 3, GL_FLOAT, false, SHADER_PACKAGE_SIZE, (void*)0);
+    glEnableVertexAttribArray(SHADER_COLOR_INDEX);
+    glVertexAttribPointer(SHADER_COLOR_INDEX, 4, GL_FLOAT, false, SHADER_PACKAGE_SIZE, (void*)(sizeof(float) * 3));
+    glEnableVertexAttribArray(SHADER_UV_INDEX);
+    glVertexAttribPointer(SHADER_UV_INDEX, 2, GL_FLOAT, false, SHADER_PACKAGE_SIZE, (void*)(sizeof(float) * 7));
+    glEnableVertexAttribArray(SHADER_TID_INDEX);
+    glVertexAttribPointer(SHADER_TID_INDEX, 1, GL_FLOAT, false, SHADER_PACKAGE_SIZE, (void*)(sizeof(float) * 9));
+}
+
+void TSE::OpenGL::BasicTextureShader::OnDisable() const
+{
+    glDisableVertexAttribArray(SHADER_VERTEX_INDEX);
+    glDisableVertexAttribArray(SHADER_COLOR_INDEX);
+    glDisableVertexAttribArray(SHADER_UV_INDEX);
+    glDisableVertexAttribArray(SHADER_TID_INDEX);
+}
+
+void TSE::OpenGL::BasicTextureShader::OnFlush()
+{
+    auto it = textureSlots.begin();
+    for (int i = 0; i < textureSlots.size(); i++, it++)
+    {
+        glActiveTexture(GL_TEXTURE0 + i);
+        glBindTexture(GL_TEXTURE_2D, it->first);
+    }
+}
+
+void TSE::OpenGL::BasicTextureShader::OnDrawCall(int indexCount)
+{
+    glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_SHORT, NULL);
+}
+
+void TSE::OpenGL::BasicTextureShader::OnSubmit(const Transformable &t, float *&target, TransformationStack &stack, void (*restartDrawcall)(IRenderer &), IRenderer &rnd)
+{
+        auto* r = dynamic_cast<Renderable*>(t.GetBehaviourScript(RENDERABLE));
+        if (!r) return;
+        if(!r->GetMaterial()->HasValue("mainTex")) return;
+        const ITexture* tex = r->GetMaterial()->GetValue<ITexture*>("mainTex");
+        float ts = 0;
+        auto it = textureSlots.find(tex->GetTextureId());
+        if (it != textureSlots.end()) 
+        {
+            ts = it->second;
+        }
+        else
+        {
+            if(textureSlots.size() == 32)
+            {
+                restartDrawcall(rnd);
+                textureSlots.clear();
+            }
+            textureSlots[tex->GetTextureId()] = textureSlots.size();
+            ts = textureSlots[tex->GetTextureId()];
+        }
+
+
+        const Vector3* verts = r->GetVertices();
+        const Vector2* uvs = r->GetUVs();
+        ushort vCount = r->GetVertexCount();
+        const Color color = r->GetMaterial()->GetValue<Color>("mainColor");
+        Matrix4x4 matr = t.GetLocalMatrix();
+
+        stack.Push(matr);
+        const Matrix4x4& top = stack.Top();
+
+        //Todo transformable.lastmatrix hier ergänzen
+
+        for (ushort i = 0; i < vCount; i++) {
+            Vector3 p = top * verts[i];
+            Vector2 uv = uvs[i];
+            *target++ = p.x;
+            *target++ = p.y;
+            *target++ = p.z;
+            *target++ = color.r;
+            *target++ = color.g;
+            *target++ = color.b;
+            *target++ = color.a;
+            *target++ = uv.x;
+            *target++ = uv.y;
+            *target++ = ts;
+        }
+
+        stack.Pop();
+}
--- a/TSE_OpenGlImpl/src/shader/basicTextureShader.hpp
+++ b/TSE_OpenGlImpl/src/shader/basicTextureShader.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "Shader.hpp"
+#include "Types.hpp"
+#include <map>
+
+namespace TSE::OpenGL
+{
+    class BasicTextureShader : public Shader
+    {
+    private:
+        static BasicTextureShader* instance;
+        static std::map<uint, float> textureSlots;
+
+    public:
+        static BasicTextureShader* Instance();
+        static void Destroy();
+        static void Init(float width, float height);
+        BasicTextureShader(std::vector<std::unique_ptr<ShaderPart>>&& parts);
+
+    protected:
+        void OnEnable() const override;
+        void OnDisable() const override;
+        void OnFlush() override;
+        void OnDrawCall(int indexCount) override;
+        void OnSubmit(const Transformable& t, float*& target, TransformationStack& stack, void (*restartDrawcall)(IRenderer&), IRenderer& rnd) override;
+    };
+} // namespace TSE::OpenGL
--- a/TSE_OpenGlImpl/src/shader/basicTextureShaderGLSL.hpp
+++ b/TSE_OpenGlImpl/src/shader/basicTextureShaderGLSL.hpp
@@ -0,0 +1,159 @@
+#pragma once
+
+inline const char* vertT = R"(
+    #version 330 core
+
+    layout (location = 0) in vec3 position;
+    layout (location = 1) in vec4 color;
+    layout (location = 2) in vec2 uv;
+    layout (location = 3) in float tid;
+
+
+    uniform mat4 prMatrix;
+    uniform mat4 camMatrix;
+
+    out DATA
+    {
+        vec4 color_out;
+        vec2 uv_out;
+        float tid_out;
+    } vs_out;
+
+
+    void main()
+    {
+        gl_Position = prMatrix * camMatrix * vec4(position.x, position.y, position.z, 1.0);
+        vs_out.color_out = color;
+        vs_out.uv_out = uv;
+        vs_out.tid_out = tid;
+    }
+)";
+
+inline const char* fragT = R"(
+    #version 330 core
+    layout (location = 0) out vec4 color;
+
+    uniform sampler2D textures[32];
+
+    in DATA
+    {
+        vec4 color_out;
+        vec2 uv_out;
+        float tid_out;
+    } fs_in;
+    void main()
+    {
+        vec4 texColor = vec4(0,0,0,0);
+        int tid = int(fs_in.tid_out);
+        switch(tid)
+        {
+            case 0:
+                texColor = texture(textures[0], fs_in.uv_out);
+                break;
+            case 1:
+                texColor = texture(textures[1], fs_in.uv_out);
+                break;
+            case 2:
+                texColor = texture(textures[2], fs_in.uv_out);
+                break;
+            case 3:
+                texColor = texture(textures[3], fs_in.uv_out);
+                break;
+            case 4:
+                texColor = texture(textures[4], fs_in.uv_out);
+                break;
+            case 5:
+                texColor = texture(textures[5], fs_in.uv_out);
+                break;
+            case 6:
+                texColor = texture(textures[6], fs_in.uv_out);
+                break;
+            case 7:
+                texColor = texture(textures[7], fs_in.uv_out);
+                break;
+            case 8:
+                texColor = texture(textures[8], fs_in.uv_out);
+                break;
+            case 9:
+                texColor = texture(textures[9], fs_in.uv_out);
+                break;
+            case 10:
+                texColor = texture(textures[10], fs_in.uv_out);
+                break;
+            case 11:
+                texColor = texture(textures[11], fs_in.uv_out);
+                break;
+            case 12:
+                texColor = texture(textures[12], fs_in.uv_out);
+                break;
+            case 13:
+                texColor = texture(textures[13], fs_in.uv_out);
+                break;
+            case 14:
+                texColor = texture(textures[14], fs_in.uv_out);
+                break;
+            case 15:
+                texColor = texture(textures[15], fs_in.uv_out);
+                break;
+            case 16:
+                texColor = texture(textures[16], fs_in.uv_out);
+                break;
+            case 17:
+                texColor = texture(textures[17], fs_in.uv_out);
+                break;
+            case 18:
+                texColor = texture(textures[18], fs_in.uv_out);
+                break;
+            case 19:
+                texColor = texture(textures[19], fs_in.uv_out);
+                break;
+            case 20:
+                texColor = texture(textures[20], fs_in.uv_out);
+                break;
+            case 21:
+                texColor = texture(textures[21], fs_in.uv_out);
+                break;
+            case 22:
+                texColor = texture(textures[22], fs_in.uv_out);
+                break;
+            case 23:
+                texColor = texture(textures[23], fs_in.uv_out);
+                break;
+            case 24:
+                texColor = texture(textures[24], fs_in.uv_out);
+                break;
+            case 25:
+                texColor = texture(textures[25], fs_in.uv_out);
+                break;
+            case 26:
+                texColor = texture(textures[26], fs_in.uv_out);
+                break;
+            case 27:
+                texColor = texture(textures[27], fs_in.uv_out);
+                break;
+            case 28:
+                texColor = texture(textures[28], fs_in.uv_out);
+                break;
+            case 29:
+                texColor = texture(textures[29], fs_in.uv_out);
+                break;
+            case 30:
+                texColor = texture(textures[30], fs_in.uv_out);
+                break;
+            case 31:
+                texColor = texture(textures[31], fs_in.uv_out);
+                break;
+            default:
+                texColor = vec4(1,1,1,1);
+                break;
+        }
+        vec4 res = texColor * fs_in.color_out;
+
+        if(res.a < 0.1)
+        {
+            discard;
+        }
+
+        color = res;
+    } 
+)";
--- a/TSE_OpenGlImpl/src/shader/basicTileMapShader.cpp
+++ b/TSE_OpenGlImpl/src/shader/basicTileMapShader.cpp
@@ -0,0 +1,209 @@
+#include "basicTileMapShader.hpp"
+#include "BehaviourScripts/Renderable.hpp"
+#include "BehaviourScripts/TileMap.hpp"
+#include "Color.hpp"
+#include "basicTileMapShaderGLSL.hpp"
+
+#define SHADER_MESH_INDEX 0
+#define SHADER_POS_INDEX 1
+#define SHADER_SPRITE_INDEX 2
+
+#define SHADER_PACKAGE_SIZE sizeof(float) * (3 + 1)
+
+TSE::OpenGL::BasicTileMapShader* TSE::OpenGL::BasicTileMapShader::instance = nullptr;
+
+TSE::OpenGL::BasicTileMapShader *TSE::OpenGL::BasicTileMapShader::Instance()
+{
+    return instance;
+}
+
+void TSE::OpenGL::BasicTileMapShader::Destroy()
+{
+    if(instance != nullptr)
+    delete instance;
+    instance = nullptr;
+}
+
+void TSE::OpenGL::BasicTileMapShader::Init(float width, float height)
+{
+    std::vector<std::unique_ptr<ShaderPart>> parts;
+    parts.push_back(ShaderPart::LoadFromString(vertTile, GL_VERTEX_SHADER));
+    parts.push_back(ShaderPart::LoadFromString(fragTile, GL_FRAGMENT_SHADER));
+    instance = new BasicTileMapShader(std::move(parts));
+
+    instance->Enable();
+    int texIDs[] = { 0 };
+    instance->SetUniform("atlas", 0);
+    instance->Disable();
+}
+
+TSE::OpenGL::BasicTileMapShader::BasicTileMapShader(std::vector<std::unique_ptr<ShaderPart>> &&parts) : Shader(parts)
+{
+    PackageSize = SHADER_PACKAGE_SIZE;
+}
+
+TSE::OpenGL::BasicTileMapShader::~BasicTileMapShader()
+{
+    if (meshVBO) glDeleteBuffers(1, &meshVBO);
+    if (meshIBO) glDeleteBuffers(1, &meshIBO);
+}
+
+void TSE::OpenGL::BasicTileMapShader::SetMesh(const void *verts, int vertCount, int stride, int floatCountPerVertex, int posOffsetBytes, GLenum primitive, const void *indices, int indexCount, GLenum indexType)
+{
+    GLint prevVAO = 0, prevArrayBuffer = 0, prevElementBuffer = 0;
+    glGetIntegerv(GL_VERTEX_ARRAY_BINDING,         &prevVAO);
+    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &prevArrayBuffer);
+    glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &prevElementBuffer);
+
+    if (!meshVBO) glGenBuffers(1, &meshVBO);
+    glBindBuffer(GL_ARRAY_BUFFER, meshVBO);
+    glBufferData(GL_ARRAY_BUFFER, vertCount * stride, verts, GL_STATIC_DRAW);
+
+    if (indices && indexCount > 0)
+    {
+        if (!meshIBO) glGenBuffers(1, &meshIBO);
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, meshIBO);
+        GLsizeiptr idxSize =
+            (indexType == GL_UNSIGNED_INT  ? 4 :
+             indexType == GL_UNSIGNED_SHORT? 2 : 1) * indexCount;
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, idxSize, indices, GL_STATIC_DRAW);
+        meshIndexCount = indexCount;
+        meshIndexType  = indexType;
+    }
+    else
+    {
+        // Kein Index-Buffer
+        if (meshIBO) { glDeleteBuffers(1, &meshIBO); meshIBO = 0; }
+        meshIndexCount  = 0;
+    }
+
+    meshVertexCount = vertCount;
+    meshStride      = stride;
+    meshPosOffset   = posOffsetBytes;
+    meshPosSize     = floatCountPerVertex;
+    meshPrimitive   = primitive;
+    meshReady       = true;
+
+    glBindBuffer(GL_ARRAY_BUFFER, prevArrayBuffer);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, prevElementBuffer);
+    glBindVertexArray(prevVAO);
+}
+
+void TSE::OpenGL::BasicTileMapShader::OnEnable() const
+{
+    if (!meshReady)
+    {
+        // Fallback: unit-Quad als TRIANGLE_FAN (4 Vertices, 2D Positionen)
+        const float quad[8] = { -0.5f,-0.5f,  0.5f,-0.5f,  0.5f,0.5f,  -0.5f,0.5f };
+        const_cast<BasicTileMapShader*>(this)->SetMesh(
+            quad, 4, sizeof(float)*2, 2, 0, GL_TRIANGLE_FAN
+        );
+    }
+
+    GLint prevArrayBuffer = 0;
+    glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &prevArrayBuffer);
+
+    glBindBuffer(GL_ARRAY_BUFFER, meshVBO);
+    glEnableVertexAttribArray(SHADER_MESH_INDEX); // LOC_QUAD/pos
+    glVertexAttribPointer(SHADER_MESH_INDEX, meshPosSize, GL_FLOAT, GL_FALSE, meshStride, (void*)meshPosOffset);
+    glVertexAttribDivisor(SHADER_MESH_INDEX, 0);  // per-vertex (Mesh)
+
+    glBindBuffer(GL_ARRAY_BUFFER, prevArrayBuffer);
+
+    //   layout 1: position (vec3)
+    glEnableVertexAttribArray(SHADER_POS_INDEX);
+    glVertexAttribPointer(SHADER_POS_INDEX, 3, GL_FLOAT, GL_FALSE, PackageSize, (void*)0);
+    glVertexAttribDivisor(SHADER_POS_INDEX, 1);
+
+    //   layout 2: spriteindex (float)
+    glEnableVertexAttribArray(SHADER_SPRITE_INDEX);
+    glVertexAttribPointer(SHADER_SPRITE_INDEX, 1, GL_FLOAT, GL_FALSE, PackageSize, (void*)(sizeof(float)*3));
+    glVertexAttribDivisor(SHADER_SPRITE_INDEX, 1);
+}
+
+void TSE::OpenGL::BasicTileMapShader::OnDisable() const
+{
+    glDisableVertexAttribArray(SHADER_MESH_INDEX);
+    glDisableVertexAttribArray(SHADER_POS_INDEX);
+    glDisableVertexAttribArray(SHADER_SPRITE_INDEX);
+}
+
+void TSE::OpenGL::BasicTileMapShader::OnFlush()
+{
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, TextureID);
+}
+
+void TSE::OpenGL::BasicTileMapShader::OnDrawCall(int indexCount)
+{
+    if (instanceCount <= 0) return;
+    SetUniform("spriteCount", &SpriteCount); 
+    SetUniform("spriteScale", &SpriteScale); 
+
+    GLint prevElementBuffer = 0;
+    glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &prevElementBuffer);
+
+    if (meshIBO && meshIndexCount > 0)
+    {
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, meshIBO);
+        glDrawElementsInstanced(meshPrimitive, meshIndexCount, meshIndexType, (void*)0, instanceCount);
+    }
+    else
+    {
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+        glDrawArraysInstanced(meshPrimitive, 0, meshVertexCount, instanceCount);
+    }
+
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, (GLuint)prevElementBuffer);
+    instanceCount = 0;
+}
+
+void TSE::OpenGL::BasicTileMapShader::OnSubmit(const Transformable &t, float *&target, TransformationStack &stack, void (*restartDrawcall)(IRenderer &), IRenderer &rnd)
+{
+    auto* r = dynamic_cast<Renderable*>(t.GetBehaviourScript(RENDERABLE));
+    if (!r) return;
+
+    auto* tm = dynamic_cast<TileMap*>(t.GetBehaviourScript(TILE_MAP));
+    if (!tm) return;
+
+    auto tileSet = tm->GetTileSet();
+    TextureID = tileSet->GetTextueID();
+    SpriteCount = tileSet->GetCount();
+    SpriteScale = tm->SpriteScale;
+
+    const std::vector<Vector2> orderedChunks = *tm->GetChunkPositionsInOrder();
+
+    Matrix4x4 matr = t.GetLocalMatrix();
+
+    stack.Push(matr);
+
+    for(auto chunkPos : orderedChunks)
+    {
+        auto chunk = tm->GetChunk(chunkPos);
+        const int spriteCount = chunk->GetSpriteCount();
+        const std::vector<Vector2> spritePositions = *chunk->GetOrderedPositions();
+        const std::vector<Vector2i> spriteIds = *chunk->GetOrderedSpriteIds();
+        int chunkSize = chunk->GetChunksize();
+
+        for (int i = 0; i < spriteCount; i++)
+        {
+            Matrix4x4 mat = Matrix4x4::ToTranslationMatrix((chunkPos - chunk->nextLine * chunkPos.y) + spritePositions[i]) * Matrix4x4::ToRotationMatrix(Quaternion()) * Matrix4x4::ToScaleMatrix({1,1,1});
+            stack.Push(mat);
+            Vector3 pos = stack.Top() * Vector3(0,0,0);
+
+            *target++ = pos.x;
+            *target++ = pos.y;
+            *target++ = pos.z;
+            *target++ = spriteIds[i].x;
+
+            ++instanceCount;
+            stack.Pop();
+
+            if(instanceCount >= 20000)
+                restartDrawcall(rnd);
+        }
+    }
+
+    stack.Pop();
+    restartDrawcall(rnd);
+}
--- a/TSE_OpenGlImpl/src/shader/basicTileMapShader.hpp
+++ b/TSE_OpenGlImpl/src/shader/basicTileMapShader.hpp
@@ -0,0 +1,44 @@
+#pragma once
+
+#include "GL/gl3w.h"
+#include "GL/gl.h"
+#include "Shader.hpp"
+#include "Types.hpp"
+
+namespace TSE::OpenGL
+{
+    class BasicTileMapShader : public Shader
+    {
+    private:
+        static BasicTileMapShader* instance;
+        mutable bool meshReady = false;
+        GLuint meshVBO = 0;
+        GLuint meshIBO = 0;
+        GLsizei meshVertexCount = 0;   // für DrawArraysInstanced
+        GLsizei meshIndexCount  = 0;   // für DrawElementsInstanced
+        GLenum  meshPrimitive   = GL_TRIANGLES;
+        GLenum meshIndexType = GL_UNSIGNED_SHORT;
+        int instanceCount = 0; // eigener Instanzzähler
+        GLint   meshPosSize   = 2;         // 2D (Billboard-Formen), für 3D Meshes: 3
+        GLsizei meshStride    = sizeof(float) * 2;
+        size_t  meshPosOffset = 0;
+        GLuint TextureID;
+        Vector2 SpriteCount;
+        Vector2 SpriteScale;
+
+    public:
+        static BasicTileMapShader* Instance();
+        static void Destroy();
+        static void Init(float width, float height);
+        BasicTileMapShader(std::vector<std::unique_ptr<ShaderPart>>&& parts);
+        ~BasicTileMapShader();
+        void SetMesh(const void* verts, int vertCount, int stride, int floatCountPerVertex, int posOffsetBytes, GLenum primitive, const void* indices = nullptr, int indexCount = 0, GLenum indexType = GL_UNSIGNED_SHORT);
+
+    protected:
+        void OnEnable() const override;
+        void OnDisable() const override;
+        void OnFlush() override;
+        void OnDrawCall(int indexCount) override;
+        void OnSubmit(const Transformable& t, float*& target, TransformationStack& stack, void (*restartDrawcall)(IRenderer&), IRenderer& rnd) override;
+    };
+} // namespace TSE::OpenGL
--- a/TSE_OpenGlImpl/src/shader/basicTileMapShaderGLSL.hpp
+++ b/TSE_OpenGlImpl/src/shader/basicTileMapShaderGLSL.hpp
@@ -0,0 +1,60 @@
+#pragma once
+
+inline const char* vertTile = R"(
+    #version 330 core
+
+    layout(location = 0) in vec2 aPos;
+
+    layout(location = 1) in vec3 iTilePos;
+    layout(location = 2) in float iSpriteId;
+
+    uniform mat4 prMatrix;
+    uniform mat4 camMatrix;
+    uniform vec2 spriteCount;
+    uniform vec2 spriteScale;
+
+    out vec2 vUV;
+    flat out int vSpriteId;
+
+    void main()
+    {
+        vec3 local = vec3(aPos.x, aPos.y, 0);
+        vec2 baseUV = aPos + vec2(0.5);
+        vec3 tileSize = vec3(spriteScale.x, spriteScale.y, 1);
+
+        vec3 worldPos = (iTilePos * tileSize) + (local * tileSize);
+
+        gl_Position = prMatrix * camMatrix * vec4(worldPos.x, worldPos.y, worldPos.z, 1.0);
+
+        vUV = baseUV;
+        vSpriteId = int(iSpriteId + 0.5);
+    }
+)";
+
+inline const char* fragTile = R"(
+    #version 330 core
+
+    in vec2 vUV;
+    flat in int vSpriteId;
+
+    uniform sampler2D atlas;
+    uniform vec2 spriteCount;
+
+    out vec4 FragColor;
+
+    void main()
+    {
+        vec2 tileUVSize = 1.0 / spriteCount;
+
+        int cols = int(spriteCount.x);
+        int sx = vSpriteId % cols;
+        int sy = vSpriteId / cols;
+
+        vec2 atlasOffset = vec2(float(sx), float(sy)) * tileUVSize;
+        vec2 atlasUV = atlasOffset + (vUV * tileUVSize);
+        vec4 c = texture(atlas, atlasUV);
+        if (c.a < 0.01) discard;
+
+        FragColor = c;
+    }
+)";
--- a/TSE_OpenGlImpl/src/shader/defaultShaderHandler.cpp
+++ b/TSE_OpenGlImpl/src/shader/defaultShaderHandler.cpp
@@ -0,0 +1,40 @@
+#include "defaultShaderHandler.hpp"
+#include "basicShader.hpp"
+#include "basicTextureShader.hpp"
+#include "ditheringShader.hpp"
+#include "basicParticleShader.hpp"
+#include "basicTileMapShader.hpp"
+#include "basicOrderedSpriteSetShader.hpp"
+#include "elements/ShaderRegistry.hpp"
+
+void TSE::OpenGL::LoadBasicShaders(float width, float height)
+{
+    BasicShader::Init(width, height);
+    BasicTextureShader::Init(width, height);
+    DitheringShader::Init(width, height);
+    BasicParticleShader::Init(width, height);
+    BasicTileMapShader::Init(width, height);
+    BasicOrderedSpriteSetShader::Init(width, height);
+    ShaderRegistry::SetShader("Basic Unlit Shader", BasicShader::Instance());
+    ShaderRegistry::SetShader("Basic Unlit Texture Shader", BasicTextureShader::Instance());
+    ShaderRegistry::SetShader("Basic Unlit Dithering Shader", DitheringShader::Instance());
+    ShaderRegistry::SetShader("Basic Unlit Particle Shader", BasicParticleShader::Instance());
+    ShaderRegistry::SetShader("Basic Unlit TileMap Shader", BasicTileMapShader::Instance());
+    ShaderRegistry::SetShader("Basic Ordered Sprite Set Shader", BasicOrderedSpriteSetShader::Instance());
+}
+
+void TSE::OpenGL::UnLoadBasicShaders()
+{
+    ShaderRegistry::RemoveShader("Basic Unlit Shader");
+    ShaderRegistry::RemoveShader("Basic Unlit Texture Shader");
+    ShaderRegistry::RemoveShader("Basic Unlit Dithering Shader");
+    ShaderRegistry::RemoveShader("Basic Unlit Particle Shader");
+    ShaderRegistry::RemoveShader("Basic Unlit TileMap Shader");
+    ShaderRegistry::RemoveShader("Basic Ordered Sprite Set Shader");
+    BasicShader::Destroy();
+    BasicTextureShader::Destroy();
+    DitheringShader::Destroy();
+    BasicParticleShader::Destroy();
+    BasicTileMapShader::Destroy();
+    BasicOrderedSpriteSetShader::Destroy();
+}
--- a/TSE_OpenGlImpl/src/shader/defaultShaderHandler.hpp
+++ b/TSE_OpenGlImpl/src/shader/defaultShaderHandler.hpp
@@ -0,0 +1,7 @@
+#pragma once
+
+namespace TSE::OpenGL
+{
+    void LoadBasicShaders(float width, float height);
+    void UnLoadBasicShaders();
+} // namespace TSE::GLFW
--- a/TSE_OpenGlImpl/src/shader/ditheringShader.cpp
+++ b/TSE_OpenGlImpl/src/shader/ditheringShader.cpp
@@ -0,0 +1,91 @@
+#include "GL/gl3w.h"
+#include "GL/gl.h"
+#include "ditheringShader.hpp"
+#include "ditheringShaderGLSL.hpp"
+#include "BehaviourScripts/Renderable.hpp"
+#include "Color.hpp"
+
+#define SHADER_VERTEX_INDEX 0
+#define SHADER_COLOR_INDEX 1
+
+#define SHADER_PACKAGE_SIZE sizeof(float) * (3 + 4)
+
+TSE::OpenGL::DitheringShader* TSE::OpenGL::DitheringShader::instance = nullptr;
+
+TSE::OpenGL::DitheringShader *TSE::OpenGL::DitheringShader::Instance()
+{
+    return instance;
+}
+
+void TSE::OpenGL::DitheringShader::Destroy()
+{
+    if(instance != nullptr)
+        delete instance;
+    instance = nullptr;
+}
+
+void TSE::OpenGL::DitheringShader::Init(float width, float height)
+{
+    std::vector<std::unique_ptr<ShaderPart>> parts;
+    parts.push_back(ShaderPart::LoadFromString(vertD, GL_VERTEX_SHADER));
+    parts.push_back(ShaderPart::LoadFromString(fragD, GL_FRAGMENT_SHADER));
+    instance = new DitheringShader(std::move(parts));
+}
+
+TSE::OpenGL::DitheringShader::DitheringShader(std::vector<std::unique_ptr<ShaderPart>> &&parts) : Shader(parts)
+{
+    PackageSize = SHADER_PACKAGE_SIZE;
+}
+
+void TSE::OpenGL::DitheringShader::OnEnable() const
+{
+    glEnableVertexAttribArray(SHADER_VERTEX_INDEX);
+    glVertexAttribPointer(SHADER_VERTEX_INDEX, 3, GL_FLOAT, false, SHADER_PACKAGE_SIZE, (void*)0);
+    glEnableVertexAttribArray(SHADER_COLOR_INDEX);
+    glVertexAttribPointer(SHADER_COLOR_INDEX, 4, GL_FLOAT, false, SHADER_PACKAGE_SIZE, (void*)(sizeof(float) * 3));
+}
+
+void TSE::OpenGL::DitheringShader::OnDisable() const
+{
+    glDisableVertexAttribArray(SHADER_VERTEX_INDEX);
+    glDisableVertexAttribArray(SHADER_COLOR_INDEX);
+}
+
+void TSE::OpenGL::DitheringShader::OnFlush()
+{
+}
+
+void TSE::OpenGL::DitheringShader::OnDrawCall(int indexCount)
+{
+    glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_SHORT, NULL);
+}
+
+void TSE::OpenGL::DitheringShader::OnSubmit(const Transformable &t, float *&target, TransformationStack &stack, void (*restartDrawcall)(IRenderer &), IRenderer &rnd)
+{
+    auto* r = dynamic_cast<Renderable*>(t.GetBehaviourScript(RENDERABLE));
+    if (!r) return;
+
+
+    const Vector3* verts = r->GetVertices();
+    ushort vCount = r->GetVertexCount();
+    const Color color = r->GetMaterial()->GetValue<Color>("mainColor");
+    Matrix4x4 matr = t.GetLocalMatrix();
+
+    stack.Push(matr);
+    const Matrix4x4& top = stack.Top();
+
+    //Todo transformable.lastmatrix hier ergänzen
+
+    for (ushort i = 0; i < vCount; i++) {
+        Vector3 p = top * verts[i];
+        *target++ = p.x;
+        *target++ = p.y;
+        *target++ = p.z;
+        *target++ = color.r;
+        *target++ = color.g;
+        *target++ = color.b;
+        *target++ = color.a;
+    }
+
+    stack.Pop();
+}
--- a/TSE_OpenGlImpl/src/shader/ditheringShader.hpp
+++ b/TSE_OpenGlImpl/src/shader/ditheringShader.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Shader.hpp"
+
+namespace TSE::OpenGL
+{
+    class DitheringShader : public Shader
+    {
+    private:
+        static DitheringShader* instance;
+
+    public:
+        static DitheringShader* Instance();
+        static void Destroy();
+        static void Init(float width, float height);
+        DitheringShader(std::vector<std::unique_ptr<ShaderPart>>&& parts);
+
+    protected:
+        void OnEnable() const override;
+        void OnDisable() const override;
+        void OnFlush() override;
+        void OnDrawCall(int indexCount) override;
+        void OnSubmit(const Transformable& t, float*& target, TransformationStack& stack, void (*restartDrawcall)(IRenderer&), IRenderer& rnd) override;
+    };
+} // namespace TSE::OpenGL
--- a/TSE_OpenGlImpl/src/shader/ditheringShaderGLSL.hpp
+++ b/TSE_OpenGlImpl/src/shader/ditheringShaderGLSL.hpp
@@ -0,0 +1,80 @@
+#pragma once
+
+
+inline const char* vertD = R"(
+    #version 330 core
+
+    layout (location = 0) in vec3 position;
+    layout (location = 1) in vec4 color;
+
+    uniform mat4 prMatrix;
+    uniform mat4 camMatrix;
+
+    out DATA
+    {
+        vec4 color_out;
+    } vs_out;
+
+    void main()
+    {
+        gl_Position = prMatrix * camMatrix * vec4(position, 1.0);
+        vs_out.color_out = color;
+    }
+)";
+
+inline const char* fragD = R"(
+    #version 330 core
+
+    layout (location = 0) out vec4 color;
+
+    in DATA
+    {
+        vec4 color_out;
+    } fs_in;
+
+    // 8x8 Bayer-Matrix (0..63), als Schwellwerttabelle
+    float bayer8(vec2 fragXY)
+    {
+        int x = int(mod(fragXY.x, 8.0));
+        int y = int(mod(fragXY.y, 8.0));
+        int idx = x + y * 8;
+
+        // Werte aus klassischer 8x8 Ordered-Dithering-Matrix
+        int m[64] = int[64](
+            0, 48, 12, 60,  3, 51, 15, 63,
+            32, 16, 44, 28, 35, 19, 47, 31,
+            8, 56,  4, 52, 11, 59,  7, 55,
+            40, 24, 36, 20, 43, 27, 39, 23,
+            2, 50, 14, 62,  1, 49, 13, 61,
+            34, 18, 46, 30, 33, 17, 45, 29,
+            10, 58,  6, 54,  9, 57,  5, 53,
+            42, 26, 38, 22, 41, 25, 37, 21
+        );
+
+        // +0.5, damit die Schwellen mittig zwischen Stufen liegen
+        return (float(m[idx]) + 0.5) / 64.0;
+    }
+
+    void main()
+    {
+        vec4 c = fs_in.color_out;
+
+        // alpha == 0 -> nichts rendern
+        if (c.a <= 0.0)
+            discard;
+
+        // Für alpha < 1 verwenden wir Ordered Dithering
+        if (c.a < 1.0)
+        {
+            float threshold = bayer8(gl_FragCoord.xy);
+            // ist der Schwellenwert größer als alpha? -> Pixel auslassen
+            if (threshold > c.a)
+                discard;
+        }
+
+        // Wenn wir bis hier nicht verworfen haben, zeichnen wir den Pixel.
+        // Typischerweise setzt man die ausgegebene Alpha dann auf 1.0,
+        // weil die Transparenz bereits über das Dithering realisiert wurde.
+        color = vec4(c.rgb, 1.0);
+    }
+)";