triangle

ExampleApps.nix

@@ -31,6 +31,50 @@
 
     };
 
+    TriangleEmbed = pkgs.stdenvNoCC.mkDerivation {
+
+        name = "Archimedes";
+
+        src = ./.;
+
+        imgui = inputs.imgui;
+
+        nativeBuildInputs = with pkgs; [
+            clang
+        ];
+
+        buildInputs = with pkgs; [
+            glfw
+            glew
+
+            glm
+            nlohmann_json
+            curl
+        ];
+
+        buildPhase = ''
+            clang++ \
+            src/example_apps/TriangleEmbed/*.cpp \
+            modules/Archimedes-Modules/TestTriangle/*.cpp \
+            modules/WindowModule/*.cpp \
+            -DRENDERER_OPENGL=1 \
+            -DWINDOW_GLFW=1 \
+            -I include -I . \
+            -lEGL -lGL -lglfw -lGLEW \
+            $(curl-config --cflags) \
+            $(curl-config --libs) \
+            -Wall \
+            -o $name
+        ''; 
+
+        installPhase = ''
+            mkdir -p $out/bin
+            cp $name $out/bin
+        '';
+
+    };
+
+   
     ImguiEmbed = pkgs.stdenvNoCC.mkDerivation {
 
         name = "Archimedes";

ExampleModules.nix

@@ -188,18 +188,23 @@
             buildInputs = with pkgs; [
                 glfw
                 glew
+                glm
+                nlohmann_json
+                curl
             ];
 
             buildPhase = ''
                 clang++ \
                 modules/Archimedes-Modules/TestTriangle/*.cpp \
                 modules/WindowModule/*.cpp \
-                -DRENDERER=1 \
-                -DWINDOW=1 \
+                -DRENDERER_OPENGL=1 \
+                -DWINDOW_GLFW=1 \
                 -DTESTTRIANGLE_DYNAMIC \
                 -fpic -shared \
                 -I include -I . \
                 -lEGL -lglfw -lGLEW \
+                $(curl-config --cflags) \
+                $(curl-config --libs) \
                 -Wall \
                 -o $name
             ''; 

include/pch.hpp

@@ -2,6 +2,7 @@
 #define PCH_HPP
 
 #include <iostream>
+#include <fstream>
 #include <cstring>
 #include <cassert>
 #include <list>

include/utils/Renderer/RenderTarget.h

@@ -0,0 +1,184 @@
+#ifndef RENDERTARGET_H
+#define RENDERTARGET_H
+
+#include "pch.hpp"
+
+#include "extratools.h"
+
+namespace Archimedes {
+
+    class LayoutElement {
+
+        public:
+            LayoutElement(unsigned int type, size_t count) : type(type), count(count) {}
+            
+            ~LayoutElement() {}
+        
+            unsigned int getType() const { return type; }
+
+            size_t getSize() const { return size; }
+
+            size_t getCount() const { return count; }
+        private:
+
+            unsigned int type;
+            size_t size;
+            size_t count;
+    };
+
+    class VertexLayout {
+
+        public:
+            VertexLayout() {}
+            ~VertexLayout() {}
+
+            const std::vector<LayoutElement>& getElements() const { return elements; }
+
+        private:
+            std::vector<LayoutElement> elements;
+    };
+
+    class VertexBuffer {
+
+        public:
+            VertexBuffer(const void* data, size_t size) : data(data), size(size) {
+            }
+            
+            ~VertexBuffer() {}
+
+            const void* getData() const { return data; }
+            size_t getSize() const { return size; }
+
+            unsigned int id;
+        private:
+            const void* data;
+            size_t size;
+    };
+    
+    class VertexArray {
+
+        public:
+            VertexArray() {
+            }
+            
+            ~VertexArray() {}
+
+
+            unsigned int id;
+        private:
+    };
+
+    class IndexArray {
+
+        public:
+            IndexArray(const unsigned int* indices, size_t count) : indices(indices), count(count) {
+            }
+            
+            ~IndexArray() {}
+
+            const void* getIndicies() const { return indices; }
+            size_t getCount() const { return count; }
+
+            unsigned int id;
+        private:
+            const unsigned int* indices;
+            size_t count;
+    };
+
+    class Shader {
+
+        public:
+            enum class LoadType {
+                FromSource,
+                FromBin,
+                FromFileSource,
+                FromFileBin
+            };
+
+            Shader(const std::string& vs, const std::string& fs, LoadType loadType) : loadType(loadType) {
+                switch(loadType) {
+                    case LoadType::FromSource:
+                        this->vs = vs;
+                        this->fs = fs;
+                        break;
+                    case LoadType::FromBin:
+                        break;
+                    case LoadType::FromFileSource:
+                        this->vs = readSourceFile(vs);
+                        this->fs = readSourceFile(fs);
+                        break;
+                    case LoadType::FromFileBin:
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+            ~Shader() {}
+
+            
+            std::string getVSource() const { return vs; }
+            std::string getFSource() const { return fs; }
+
+            unsigned int id;
+        private:
+            LoadType loadType;
+
+            std::string vs;
+            std::string fs;
+
+            std::string readSourceFile(const std::string& path) {
+
+                std::ifstream file(path);
+
+                if(!file.is_open()) {
+                    return "";
+                }
+
+                std::string s;
+
+                while(!file.eof()) {
+                    file >> s;
+                }
+
+                return s;
+
+            }
+    };
+
+    class RenderTarget {
+
+        public:
+            RenderTarget(const void* data, size_t size, unsigned int* indices, size_t count, VertexLayout layout, const std::string& vs, const std::string& fs) 
+                : vertexBuffer(data, size), 
+                indexArray(indices, count), 
+                layout(layout), 
+                shader(vs, fs, Shader::LoadType::FromFileSource) {
+
+            }
+
+            RenderTarget(VertexBuffer vb, IndexArray ia, VertexLayout vl, Shader s) 
+                : vertexBuffer(vb), 
+                indexArray(ia), 
+                layout(vl), 
+                shader(s) {
+
+            }
+
+            ~RenderTarget() {}
+
+        //private:
+
+            VertexBuffer vertexBuffer;
+
+            VertexArray vertexArray;
+
+            VertexLayout layout;
+
+            IndexArray indexArray;
+
+            Shader shader;
+    };
+}
+
+#endif

include/utils/Renderer/Renderer.h

@@ -5,89 +5,10 @@
 
 #include "extratools.h"
 
+#include "RenderTarget.h"
+
 namespace Archimedes {
        
-
-    class VertexArray {
-
-        public:
-            VertexArray(const void* data, size_t size) : data(data), size(size) {
-            }
-            
-            ~VertexArray() {}
-
-            const void* getData() const { return data; }
-            size_t getSize() const { return size; }
-            unsigned int getId() const { return id; }
-
-        private:
-            const void* data;
-            size_t size;
-            unsigned int id;
-    };
-
-    class IndexArray {
-
-        public:
-            IndexArray(const unsigned int* indices, size_t count) : indices(indices), count(count) {
-            }
-            
-            ~IndexArray() {}
-
-            const void* getIndicies() const { return indices; }
-            size_t getCount() const { return count; }
-
-        private:
-            const unsigned int* indices;
-            size_t count;
-            unsigned int id;
-    };
-
-    class Shader {
-
-        public:
-            enum class LoadType {
-                FromSource,
-                FromFileSource,
-                FromFileBin
-            };
-
-            Shader(const std::string& source, LoadType loadType) {
-                switch(loadType) {
-                    case LoadType::FromSource:
-                        break;
-                    case LoadType::FromFileSource:
-                        break;
-                    case LoadType::FromFileBin:
-                        break;
-                    default:
-                        break;
-                }
-            }
-
-            ~Shader() {}
-
-            unsigned int getId() const { return id; }
-
-        private:
-            unsigned int id;
-    };
-
-    class RenderTarget {
-
-        public:
-            RenderTarget(const void* data, size_t size, size_t count, const std::string& shader) 
-                : data(data), size(size), count(count), shader(shader) {}
-
-            ~RenderTarget() {}
-
-        private:
-            const void* data;
-            size_t size;
-            size_t count;
-            const std::string& shader;
-    };
-
     class Renderer {
 
         public:
@@ -103,7 +24,20 @@ namespace Archimedes {
 
             virtual void render() = 0;
             
-            virtual void draw(const VertexArray&, const IndexArray&, const Shader&) = 0;
+            virtual Shader createShader(const std::string& vs, const std::string& fs, const Shader::LoadType& lt) = 0;
+            
+            virtual RenderTarget* createRenderTarget(
+                    const void* data, 
+                    size_t size, 
+                    unsigned int* indices, 
+                    size_t count, 
+                    VertexLayout layout, 
+                    const std::string& vs,
+                    const std::string& fs,
+                    const Shader::LoadType& lt
+            ) = 0;
+            
+            virtual void draw(const RenderTarget*) = 0;
 
             virtual Renderer* getRendererImpl() = 0;
 

include/utils/Renderer/RendererImpl/RendererOpenGL/RendererOpenGL.h

@@ -1,7 +1,7 @@
 
-#define RENDERER_OPENGL
 #ifdef RENDERER_OPENGL
-#undef RENDERER_OPENGL
+#ifndef RENDERER_OPENGL_H
+#define RENDERER_OPENGL_H
 
 #include "pch.hpp"
 
@@ -13,12 +13,6 @@
 
 namespace Archimedes {
 
-    class VertexArrayOpenGL : public VertexArray {};
-
-    class IndexArrayOpenGL : public IndexArray {};
-
-    class ShaderOpenGL : public Shader {};
-
     class RendererOpenGL : public Renderer {
     
         public:
@@ -39,13 +33,104 @@ namespace Archimedes {
 
             }
 
-            void draw(const VertexArray& va, const IndexArray& ia, const Shader& shader) override {
+            Shader createShader(const std::string& vs, const std::string& fs, const Shader::LoadType& lt) override {
 
-                glUseProgram(shader.id);
 
-                glBindVertexArray(va.id);
+                Shader shader(vs, fs, lt);
                 
-                glDrawElements(GL_TRIANGLES, va.count, GL_UNSIGNED_INT, 0);
+                std::string vss = shader.getVSource();
+                std::string fss = shader.getFSource();
+
+                const char* vsc = vss.c_str();
+                const char* fsc = fss.c_str();
+
+                unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
+                glShaderSource(vertexShader, 1, &vsc, NULL);
+                glCompileShader(vertexShader);
+                // check for shader compile errors
+                int success;
+                char infoLog[512];
+                glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
+                if (!success)
+                {
+                    glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
+                    std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
+                }
+                // fragment shader
+                unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
+                glShaderSource(fragmentShader, 1, &fsc, NULL);
+                glCompileShader(fragmentShader);
+                // check for shader compile errors
+                glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
+                if (!success)
+                {
+                    glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
+                    std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
+                }
+                // link shaders
+                unsigned int shaderProgram = glCreateProgram();
+                glAttachShader(shaderProgram, vertexShader);
+                glAttachShader(shaderProgram, fragmentShader);
+                glLinkProgram(shaderProgram);
+                // check for linking errors
+                glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
+                if (!success) {
+                    glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
+                    std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
+                }
+                glDeleteShader(vertexShader);
+                glDeleteShader(fragmentShader);
+
+                shader.id = shaderProgram;
+                
+                return shader;
+            }
+            
+            RenderTarget* createRenderTarget(const void* data, size_t size, unsigned int* indices, size_t count, VertexLayout layout, const std::string& vs, const std::string& fs, const Shader::LoadType& lt) override {
+                
+                VertexBuffer vb(data, size);
+
+                IndexArray ia(indices, count);
+
+                Shader s = createShader(vs, fs, lt);
+
+                auto rt = new RenderTarget(vb, ia, layout, s);
+
+                glGenVertexArrays(1, &rt->vertexArray.id);
+
+                glGenBuffers(1, &rt->vertexBuffer.id);
+
+                glBindVertexArray(rt->vertexArray.id);
+
+                glBindBuffer(GL_ARRAY_BUFFER, rt->vertexBuffer.id);
+                glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 6, data, GL_STATIC_DRAW);
+                
+
+                glGenBuffers(1, &rt->indexArray.id);
+
+                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rt->indexArray.id);
+                glBufferData(GL_ELEMENT_ARRAY_BUFFER, count * sizeof(unsigned int), indices, GL_STATIC_DRAW);
+                
+
+                glUseProgram(s.id);
+
+                
+                glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
+                glEnableVertexAttribArray(0);
+
+                glBindVertexArray(0); 
+                glBindBuffer(GL_ARRAY_BUFFER, 0); 
+
+                return rt;
+            };
+
+            void draw(const RenderTarget* rt) override {
+                
+                glUseProgram(rt->shader.id);
+
+                glBindVertexArray(rt->vertexArray.id);
+
+                glDrawElements(GL_TRIANGLES, rt->indexArray.getCount(), GL_UNSIGNED_INT, nullptr);
                 
                 glBindVertexArray(0);
             }
@@ -55,3 +140,4 @@ namespace Archimedes {
 }
 
 #endif
+#endif

include/utils/Renderer/RendererImpl/RendererSDL3/RendererSDL3.h

@@ -1,5 +1,6 @@
-#ifndef RENDERER_SDL3
-#define RENDERER_SDL3
+#ifdef RENDERER_SDL3
+#ifndef RENDERER_SDL3_H
+#define RENDERER_SDL3_H
 
 #include "pch.hpp"
 
@@ -39,3 +40,4 @@ namespace Archimedes {
 }
 
 #endif
+#endif

include/utils/Window/Window.h

@@ -13,15 +13,15 @@ namespace Archimedes {
 
             Window(const std::function<void(Event*)>& sendEventFn) : eventFn(sendEventFn) {}
 
-            virtual ~Window() = 0;
+            virtual ~Window() {};
 
 
             void doFrame() {
 
-                renderer->render();
-
                 swapBuffers();
 
+                renderer->render();
+                
                 pollEvents();
                 
             }
@@ -32,6 +32,8 @@ namespace Archimedes {
 
             virtual void pollEvents() = 0;
             
+            virtual void restoreContext() = 0;
+            
             virtual void getSize(int& w, int& h) {
                 w = this->w;
                 h = this->h;

include/utils/Window/WindowImpl/WindowGLFW/WindowGLFW.h

@@ -1,5 +1,6 @@
 #ifdef WINDOW_GLFW
-#undef WINDOW_GLFW
+#ifndef WINDOW_GLFW_H
+#define WINDOW_GLFW_H
 
 #include "pch.hpp"
 
@@ -28,16 +29,17 @@ namespace Archimedes {
                     std::cout << "glfwInit failed!\n";
                     std::abort();
                 }
+#ifdef RENDERER_OPENGL
+                glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+                glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+                glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
                     
-                if(renderer) {
-                    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-                    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
-                    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-                }
+                glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, 1);
+#endif
 
                 window = glfwCreateWindow(640, 480, "Archimedes", NULL, NULL);
 
-                if(!w) {
+                if(!window) {
                     std::cout << "glfwCreateWindow failed!\n";
                     glfwTerminate();
                     std::abort();
@@ -114,7 +116,7 @@ namespace Archimedes {
                 return glfwWindowShouldClose(window);
             }
 
-            void restoreContext() { glfwMakeContextCurrent(window); }
+            void restoreContext() override { glfwMakeContextCurrent(window); }
 
             void getSize(int& w, int& h) override {
                 glfwGetFramebufferSize(window, &w, &h);
@@ -134,3 +136,4 @@ namespace Archimedes {
 }
 
 #endif
+#endif

include/utils/Window/WindowImpl/WindowSDL3/WindowSDL3.h

@@ -1,5 +1,6 @@
 #ifdef WINDOW_SDL3
-#undef WINDOW_SDL3
+#ifndef WINDOW_SDL3_H
+#define WINDOW_SDL3_H
 
 #include "pch.hpp"
 
@@ -7,7 +8,7 @@
 
 #include <SDL3/SDL.h>
 
-#if RENDERER == 1
+#ifdef RENDERER_OPENGL
 
 #include <SDL3/SDL_opengl.h>
 
@@ -76,13 +77,14 @@ namespace Archimedes {
                     std::abort();
                 }
 
-#if RENDERER == 1
+#ifdef RENDERER_OPENGL
                 SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
                 SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
                 SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
 
                 SDL_WindowFlags window_flags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIDDEN;
-#elif RENDERER == 2
+#endif
+#ifdef RENDERER_SDL3
                 SDL_WindowFlags window_flags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIDDEN | SDL_WINDOW_HIGH_PIXEL_DENSITY;
 #endif
 
@@ -94,7 +96,7 @@ namespace Archimedes {
                 }
                 SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
  
-#if RENDERER == 1
+#ifdef RENDERER_OPENGL
                 gl_context = SDL_GL_CreateContext(window);
 
                 if (gl_context == nullptr)
@@ -112,7 +114,7 @@ namespace Archimedes {
             }
 
             ~WindowSDL3() {
-#if RENDERER == 1
+#ifdef RENDERER_OPENGL
                 SDL_GL_DestroyContext(gl_context);
 #endif
                 SDL_RemoveEventWatch(EventCallback, &data);
@@ -123,7 +125,7 @@ namespace Archimedes {
             bool shouldClose() override { return false; }
 
             void swapBuffers() override { 
-#if RENDERER == 1
+#ifdef RENDERER_OPENGL
                 restoreContext();
                 SDL_GL_SwapWindow(window);
 #endif
@@ -136,8 +138,8 @@ namespace Archimedes {
             
             WindowSDL3* getWindowImpl() override { return this; };
 
-#if RENDERER == 1
-            void restoreContext() { SDL_GL_MakeCurrent(window, gl_context); }
+#ifdef RENDERER_OPENGL
+            void restoreContext() override { SDL_GL_MakeCurrent(window, gl_context); }
 #endif
             void getSize(int& w, int& h) override {
                 w = this->w;
@@ -150,14 +152,14 @@ namespace Archimedes {
             }
 
             SDL_Window* getWindow() { return window; }
-#if RENDERER == 1
+#ifdef RENDERER_OPENGL
             SDL_GLContext getContext() { return gl_context; }
 #endif
             WindowData data;
         
         private:
             SDL_Window* window;
-#if RENDERER == 1
+#ifdef RENDERER_OPENGL
             SDL_GLContext gl_context;
 #endif
 
@@ -165,3 +167,4 @@ namespace Archimedes {
 }
 
 #endif
+#endif

modules/Archimedes-Modules/TestTriangle/TestTriangle.cpp

@@ -18,13 +18,14 @@ TestTriangle::~TestTriangle() {
     if(app) {
         WindowModule* wm; { wm = (WindowModule*) moduleInstances[WindowModule()]; }
 
-        wm->getRenderer()->getCmdList().erase(rcmd_it);
 /*
 #if WINDOW == 2
         wm->removeEventFn(ecmd_it);
 #endif
 */
         wm->releaseWindow(window);
+
+        delete rt;
     }   
 }
 
