polymorphic windows

flake.nix

@@ -279,8 +279,9 @@
                     sdl3
 
                     curl
-
+                    glm
                     nlohmann_json
+                    stb
 
                     gamenetworkingsockets
 

include/extratools.h

@@ -0,0 +1,8 @@
+#ifndef EXTRATOOLS_H
+#define EXTRATOOLS_H
+
+#include <glm/glm.hpp>
+#include <nlohmann/json.hpp>
+#include <curl/curl.h>
+
+#endif

include/pch.hpp

@@ -17,6 +17,7 @@
 #include <optional>
 #include <chrono>
 //#include <thread>
+#include <concepts>
 
 #include <dlfcn.h>
 

include/utils/Objects/Object.h

@@ -0,0 +1,22 @@
+#ifndef OBJECT_H
+#define OBJECT_H
+
+#include "pch.hpp"
+
+#include "extratools.h"
+
+namespace Archimedes {
+
+    class Object {
+    
+        public:
+            Object() {};
+            ~Object() {};
+        
+        private:
+           
+            
+    };
+}
+
+#endif

include/utils/Renderer/Renderer.h

@@ -2,32 +2,35 @@
 #define RENDERER_H
 
 #include "pch.hpp"
-#include "RendererOpenGL/RendererOpenGL.h"
-#include "RendererSDL3/RendererSDL3.h"
 
 namespace Archimedes {
+
+
+    class VertexArray {};
+
+    class IndexArray {};
+
+    class Shader {};
+
     class Renderer {
 
         public:
             int w, h;
+            
+            Renderer() {}
+            virtual ~Renderer() = 0;
 
-            ~Renderer() {}
+            virtual bool init() = 0;
 
-            bool init(void* ptr) { return r.init(ptr); }
+            virtual void render() = 0;
-
-            void render() {
-                r.render(rc, w, h);
-            }
 
             std::list<std::function<void()>>& getCmdList() {
                 return rc;
             }
 
-            RendererImpl& getRendererImpl() { return r; }
 
         private:
             std::list<std::function<void()>> rc;
-            RendererImpl r;
     };
 }
 

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

@@ -1,17 +1,17 @@
-#if RENDERER == 1
-
 #ifndef RENDERER_OPENGL
 #define RENDERER_OPENGL
 
 #include "pch.hpp"
 
