add Audio

flake.nix

@@ -182,7 +182,6 @@
 
                 buildInputs = with pkgs; [
                     sdl3
-                    glew
                 ];
 
                 buildPhase = ''
@@ -191,15 +190,15 @@
                     modules/ImguiModule/src/*.cpp \
                     modules/WindowModule/src/*.cpp \
                     $imgui/backends/imgui_impl_sdl3.cpp \
-                    $imgui/backends/imgui_impl_opengl3.cpp \
+                    $imgui/backends/imgui_impl_sdlrenderer3.cpp \
                     $imgui/misc/cpp/*.cpp \
                     $imgui/*.cpp \
-                    -DRENDERER=1 \
+                    -DRENDERER=2 \
                     -DWINDOW=2 \
                     -DMAINGUI_DYNAMIC \
                     -fpic -shared \
                     -I src -I include -I $imgui -I . \
-                    -lGL -lSDL3 -lGLEW \
+                    -lSDL3 \
                     -Wall \
                     -o $name 
                 ''; 

include/utils/Audio/Audio.h

@@ -0,0 +1,13 @@
+#ifndef AUDIO_H
+#define AUDIO_H
+
+#include <SDL3/SDL_audio.h>
+
+namespace Archimedes {
+
+    class Audio {
+
+    };
+}
+
+#endif

include/utils/Renderer/Renderer.h

@@ -3,6 +3,7 @@
 
 #include "pch.hpp"
 #include "RendererOpenGL/RendererOpenGL.h"
+#include "RendererSDL3/RendererSDL3.h"
 
 namespace Archimedes {
     class Renderer {
@@ -12,7 +13,7 @@ namespace Archimedes {
 
             ~Renderer() {}
 
-            bool init() { return r.init(); }
+            bool init(void* ptr) { return r.init(ptr); }
 
             void render() {
                 r.render(rc, w, h);
@@ -22,6 +23,8 @@ namespace Archimedes {
                 return rc;
             }
 
+            RendererImpl& getRendererImpl() { return r; }
+
         private:
             std::list<std::function<void()>> rc;
             RendererImpl r;

include/utils/Renderer/RendererOpenGL/RendererOpenGL.h

@@ -19,7 +19,7 @@ namespace Archimedes {
             RendererOpenGL() {};
             ~RendererOpenGL() {};
 
-            bool init() { 
+            bool init(void* p) { 
                 return glewInit() == GLEW_OK;
             };
 

include/utils/Renderer/RendererSDL3/RendererSDL3.h

@@ -0,0 +1,49 @@
+#if RENDERER == 2
+
+#ifndef RENDERER_SDL3
+#define RENDERER_SDL3
+
+#include "pch.hpp"
+
+#include <SDL3/SDL.h>
+
+
+namespace Archimedes {
+
+    class RendererSDL3 {
+    
+        public:
+            typedef void renderCmd();
+
+            RendererSDL3() {};
+            ~RendererSDL3() { SDL_DestroyRenderer(renderer); };
+
+            bool init(void* window) {
+                renderer = SDL_CreateRenderer((SDL_Window*) window, nullptr);
+                SDL_SetRenderVSync(renderer, 1);
+                return renderer != nullptr;
+            };
+
+            void render(std::list<std::function<void()>> cmdList, int& w, int& h) {
+
+                //SDL_SetRenderScale(renderer, w, h);
+
+                SDL_RenderClear(renderer);
+
+                for(auto f : cmdList)
+                    f();
+
+                SDL_RenderPresent(renderer);
+            }
+
+        SDL_Renderer* renderer = nullptr;
+    };
+
+    typedef RendererSDL3 RendererImpl;
+
+
+}
+
+#endif
+
+#endif

include/utils/Window/Window.h

@@ -25,11 +25,11 @@ namespace Archimedes {
 
             void doFrame() {
 
-                window.pollEvents();
-
                 renderer->render();
 
                 window.doFrame();
+                
+                window.pollEvents();
             }
 
             Renderer* getRenderer() { return renderer; }

include/utils/Window/WindowSDL3/WindowSDL3.h

@@ -9,12 +9,63 @@
 
 #include <SDL3/SDL.h>
 
+#if RENDERER == 2
+
 #include <SDL3/SDL_opengl.h>
 
+#endif
+
 namespace Archimedes {
 
     class Window;
 
+    static bool EventCallback(void* ptr, SDL_Event* e) {
+
+        WindowData& data = *(WindowData*) ptr;
+
+        switch(e->type) {
+
+            case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
+            case SDL_EVENT_QUIT:
+                data.sendEvent(new CloseWindowEvent(data.window, e));
+                break;
+            case SDL_EVENT_WINDOW_RESIZED:
+                data.sendEvent(new ResizeWindowEvent(e->window.data1, e->window.data2, e));
+                break;
+            case SDL_EVENT_WINDOW_MOUSE_ENTER:
+            case SDL_EVENT_WINDOW_FOCUS_GAINED:
+                data.sendEvent(new FocusedWindowEvent(data.window, e));
+                break;
+            case SDL_EVENT_WINDOW_MOUSE_LEAVE:
+            case SDL_EVENT_WINDOW_FOCUS_LOST:
+                data.sendEvent(new FocusLostWindowEvent(data.window, e));
+                break;
+            case SDL_EVENT_KEY_DOWN:
+                data.sendEvent(new KeyPressedWindowEvent(e->key.key, e->key.repeat ? 1 : 0, e));
+                break;
+            case SDL_EVENT_KEY_UP:
+                data.sendEvent(new KeyReleasedWindowEvent(e->key.key, e));
+                break;
+            case SDL_EVENT_MOUSE_MOTION:
+                data.sendEvent(new MouseMovedWindowEvent(e->motion.x, e->motion.y, e));
+                break;
+            case SDL_EVENT_MOUSE_BUTTON_DOWN:
+                data.sendEvent(new MouseButtonPressedWindowEvent(e->button.button, e));
+                break;
+            case SDL_EVENT_MOUSE_BUTTON_UP:
+                data.sendEvent(new MouseButtonReleasedWindowEvent(e->button.button, e));
+                break;
+            case SDL_EVENT_MOUSE_WHEEL:
+                data.sendEvent(new ScrollWindowEvent(e->wheel.x, e->wheel.y, e));
+                break;
+            default:
+                data.sendEvent(new AnonymousEvent(e));
+                break;
+        }
+
+        return true;
+    }
+
     class WindowSDL3 {
 
         public:
@@ -24,158 +75,93 @@ namespace Archimedes {
                 data.window = p;
                 data.sendEvent = sendEvent;
 
+                if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD)) {
+                    std::cerr << "Error: SDL_Init(): " << SDL_GetError() << std::flush;
+                    std::abort();
+                }
+
+#if RENDERER == 1
                 SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
                 SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
                 SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
-                Uint32 window_flags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIDDEN;
+
+                SDL_WindowFlags window_flags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIDDEN;
+#elif RENDERER == 2
+                SDL_WindowFlags window_flags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIDDEN | SDL_WINDOW_HIGH_PIXEL_DENSITY;
+#endif
+
                 w = SDL_CreateWindow("Archimedes", 1280, 720, window_flags);
                 if (w == nullptr)
                 {
-                    printf("Error: SDL_CreateWindow(): %s\n", SDL_GetError());
+                    std::cerr << "Error: SDL_CreateWindow(): " << SDL_GetError() << std::endl;
                     std::abort();
                 }
                 SDL_SetWindowPosition(w, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
  
+#if RENDERER == 1
                 gl_context = SDL_GL_CreateContext(w);
 
                 if (gl_context == nullptr)
                 {
-                    printf("Error: SDL_GL_CreateContext(): %s\n", SDL_GetError());
+                    std::cerr << "Error: SDL_GL_CreateContext(): " << SDL_GetError() << std::endl;
                     std::abort();
                 }
 
-                /*SDL_AddEventWatch([](void* ptr, SDL_Event* e) -> bool {
-
-                    WindowData& data = (WindowData&) *ptr;
-
-                    switch(e.type) {
-
-                        case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
-                        case SDL_EVENT_QUIT:
-                            data.sendEvent(new CloseWindowEvent(data.window, (void*) &e));
-                            break;
-                        case SDL_EVENT_WINDOW_RESIZED:
-                            width = e.window.data1;
-                            height = e.window.data2;
-                            data.sendEvent(new ResizeWindowEvent(e.window.data1, e.window.data2, (void*) &e));
-                            break;
-                        case SDL_EVENT_WINDOW_MOUSE_ENTER:
-                        case SDL_EVENT_WINDOW_FOCUS_GAINED:
-                            data.sendEvent(new FocusedWindowEvent(data.window, (void*) &e));
-                            break;
-                        case SDL_EVENT_WINDOW_MOUSE_LEAVE:
-                        case SDL_EVENT_WINDOW_FOCUS_LOST:
-                            data.sendEvent(new FocusLostWindowEvent(data.window, (void*) &e));
-                            break;
-                        case SDL_EVENT_KEY_DOWN:
-                            data.sendEvent(new KeyPressedWindowEvent(e.key.key, e.key.repeat ? 1 : 0, (void*) &e));
-                            break;
-                        case SDL_EVENT_KEY_UP:
-                            data.sendEvent(new KeyReleasedWindowEvent(e.key.key, (void*) &e));
-                            break;
-                        case SDL_EVENT_TEXT_EDITING:
-                            break;
-                        case SDL_EVENT_TEXT_INPUT:
-                            break;
-                        case SDL_EVENT_MOUSE_MOTION:
-                            data.sendEvent(new MouseMovedWindowEvent(e.motion.x, e.motion.y, (void*) &e));
-                            break;
-                        case SDL_EVENT_MOUSE_BUTTON_DOWN:
-                            data.sendEvent(new MouseButtonPressedWindowEvent(e.button.button, (void*) &e));
-                            break;
-                        case SDL_EVENT_MOUSE_BUTTON_UP:
-                            data.sendEvent(new MouseButtonReleasedWindowEvent(e.button.button, (void*) &e));
-                            break;
-                        case SDL_EVENT_MOUSE_WHEEL:
-                            data.sendEvent(new ScrollWindowEvent(e.wheel.x, e.wheel.y, (void*) &e));
-                            break;
-                        default:
-                            break;
-                    }
-
-                    return true;
-                }, &data);*/
-
-
                 SDL_GL_MakeCurrent(w, gl_context);
                 SDL_GL_SetSwapInterval(1); // Enable vsync
