Converted existing vulkan program without vkbootstrap to use SDL callbacks

.gitignore

@@ -103,4 +103,7 @@ CMakeUserPresets.json
 # Other
 .cache/
 .vscode/
-build/
+build/
+
+.kdev4/
+*.kdev4

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.10)
-project(vksdlproj VERSION 0.1.0 LANGUAGES C CXX)
+project(vksdlproj VERSION 0.2.0 LANGUAGES C CXX)
 
 SET(CMAKE_BUILD_RPATH_USE_ORIGIN TRUE)
 set(EXE_NAME project)
@@ -69,4 +69,4 @@ endif()
 # Linking
 target_link_libraries(${EXE_NAME} PRIVATE SDL3::SDL3)
 target_link_libraries(${EXE_NAME} PRIVATE Vulkan::Vulkan)
-target_link_libraries(${EXE_NAME} PRIVATE vk-bootstrap::vk-bootstrap)
+target_link_libraries(${EXE_NAME} PRIVATE vk-bootstrap::vk-bootstrap)

include/vulkanapp.hh

@@ -7,6 +7,8 @@
 #include <vector>
 #include <optional>
 
+#include <stdio.h>
+
 #include <vulkan/vulkan.h>
 
 const std::vector<const char*> validationLayers = {
@@ -51,6 +53,9 @@ public:
     void init();
     void loop();
     void cleanup();
+    inline bool minimized() { return mMinimized; }
+    inline void minimized(bool v) { mMinimized = v; }
+    inline void resized(bool v) { mResized = v; }
 private:
     // SDL2
     SDL_Window *mWin;
@@ -59,7 +64,7 @@ private:
     // Not tied to library
     uint32_t mWidth;
     uint32_t mHeight;
-    bool mActive = false;
+    // bool mActive = false;
     bool mResized = false;
     bool mMinimized = false;
 
@@ -138,4 +143,4 @@ private:
 
         return VK_FALSE;
     }
-};
+};

src/main.cc

@@ -1,19 +1,95 @@
+#define SDL_MAIN_USE_CALLBACKS
+#include <SDL3/SDL_main.h>
+#include <SDL3/SDL_init.h>
+#include <SDL3/SDL.h>
+
 #include "vulkanapp.hh"
 
 #include <exception>
 
-int main() {
-    VulkanApp app(1024, 1024);
+constexpr uint32_t winInitWidth = 512;
+constexpr uint32_t winInitHeight = 512;
+
+struct AppContext {
+    VulkanApp vkapp;
+    SDL_AppResult appQuit = SDL_APP_CONTINUE;
+};
+
+SDL_AppResult SDL_Fail() {
+    SDL_LogError(SDL_LOG_CATEGORY_ERROR, "Error: %s", SDL_GetError());
+    return SDL_APP_FAILURE;
+}
+
+SDL_AppResult SDL_AppInit(void **appstate, int argc, char **argv) {
+    (void)argc;
+    (void)argv;
+
+    if(!SDL_Init(SDL_INIT_VIDEO))
+        return SDL_Fail();
 
     try {
-        app.init();
-        app.loop();
-        app.cleanup();
+        *appstate = new AppContext { .vkapp = VulkanApp(1024, 1024)};
+        AppContext* app = static_cast<AppContext*>(*appstate);
+        app->vkapp.init();
     } catch(const std::exception& except) {
         fprintf(stderr, "Error! %s\n", except.what());
 
-        return 1;
+        return SDL_APP_FAILURE;
+    }
+    return SDL_APP_CONTINUE;
+}
+
+SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event) {
+    AppContext* app = static_cast<AppContext*>(appstate);
+
+    switch(event->type) {
+    case SDL_EVENT_QUIT:
+        app->appQuit = SDL_APP_SUCCESS;
+        break;
+    case SDL_EVENT_WINDOW_RESIZED:
+        app->vkapp.resized(true);
+        break;
+    case SDL_EVENT_WINDOW_MINIMIZED:
+        app->vkapp.minimized(true);
+        break;
+    case SDL_EVENT_WINDOW_RESTORED:
+        app->vkapp.minimized(false);
+        break;
+    default:
+        break;
     }
 
-    return 0;
-}
+    return SDL_APP_CONTINUE;
+}
+
+SDL_AppResult SDL_AppIterate(void *appstate) {
+    AppContext* app = static_cast<AppContext*>(appstate);
+
+    try {
+        app->vkapp.loop();
+    } catch(const std::exception& except) {
+        fprintf(stderr, "Error! %s\n", except.what());
+
+        return SDL_APP_FAILURE;
+    }
+
+    return app->appQuit;
+}
+
+void SDL_AppQuit(void *appstate, SDL_AppResult result) {
+    AppContext* app = static_cast<AppContext*>(appstate);
+
+    if(result == SDL_APP_FAILURE) {
+        fputs("Program failure, shutting down\n", stderr);
+    } else {
+       puts("Program shutting down, no errors.");
+    }
+
+    if(app) {
+        app->vkapp.cleanup();
+
+        delete app;
+    }
+
+    SDL_Quit();
+}

src/vulkanapp.cc

@@ -862,31 +862,7 @@ void VulkanApp::loop() {
         throw std::runtime_error(err);
     }
 
-    mActive = true;
-
-    // Main loop
-    while(mActive) {
-        while(SDL_PollEvent(&mEvent)) {
-            switch (mEvent.type) {
-            case SDL_EVENT_QUIT:
-                mActive = false;
-                break;
-            case SDL_EVENT_WINDOW_RESIZED:
-                mResized = true;
-                break;
-            case SDL_EVENT_WINDOW_MINIMIZED:
-                mMinimized = true;
-                break;
-            case SDL_EVENT_WINDOW_RESTORED:
-                mMinimized = false;
-                break;
-            default:
-                break;
-            }
-        }
-
-        if(!mMinimized) drawFrame();
-    }
+    if(!mMinimized) drawFrame();
 
     vkDeviceWaitIdle(mLogicalDevice);
 }
@@ -921,7 +897,4 @@ void VulkanApp::cleanup() {
         SDL_DestroyWindow(mWin);
         mWin = nullptr;
     }
-
-    //SDL_Vulkan_UnloadLibrary();
-    SDL_Quit();
-}
+}