+#include "utils/Renderer/Renderer.h"
+
 #define GLEW_STATIC
 #include <GL/glew.h>
 
 
 namespace Archimedes {
 
-    class RendererOpenGL {
+    class RendererOpenGL : public Renderer {
     
         public:
             typedef void renderCmd();
@@ -19,7 +19,7 @@ namespace Archimedes {
             RendererOpenGL() {};
             ~RendererOpenGL() {};
 
-            bool init(void* p) { 
+            bool init() { 
                 return glewInit() == GLEW_OK;
             };
 
@@ -29,16 +29,10 @@ namespace Archimedes {
                 glClearColor(0.2, 0.2, 0.4, 1);
                 glClear(GL_COLOR_BUFFER_BIT);
 
-                for(auto f : cmdList)
-                    f();
             }
+
+            void draw() {}
     };
-
-    typedef RendererOpenGL RendererImpl;
-
-
 }
 
 #endif
-
-#endif

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

@@ -1,5 +1,3 @@
-#if RENDERER == 2
-
 #ifndef RENDERER_SDL3
 #define RENDERER_SDL3
 
@@ -38,12 +36,6 @@ namespace Archimedes {
 
         SDL_Renderer* renderer = nullptr;
     };
-
-    typedef RendererSDL3 RendererImpl;
-
-
 }
 
 #endif
-
-#endif

include/utils/Renderer/concepts.h

@@ -0,0 +1,21 @@
+#ifndef RENDERER_CONCEPTS
+#define RENDERER_CONCEPTS
+
+#include "pch.hpp"
+
+namespace Archimedes {
+
+    class RendererOpenGL;
+
+    class RendererSDL3;
+
+    template <class RendererImpl>
+    concept allowed_renderers = requires (RendererImpl r) {
+#ifndef CUSTOM_RENDERER
+        requires std::same_as<RendererImpl, RendererOpenGL>
+            || std::same_as<RendererImpl, RendererSDL3>;
+#endif
+    };
+}
+
+#endif

include/utils/Window/Window.h

@@ -4,8 +4,6 @@
 #include "WindowEvents.h"
 
 #include "utils/Renderer/Renderer.h"
-#include "WindowGLFW/WindowGLFW.h"
-#include "WindowSDL3/WindowSDL3.h"
 
 namespace Archimedes {
 
@@ -13,34 +11,44 @@ namespace Archimedes {
 
         public:
 
-            Window(const std::function<void(Event*)>& sendEventFn) : window(this, sendEventFn) {}
+            Window(const std::function<void(Event*)>& sendEventFn) : eventFn(sendEventFn) {}
 
-            ~Window() {}
+            virtual ~Window() = 0;
 
-            bool shouldClose() { return window.shouldClose(); }
-
-            void getSize(int& w, int& h) {
-                window.getSize(w, h);
-            }
 
             void doFrame() {
 
                 renderer->render();
 
-                window.doFrame();
+                swapBuffers();
+
+                pollEvents();
                 
-                window.pollEvents();
+            }
+
+            virtual bool shouldClose() = 0;
+            
+            virtual void swapBuffers() = 0;
+
+            virtual void pollEvents() = 0;
+            
+            virtual void getSize(int& w, int& h) {
+                w = this->w;
+                h = this->h;
             }
 
             Renderer* getRenderer() { return renderer; }
             void setRenderer(Renderer* r) { renderer = r; }
 
-            WindowImpl& getWindowImpl() { return window; }
+            virtual Window* getWindowImpl() = 0;
+
+        protected:
+
+            int w, h;
 
-        private:
             Renderer* renderer;
 
-            WindowImpl window;
+            std::function<void(Event*)> eventFn;
     };
 }
 

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

@@ -5,7 +5,7 @@
 
 #include "pch.hpp"
 
-#include "utils/Window/WindowEvents.h"
+#include "utils/Window/Window.h"
 
 #define GLFW_INCLUDE_NONE
 #include <GLFW/glfw3.h>
@@ -13,20 +13,13 @@
 
 namespace Archimedes {
 
-    class Window;
+    class WindowGLFW : public Window {
-
-    class WindowGLFW {
 
         public:
 
-            WindowGLFW(Window* p, const std::function<void(Event*)>& sendEvent) {
+            WindowGLFW(const std::function<void(Event*)>& sendEvent) : Window(sendEvent) {
 
-                /*if(glfwPlatformSupported(GLFW_PLATFORM_WAYLAND)) {
+                data.window = this;
-                    glfwInitHint(GLFW_PLATFORM, GLFW_PLATFORM_WAYLAND);
-                }*/
-
-
-                data.window = p;
                 data.sendEvent = sendEvent;
 
                 glfwSetErrorCallback([](int e, const char* m){
@@ -42,31 +35,31 @@ namespace Archimedes {
                 glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
                 glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
 #endif
-                w = glfwCreateWindow(640, 480, "Archimedes", NULL, NULL);
+                window = glfwCreateWindow(640, 480, "Archimedes", NULL, NULL);
 
                 if(!w) {
                     std::cout << "glfwCreateWindow failed!\n";
                     glfwTerminate();
                     std::abort();
                 }
-                glfwMakeContextCurrent(w);
+                glfwMakeContextCurrent(window);
                 glfwSwapInterval(1);
 
-                glfwSetWindowUserPointer(w, &data);
+                glfwSetWindowUserPointer(window, &data);
 
-                glfwSetWindowSizeCallback(w, [](GLFWwindow* window, int w, int h){
+                glfwSetWindowSizeCallback(window, [](GLFWwindow* window, int w, int h){
                     WindowData& d = *(WindowData*) glfwGetWindowUserPointer(window);
 
                     d.sendEvent(new ResizeWindowEvent(w, h));
                 });
                 
-                glfwSetWindowCloseCallback(w, [](GLFWwindow* window){
+                glfwSetWindowCloseCallback(window, [](GLFWwindow* window){
                     WindowData& d = *(WindowData*) glfwGetWindowUserPointer(window);
 
                     d.sendEvent(new CloseWindowEvent(d.window));
                 });
 
-                glfwSetKeyCallback(w, [](GLFWwindow* window, int key, int scancode, int action, int mods){
+                glfwSetKeyCallback(window, [](GLFWwindow* window, int key, int scancode, int action, int mods){
                     WindowData& d = *(WindowData*) glfwGetWindowUserPointer(window);
 
                     switch(action) {
@@ -82,7 +75,7 @@ namespace Archimedes {
                     }
                 });
 
-                glfwSetMouseButtonCallback(w, [](GLFWwindow* window, int button, int action, int mods){
+                glfwSetMouseButtonCallback(window, [](GLFWwindow* window, int button, int action, int mods){
                     WindowData& d = *(WindowData*) glfwGetWindowUserPointer(window);
 
                     switch(action) {
@@ -95,13 +88,13 @@ namespace Archimedes {
                     }
                 });
 
-                glfwSetScrollCallback(w, [](GLFWwindow* window, double dx, double dy){
+                glfwSetScrollCallback(window, [](GLFWwindow* window, double dx, double dy){
                     WindowData& d = *(WindowData*) glfwGetWindowUserPointer(window);
 
                     d.sendEvent(new ScrollWindowEvent(dx, dy));
                 });
 
-                glfwSetCursorPosCallback(w, [](GLFWwindow* window, double dx, double dy){
+                glfwSetCursorPosCallback(window, [](GLFWwindow* window, double dx, double dy){
                     WindowData& d = *(WindowData*) glfwGetWindowUserPointer(window);
 
                     d.sendEvent(new MouseMovedWindowEvent(dx, dy));
@@ -113,31 +106,31 @@ namespace Archimedes {
             }
 
 
-            bool shouldClose() {
+            void swapBuffers() override { restoreContext(); glfwSwapBuffers(window); };
-                return glfwWindowShouldClose(w);
+
+            void pollEvents() override { glfwPollEvents(); }
+
+            bool shouldClose() override {
+                return glfwWindowShouldClose(window);
             }
 
-            void doFrame() { restoreContext(); glfwSwapBuffers(w); }
+            void restoreContext() { glfwMakeContextCurrent(window); }
 
-            void pollEvents() { glfwPollEvents(); }
+            void getSize(int& w, int& h) override {
-
+                glfwGetFramebufferSize(window, &w, &h);
-            void restoreContext() { glfwMakeContextCurrent(w); }
-
-            void getSize(int& w, int& h) {
-                glfwGetFramebufferSize(this->w, &w, &h);
             }
 
-            GLFWwindow* getWindow() { return w; }
+            GLFWwindow* getWindow() { return window; }
 
             WindowData data;
+            
+            virtual WindowGLFW* getWindowImpl() override { return this; }
         
         private:
-            GLFWwindow* w;
+            GLFWwindow* window;
 
     };
 
-    typedef WindowGLFW WindowImpl;
-
 }
 
 #endif

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

@@ -5,7 +5,7 @@
 
 #include "pch.hpp"
 
-#include "utils/Window/WindowEvents.h"
+#include "utils/Window/Window.h"
 
 #include <SDL3/SDL.h>
 
@@ -17,8 +17,6 @@
 
 namespace Archimedes {
 
-    class Window;
-
     static bool EventCallback(void* ptr, SDL_Event* e) {
 
         WindowData& data = *(WindowData*) ptr;
@@ -66,13 +64,13 @@ namespace Archimedes {
         return true;
     }
 
-    class WindowSDL3 {
+    class WindowSDL3 : public Window {
 
         public:
 
-            WindowSDL3(Window* p, const std::function<void(Event*)>& sendEvent) {
+            WindowSDL3(const std::function<void(Event*)>& sendEvent) : Window(sendEvent) {
 
-                data.window = p;
+                data.window = this;
                 data.sendEvent = sendEvent;
 
                 if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD)) {
@@ -90,16 +88,16 @@ namespace Archimedes {
                 SDL_WindowFlags window_flags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIDDEN | SDL_WINDOW_HIGH_PIXEL_DENSITY;
 #endif
 
-                w = SDL_CreateWindow("Archimedes", 1280, 720, window_flags);
+                window = SDL_CreateWindow("Archimedes", 1280, 720, window_flags);
-                if (w == nullptr)
+                if (window == nullptr)
                 {
                     std::cerr << "Error: SDL_CreateWindow(): " << SDL_GetError() << std::endl;
                     std::abort();
                 }
-                SDL_SetWindowPosition(w, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
+                SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
  
 #if RENDERER == 1
-                gl_context = SDL_GL_CreateContext(w);
+                gl_context = SDL_GL_CreateContext(window);
 
                 if (gl_context == nullptr)
                 {
@@ -107,12 +105,12 @@ namespace Archimedes {
                     std::abort();
                 }
 
-                SDL_GL_MakeCurrent(w, gl_context);
+                SDL_GL_MakeCurrent(window, gl_context);
                 SDL_GL_SetSwapInterval(1); // Enable vsync
 #endif               
                 SDL_AddEventWatch(EventCallback, &data);
 
-                SDL_ShowWindow(w);
+                SDL_ShowWindow(window);
             }
 
             ~WindowSDL3() {
@@ -120,52 +118,52 @@ namespace Archimedes {
                 SDL_GL_DestroyContext(gl_context);
 #endif
                 SDL_RemoveEventWatch(EventCallback, &data);
-                SDL_DestroyWindow(w);
+                SDL_DestroyWindow(window);
                 SDL_Quit();
             }
 
-            bool shouldClose() { return false; }
+            bool shouldClose() override { return false; }
 
-            void doFrame() { 
+            void swapBuffers() override { 
 #if RENDERER == 1
                 restoreContext();
-                SDL_GL_SwapWindow(w);
+                SDL_GL_SwapWindow(window);
 #endif
             }
 
-            void pollEvents() {
+            void pollEvents() override {
                 static SDL_Event e;
-                while(SDL_PollEvent(&e)) {}
+                while(SDL_PollEvent(&e));
             }
+            
+            WindowSDL3* getWindowImpl() { return this; };
+
 #if RENDERER == 1
-            void restoreContext() { SDL_GL_MakeCurrent(w, gl_context); }
+            void restoreContext() { SDL_GL_MakeCurrent(window, gl_context); }
 #endif
-            void getSize(int& w, int& h) {
+            void getSize(int& w, int& h) override {
-                w = this->width;
+                w = this->w;
-                h = this->height;
+                h = this->h;
             }
 
             void setSize(int& w, int& h) {
-                this->width = w;
+                this->w = w;
-                this->height = h;
+                this->h = h;
             }
 
-            SDL_Window* getWindow() { return w; }
+            SDL_Window* getWindow() { return window; }
 #if RENDERER == 1
             SDL_GLContext getContext() { return gl_context; }
 #endif
             WindowData data;
         
         private:
-            SDL_Window* w;
+            SDL_Window* window;
-            int width = 0, height = 0;
 #if RENDERER == 1
             SDL_GLContext gl_context;
 #endif
 
     };
-
-    typedef WindowSDL3 WindowImpl;
 }
 
 #endif

include/utils/Window/concepts.h

@@ -0,0 +1,25 @@
+#ifndef WINDOW_CONCEPTS
+#define WINDOW_CONCEPTS
+
+#include "pch.hpp"
+
+#include "utils/Renderer/concepts.h"
+
+namespace Archimedes {
+
+    template <class R>
+    class WindowGLFW;
+
+    template <class R>
+    class WindowSDL3;
+
+    template <class WindowImpl, class R>
+    concept allowed_windows = requires (WindowImpl a, R b) {
+#ifndef CUSTOM_WINDOW
+        requires std::same_as<WindowImpl, WindowGLFW<R>>
+            || std::same_as<WindowImpl, WindowSDL3<R>>;
+#endif
+    };
+}
+
+#endif

modules/Archimedes-Modules/Ollama/Ollama.h

@@ -1,7 +1,6 @@
 #include "Archimedes.h"
 
-#include <curl/curl.h>
+#include "extratools.h"
-#include <nlohmann/json.hpp>
 
 class Ollama : public Archimedes::Module {