+#endif               
+                SDL_AddEventWatch(EventCallback, &data);
+
                 SDL_ShowWindow(w);
             }
 
             ~WindowSDL3() {
+#if RENDERER == 1
                 SDL_GL_DestroyContext(gl_context);
+#endif
+                SDL_RemoveEventWatch(EventCallback, &data);
                 SDL_DestroyWindow(w);
                 SDL_Quit();
             }
 
             bool shouldClose() { return false; }
 
-            void doFrame() { restoreContext(); SDL_GL_SwapWindow(w); }
-
-            void pollEvents() {
-                while(SDL_PollEvent(&e)) {
-                    switch(e.type) {
-
-                        case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
-                        case SDL_EVENT_QUIT:
-                            data.sendEvent(new CloseWindowEvent(data.window, &e));
-                            break;
-                        case SDL_EVENT_WINDOW_RESIZED:
-                            width = e.window.data1;
-                            height = e.window.data2;
-                            data.sendEvent(new ResizeWindowEvent(e.window.data1, e.window.data2, &e));
-                            break;
-                        case SDL_EVENT_WINDOW_MOUSE_ENTER:
-                        case SDL_EVENT_WINDOW_FOCUS_GAINED:
-                            data.sendEvent(new FocusedWindowEvent(data.window, &e));
-                            break;
-                        case SDL_EVENT_WINDOW_MOUSE_LEAVE:
-                        case SDL_EVENT_WINDOW_FOCUS_LOST:
-                            data.sendEvent(new FocusLostWindowEvent(data.window, &e));
-                            break;
-                        case SDL_EVENT_KEY_DOWN:
-                            data.sendEvent(new KeyPressedWindowEvent(e.key.key, e.key.repeat ? 1 : 0, &e));
-                            break;
-                        case SDL_EVENT_KEY_UP:
-                            data.sendEvent(new KeyReleasedWindowEvent(e.key.key, &e));
-                            break;
-                        case SDL_EVENT_MOUSE_MOTION:
-                            data.sendEvent(new MouseMovedWindowEvent(e.motion.x, e.motion.y, &e));
-                            break;
-                        case SDL_EVENT_MOUSE_BUTTON_DOWN:
-                            data.sendEvent(new MouseButtonPressedWindowEvent(e.button.button, &e));
-                            break;
-                        case SDL_EVENT_MOUSE_BUTTON_UP:
-                            data.sendEvent(new MouseButtonReleasedWindowEvent(e.button.button, &e));
-                            break;
-                        case SDL_EVENT_MOUSE_WHEEL:
-                            data.sendEvent(new ScrollWindowEvent(e.wheel.x, e.wheel.y, &e));
-                            break;
-                        default:
-                            data.sendEvent(new AnonymousEvent(&e));
-                            break;
-                    }
-                }
+            void doFrame() { 
+#if RENDERER == 1
+                restoreContext();
+                SDL_GL_SwapWindow(w);
+#endif
             }
 
+            void pollEvents() {
+                static SDL_Event e;
+                while(SDL_PollEvent(&e)) {}
+            }
+#if RENDERER == 1
             void restoreContext() { SDL_GL_MakeCurrent(w, gl_context); }
-
+#endif
             void getSize(int& w, int& h) {
                 w = this->width;
                 h = this->height;
             }
 
+            void setSize(int& w, int& h) {
+                this->width = w;
+                this->height = h;
+            }
+
             SDL_Window* getWindow() { return w; }
-            
+#if RENDERER == 1
             SDL_GLContext getContext() { return gl_context; }
-
+#endif
             WindowData data;
         
         private:
             SDL_Window* w;
             int width = 0, height = 0;
+#if RENDERER == 1
             SDL_GLContext gl_context;
-            SDL_Event e;
+#endif
 
     };
 

