create SDL window

src/App.cpp

@@ -1,18 +1,49 @@
 
 #include "App.hpp"
 
-void App::run() {
-
-    std::cout << "im an app and im running !!" << std::endl;
-
-    (void)foo();
-
-    return;
+#include <thread>
+#include <chrono>
+#include <SDL3/SDL_events.h>
 
+App::App(): window_(new Window()) {
+    // smart pointers might be a good idea
+    // since app will be the top level owner we can use unique ptrs for almost everything
 }
 
-int32_t App::foo() {
+int32_t App::run() {
 
-    return 12;
+    SDL_Event event;
+	while (window_->open()) {
+        // app loop for as long as the window is open
 
-}
+        // pass events to the window
+        while(SDL_PollEvent(&event) != 0) {
+            window_->handleEvent(event);
+        }
+
+        // pass vulkan handling to engine
+        // call engine.render() or something
+        // engine will have a pointer to window so can handle pushing to the screen
+
+        if(window_->rendering()) {
+            // engine.draw();
+
+            // TODO: performance profiling :3
+            // static int counter = 0;
+            // if(counter > 100) {
+            //     std::cout << "out" << std::endl;
+            //     counter = 0;
+            // }
+            // counter++;
+
+        } else {
+             // throttle while the window isn't active
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        }
+    }
+
+    // SDL teardown handled in window destructor
+
+    return 0; // maybe want to have an error codes enum for better clarity
+
+}

src/App.hpp

@@ -4,16 +4,20 @@
 #include <iostream>
 #include <cstdint>
 
+#include "Window.hpp"
+
 class App {
 
-    public:
-    App() = default;
+public:
+    App();
     ~App() = default;
 
-    void run();
+    int32_t run();
 
-    private:
+private:
 
-    int32_t foo();
+    Window* window_;
+
+    bool rendering_ = true;
 
 };

src/Window.cpp

@@ -0,0 +1,45 @@
+
+#include "Window.hpp"
+
+#include <SDL3/SDL_events.h>
+
+Window::Window() {
+
+    (void)init();
+
+}
+
+Window::~Window() {
+
+    SDL_DestroyWindow(sdlWindow_);
+    SDL_Quit();
+
+}
+
+int Window::init() {
+
+    // TODO: config service for controlling window parameters
+    sdlWindow_ = SDL_CreateWindow("Ouros: Vulkan", 1280u, 720u, SDL_WINDOW_VULKAN | SDL_WINDOW_RESIZABLE);
+
+    if(sdlWindow_ != nullptr) {
+        rendering_ = true;
+        open_ = true;
+        return 0;
+    } else {
+        return -1;
+    }
+
+}
+
+void Window::handleEvent(SDL_Event& event) {
+
+    if(event.type == SDL_EVENT_QUIT ) {
+        open_ = false;
+    }
+
+    if(event.type == SDL_EVENT_WINDOW_MINIMIZED) {
+        rendering_ = false;
+    } else if(event.type == SDL_EVENT_WINDOW_RESTORED) {
+        rendering_ = true;
+    }
+}

src/Window.hpp

@@ -0,0 +1,34 @@
+
+#pragma once
+
+#include "SDL3/SDL.h"
+#include "SDL3/SDL_vulkan.h"
+
+// reference: https://wiki.libsdl.org/SDL3/SDL_CreateWindow
+class Window {
+
+public:
+
+    Window();
+    ~Window();
+
+    // for SDL3 event polling, runs once per app iteration in its while(running) loop
+    void handleEvent(SDL_Event& event);
+
+    bool rendering() { return rendering_; }
+    bool open() { return open_; }
+
+private:
+
+    // launches window, runs at app startup
+    int init();
+
+    // this window class will eventually hold mouse, keyboard, audio, etc. interfaces, like an SDL3 hub
+    // app will be able to attach callbacks for mouse and keyboard events
+
+    SDL_Window* sdlWindow_;
+
+    bool rendering_ = false;
+    bool open_ = false;
+
+};

src/main.cpp

@@ -7,8 +7,10 @@ int main(int argc, char** argv) {
 
     std::cout << "hi mom !" << std::endl;
 
+    // create app and run
     App app;
     app.run();
+    // no freaking way
 
     return 0;
 }