@@ -33,104 +34,33 @@ void TestTriangle::onLoad() {
     WindowModule* wm; { wm = (WindowModule*) moduleInstances[WindowModule()]; }
     
     if(!wm) {
-        std::cout << "No WindowModule for ImguiModule!\n";
+        std::cout << "No WindowModule TestTriangle!\n";
         std::abort();
     }
 
     window = wm->aquireWindow();
 
+    window->getRenderer()->clearColor = { 0.2, 0.2, 0.4, 0.7 };
 
-    wm->getRenderer()->getCmdList().push_back([this](){
-            // draw our first triangle
-            glUseProgram(shaderProgram);
-            glBindVertexArray(VAO); // seeing as we only have a single VAO there's no need to bind it every time, but we'll do so to keep things a bit more organized
-            glDrawArrays(GL_TRIANGLES, 0, 3);
-            glBindVertexArray(0); // no need to unbind it every time 
-    });
-
-    rcmd_it = --wm->getRenderer()->getCmdList().end()++;
-
-
-    //////////////////////glew
-
-    /*
-    if(glewInit() != GLEW_OK) {
-        std::cout << "glew is not ok!" << std::endl;
-        std::abort();
-    }
-    */
-   ///////////////////////////////NUCLEAR
-   
-
-    // build and compile our shader program
-    // ------------------------------------
-    // vertex shader
-    unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
-    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
-    glCompileShader(vertexShader);
-    // check for shader compile errors
-    int success;
-    char infoLog[512];
-    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
-    if (!success)
-    {
-        glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
-        std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
-    }
-    // fragment shader
-    unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
-    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
-    glCompileShader(fragmentShader);
-    // check for shader compile errors
-    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
-    if (!success)
-    {
-        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
-        std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
-    }
-    // link shaders
-    shaderProgram = glCreateProgram();
-    glAttachShader(shaderProgram, vertexShader);
-    glAttachShader(shaderProgram, fragmentShader);
-    glLinkProgram(shaderProgram);
-    // check for linking errors
-    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
-    if (!success) {
-        glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
-        std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
-    }
-    glDeleteShader(vertexShader);
-    glDeleteShader(fragmentShader);
-
-    // set up vertex data (and buffer(s)) and configure vertex attributes
-    // ------------------------------------------------------------------
-
-    glGenVertexArrays(1, &VAO);
-    glGenBuffers(1, &VBO);
-    // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
-    glBindVertexArray(VAO);
-
-    glBindBuffer(GL_ARRAY_BUFFER, VBO);
-    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
-
-    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
-    glEnableVertexAttribArray(0);
-
-    // note that this is allowed, the call to glVertexAttribPointer registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind
-    glBindBuffer(GL_ARRAY_BUFFER, 0); 
-
-    // You can unbind the VAO afterwards so other VAO calls won't accidentally modify this VAO, but this rarely happens. Modifying other
-    // VAOs requires a call to glBindVertexArray anyways so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary.
-    glBindVertexArray(0); 
-
-
-    // uncomment this call to draw in wireframe polygons.
-    //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+    rt = window->getRenderer()->createRenderTarget(
+            vertices, 
+            9 * sizeof(float), 
+            indices, 
+            3, 
+            Archimedes::VertexLayout(), 
+            vertexShaderSource, 
+            fragmentShaderSource, 
+            Archimedes::Shader::LoadType::FromSource
+        );
 
 }
 
 void TestTriangle::run() {
 
+    window->getRenderer()->render();
+    window->getRenderer()->draw(rt);
+    window->swapBuffers();
+    window->pollEvents();
 
 } 
 