modules/ImguiModule/src/ImguiModule.cpp

@@ -40,6 +40,10 @@ void ImguiModule::onLoad() {
 
     window = wm->aquireWindow();
 
+#if RENDERER == 2
+    renderer = window->getRenderer()->getRendererImpl().renderer;
+#endif
+    
     IMGUI_CHECKVERSION();
     context = ImGui::CreateContext();
     ImGuiIO& io = ImGui::GetIO(); (void)io;

modules/ImguiModule/src/ImguiModule.h

@@ -10,6 +10,10 @@
 
 #include "backends/imgui_impl_opengl3.h"
 
+#elif RENDERER == 2
+
+#include "backends/imgui_impl_sdlrenderer3.h"
+
 #endif
 
 #if WINDOW == 1
@@ -69,6 +73,13 @@ class ImguiModule : public Archimedes::Module {
         void rendererNewFrame() { ImGui_ImplOpenGL3_NewFrame(); }
         void rendererRenderDrawData() { ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData()); }
 
+#elif RENDERER == 2
+        SDL_Renderer* renderer;
+        auto rendererInit() { return ImGui_ImplSDLRenderer3_Init(renderer); }
+        void rendererShutdown() { ImGui_ImplSDLRenderer3_Shutdown(); }
+
+        void rendererNewFrame() { ImGui_ImplSDLRenderer3_NewFrame(); }
+        void rendererRenderDrawData() { ImGui_ImplSDLRenderer3_RenderDrawData(ImGui::GetDrawData(), renderer); }
 #endif
 
 #if WINDOW == 1
@@ -83,6 +94,8 @@ class ImguiModule : public Archimedes::Module {
 #elif WINDOW == 2
 #if RENDERER == 1
         auto windowInit() { return ImGui_ImplSDL3_InitForOpenGL(window->getWindowImpl().getWindow(), window->getWindowImpl().getContext()); }
+#elif RENDERER == 2
+        auto windowInit() { return ImGui_ImplSDL3_InitForSDLRenderer(window->getWindowImpl().getWindow(), renderer); }
 #endif
 
         void windowShutdown() { ImGui_ImplSDL3_Shutdown(); }

modules/WindowModule/src/WindowModule.cpp

@@ -57,6 +57,9 @@ bool WindowModule::onEvent(const Archimedes::Event& e) {
         Archimedes::ResizeWindowEvent& event = (Archimedes::ResizeWindowEvent&) e;
         renderer->w = event.width;
         renderer->h = event.height;
+#if WINDOW == 2
+        window->getWindowImpl().setSize(event.width, event.height);
+#endif
         return true;
     } else if(type == app->getEventType(Archimedes::CloseWindowEvent())) {
         app->emitEvent(new Archimedes::DoUnloadModuleEvent(name));

modules/WindowModule/src/WindowModule.h

@@ -6,6 +6,8 @@
 #include "utils/Renderer/Renderer.h"
 #include "utils/Window/Window.h"
 
+static_assert(!(WINDOW == 1 && RENDERER == 2), "Window and Renderer are incompatible!\n");
+
 class WindowModule : public Archimedes::Module {
 
     public:
@@ -37,14 +39,16 @@ class WindowModule : public Archimedes::Module {
                 window->setRenderer(renderer);
 
                 
-                if(!renderer->init()) {
+                if(!renderer->init(window->getWindowImpl().getWindow())) {
                     std::cout << "Renderer init failed!\n";
                     std::abort();
                 }
             }
             
             windowRefs++;
+#if RENDERER == 1
             window->getWindowImpl().restoreContext();
+#endif
             return window;
         }
 

src/example_apps/MinimalApp/MinimalApp.cpp

@@ -6,6 +6,7 @@ void MinimalApp::run() {
         modules[m]->onLoad();
     }
 
+
     // Main loop
     while (!done && !runOrder.empty()) {