modules/Archimedes-Modules/TestTriangle/TestTriangle.h

@@ -29,8 +29,6 @@ class TestTriangle : public Archimedes::Module {
 
         Archimedes::Window* window;
         
-        std::list<std::function<void()>>::iterator rcmd_it;
-
         const char *vertexShaderSource = "#version 330 core\n"
             "layout (location = 0) in vec3 aPos;\n"
             "void main()\n"
@@ -44,14 +42,21 @@ class TestTriangle : public Archimedes::Module {
             "   FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
             "}\n\0";
 
-        unsigned int shaderProgram;
-        unsigned int VBO, VAO;
+        Archimedes::RenderTarget* rt;
         
         float vertices[9] = {
             -0.5f, -0.5f, 0.0f, // left  
             0.5f, -0.5f, 0.0f, // right 
             0.0f,  0.5f, 0.0f  // top   
         }; 
+
+        unsigned int indices[3] = {
+            0, // left  
+            1, // right 
+            2  // top   
+        }; 
+                
+        unsigned int vao, vbo, ibo, shaderProgram;
 };
 
 #ifdef TESTTRIANGLE_DYNAMIC

modules/ImguiModule/ImguiModule.cpp

@@ -15,9 +15,7 @@ ImguiModule::~ImguiModule() {
     if(app) {
         WindowModule* wm; { wm = (WindowModule*) moduleInstances[WindowModule()]; }
 
-        wm->getRenderer()->getCmdList().erase(rcmd_it);
-
-#if WINDOW == 2
+#ifdef WINDOW_SDL3
         wm->removeEventFn(ecmd_it);
 #endif
 
@@ -40,8 +38,8 @@ void ImguiModule::onLoad() {
 
     window = wm->aquireWindow();
 
-#if RENDERER == 2
-    renderer = window->getRenderer()->getRendererImpl().renderer;
+#ifdef RENDERER_SDL3
+    renderer = window->getRenderer()->getRendererImpl()->renderer;
 #endif
     
     IMGUI_CHECKVERSION();
@@ -80,21 +78,6 @@ void ImguiModule::onLoad() {
         std::cout << "rendererInit failed!\n" << std::endl;
     }
 
-    wm->getRenderer()->getCmdList().push_back([this](){
-        ImGui::Render();
-
-        rendererRenderDrawData();
-
-        if(ImGui::GetIO().ConfigFlags & ImGuiConfigFlags_ViewportsEnable) {
-            ImGui::UpdatePlatformWindows();
-            ImGui::RenderPlatformWindowsDefault();
-
-            window->getWindowImpl().restoreContext();
-        }
-    });
-
-    rcmd_it = --wm->getRenderer()->getCmdList().end()++;
-
 #if WINDOW == 2
     ecmd_it = wm->addEventFn([](Archimedes::Event* e){
         if(e->userData.type() == typeid(SDL_Event*)) {
@@ -113,6 +96,17 @@ void ImguiModule::run() {
     rendererNewFrame();
     windowNewFrame();
     ImGui::NewFrame();
+
+    ImGui::Render();
+
+    rendererRenderDrawData();
+
+    if(ImGui::GetIO().ConfigFlags & ImGuiConfigFlags_ViewportsEnable) {
+        ImGui::UpdatePlatformWindows();
+        ImGui::RenderPlatformWindowsDefault();
+
+        window->getWindowImpl()->restoreContext();
+    }
 };
 
 bool ImguiModule::onEvent(const Archimedes::Event &e) {

modules/ImguiModule/ImguiModule.h

@@ -6,22 +6,24 @@
 
 #include "modules/WindowModule/WindowModule.h"
 
-#if RENDERER == 1
+#ifdef RENDERER_OPENGL
 
 #include "backends/imgui_impl_opengl3.h"
 
-#elif RENDERER == 2
+#endif
+#ifdef RENDERER_SDL3
 
 #include "backends/imgui_impl_sdlrenderer3.h"
 
 #endif
 
-#if WINDOW == 1
+#ifdef WINDOW_GLFW
 
 #include "backends/imgui_impl_glfw.h"
 #include <GLFW/glfw3.h>
 
-#elif WINDOW == 2
+#endif
+#ifdef WINDOW_SDL3
 
 #include "backends/imgui_impl_sdl3.h"
 #include <SDL3/SDL.h>
@@ -68,14 +70,14 @@ class ImguiModule : public Archimedes::Module {
         
         std::list<std::function<void(Archimedes::Event*)>>::iterator ecmd_it;
 
-#if RENDERER == 1
+#ifdef RENDERER_OPENGL
         auto rendererInit() { return ImGui_ImplOpenGL3_Init("#version 330"); }
         void rendererShutdown() { ImGui_ImplOpenGL3_Shutdown(); }
 
         void rendererNewFrame() { ImGui_ImplOpenGL3_NewFrame(); }
         void rendererRenderDrawData() { ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData()); }
-
-#elif RENDERER == 2
+#endif
+#ifdef RENDERER_SDL3
         SDL_Renderer* renderer;
         auto rendererInit() { return ImGui_ImplSDLRenderer3_Init(renderer); }
         void rendererShutdown() { ImGui_ImplSDLRenderer3_Shutdown(); }
@@ -84,19 +86,22 @@ class ImguiModule : public Archimedes::Module {
         void rendererRenderDrawData() { ImGui_ImplSDLRenderer3_RenderDrawData(ImGui::GetDrawData(), renderer); }
 #endif
 
-#if WINDOW == 1
-#if RENDERER == 1
-        auto windowInit() { return ImGui_ImplGlfw_InitForOpenGL(window->getWindowImpl().getWindow(), true); }
+#ifdef WINDOW_GLFW
+#ifdef RENDERER_OPENGL
+        auto windowInit() { return ImGui_ImplGlfw_InitForOpenGL(window->getWindowImpl()->getWindow(), true); }
 #endif
 
         void windowShutdown() { ImGui_ImplGlfw_Shutdown(); }
 
         void windowNewFrame() { ImGui_ImplGlfw_NewFrame(); }
 
-#elif WINDOW == 2
-#if RENDERER == 1
+#endif
+
+#ifdef WINDOW_SDL3
+#ifdef RENDERER_OPENGL
         auto windowInit() { return ImGui_ImplSDL3_InitForOpenGL(window->getWindowImpl().getWindow(), window->getWindowImpl().getContext()); }
-#elif RENDERER == 2
+#endif
+#ifdef RENDERER_SDL3
         auto windowInit() { return ImGui_ImplSDL3_InitForSDLRenderer(window->getWindowImpl().getWindow(), renderer); }
 #endif
 

modules/WindowModule/WindowModule.cpp

@@ -15,7 +15,6 @@ WindowModule::~WindowModule() {
         app->unregisterEvent(Archimedes::MovedWindowEvent());
 
         if(renderer) {
-            renderer->getCmdList().clear();
             delete renderer;
         }
 
@@ -38,15 +37,16 @@ void WindowModule::onLoad() {
     app->registerEvent(Archimedes::FocusLostWindowEvent());
     app->registerEvent(Archimedes::MovedWindowEvent());
 
-    renderer = new Archimedes::Renderer();
+    renderer = new Archimedes::RendererOpenGL();
 }
 
 void WindowModule::run() {
 
-    if(window)
-        window->doFrame();
-    else
+    if(window) {
+        //window->doFrame();
+    } else {
         app->emitEvent(new Archimedes::DoUnloadModuleEvent(name));
+    }
 }
         
 bool WindowModule::onEvent(const Archimedes::Event& e) {

modules/WindowModule/WindowModule.h

@@ -3,10 +3,8 @@
 
 #include "Archimedes.h"
 
-#include "utils/Renderer/Renderer.h"
-#include "utils/Window/Window.h"
-
-static_assert(!(WINDOW == 1 && RENDERER == 2), "Window and Renderer are incompatible!\n");
+#include "utils/Renderer/RendererImpl/RendererOpenGL/RendererOpenGL.h"
+#include "utils/Window/WindowImpl/WindowGLFW/WindowGLFW.h"
 
 class WindowModule : public Archimedes::Module {
 
@@ -30,7 +28,7 @@ class WindowModule : public Archimedes::Module {
         Archimedes::Window* aquireWindow() {
             if(!window) {
                 
-                window = new Archimedes::Window([this](Archimedes::Event* e) {
+                window = new Archimedes::WindowGLFW([this](Archimedes::Event* e) {
                     for(std::function<void(Archimedes::Event*)> f : eventFuncs)
                         f(e);
                     app->emitEvent(e);
@@ -39,15 +37,15 @@ class WindowModule : public Archimedes::Module {
                 window->setRenderer(renderer);
 
                 
-                if(!renderer->init(window->getWindowImpl().getWindow())) {
+                if(!renderer->init()) {
                     std::cout << "Renderer init failed!\n";
                     std::abort();
                 }
             }
             
             windowRefs++;
-#if RENDERER == 1
-            window->getWindowImpl().restoreContext();
+#ifdef RENDERER_OPENGL
+            window->getWindowImpl()->restoreContext();
 #endif
             return window;
         }
@@ -73,8 +71,8 @@ class WindowModule : public Archimedes::Module {
 
         std::list<std::function<void(Archimedes::Event*)>> eventFuncs;
 
-        Archimedes::Window* window = nullptr;
-        Archimedes::Renderer* renderer = nullptr;
+        Archimedes::WindowGLFW* window = nullptr;
+        Archimedes::RendererOpenGL* renderer = nullptr;
 
 };
 

src/example_apps/TriangleEmbed/TriangleEmbed.cpp

@@ -0,0 +1,71 @@
+#include "TriangleEmbed.h"
+
+bool TriangleEmbed::onEvent(const Archimedes::Event& event) {
+
+    unsigned int type = getEventType(event);
+
+    if(type == getEventType(Archimedes::DoLoadModuleEvent())) {
+    
+        Archimedes::DoLoadModuleEvent& e = (Archimedes::DoLoadModuleEvent&) event;
+
+        startModule(e.module);
+
+        return true;
+
+    } else if(type == getEventType(Archimedes::DoUnloadModuleEvent())) {
+    
+        Archimedes::DoUnloadModuleEvent& e = (Archimedes::DoUnloadModuleEvent&) event;
+
+        stopModule(e.module);
+
+        return true;
+
+    } else if(type == getEventType(Archimedes::LoadModuleEvent())) {
+
+        return true;
+    } else if(type == getEventType(Archimedes::UnloadModuleEvent())) {
+
+        return true; 
+    } else if(type == getEventType(Archimedes::AnonymousEvent())) {
+        return true;
+    }
+
+    return false;
+}
+
+void TriangleEmbed::run() {
+
+    for(std::string m : runOrder) {
+        modules[m]->onLoad();
+    }
+
+
+    // Main loop
+    while (!done && !runOrder.empty()) {
+
+        for(std::string m : runOrder) {
+            modules[m]->run();
+        }
+
+        handleEvents();
+
+        for(std::string m : toClose) {
+            unload(m);
+        }
+        toClose.clear();
+
+        for(auto m : toOpen) {
+            static Archimedes::Module* n;
+            if(std::holds_alternative<std::string>(m)) {
+                n = load(std::get<std::string>(m));
+            } else {
+                n = load(std::get<Archimedes::Module*>(m));
+            }
+            if(n) {
+                n->onLoad();
+                n = nullptr;
+            }
+        }
+        toOpen.clear();
+    }
+}

src/example_apps/TriangleEmbed/TriangleEmbed.h

@@ -0,0 +1,29 @@
+#define ENTRYPOINT
+#include "Archimedes.h"
+
+#include "modules/Archimedes-Modules/TestTriangle/TestTriangle.h"
+
+class TriangleEmbed : public Archimedes::App {
+
+    private:
+
+        void printHelp() override {};
+
+        bool onEvent(const Archimedes::Event&) override;
+    
+    public:
+        TriangleEmbed() {
+            Archimedes::Module* m = (Archimedes::Module*) new TestTriangle(Get(), nullptr);
+
+            load(m);
+        };
+        ~TriangleEmbed() {};
+
+        void handleArgs(const int& argc, char* argv[]) override {};
+        
+        void run() override;
+
+};
+
+#define APP_TYPE TriangleEmbed
+#include "endApp.h"