Qt6 frontend

Reviewed-on: #1
Co-authored-by: iris <iris.kaizen@pm.me>
Co-committed-by: iris <iris.kaizen@pm.me>

src/frontend/RenderWidget.hpp

@@ -1,79 +1,106 @@
 #pragma once
+#undef signals
 #include <ParallelRDPWrapper.hpp>
-#include <SDL3/SDL.h>
-#include <SDL3/SDL_vulkan.h>
+#include <QVulkanWindow>
+#include <QMainWindow>
+#include <QThread>
 
 struct InputSettings;
 
 namespace n64 {
 struct Core;
 }
+class QtPrdpWindowInfo;
+class QtWSIPlatform;
 
-class SDLParallelRdpWindowInfo final : public ParallelRDP::WindowInfo {
-public:
-  explicit SDLParallelRdpWindowInfo(SDL_Window* window) : window(window) {}
-  CoordinatePair get_window_size() override {
-    int w,h;
-    SDL_GetWindowSizeInPixels(window, &w, &h);
-    return CoordinatePair{static_cast<float>(w), static_cast<float>(h)};
-  }
+struct QtInstanceFactory : Vulkan::InstanceFactory {
+    VkInstance create_instance(const VkInstanceCreateInfo *info) override {
+        handle.setApiVersion({1, 3, 0});
+        QByteArrayList exts;
+        for (int i = 0; i < info->enabledExtensionCount; i++) {
+            exts.push_back(QByteArray::fromStdString(info->ppEnabledExtensionNames[i]));
+        }
+        QByteArrayList layers;
+        for (int i = 0; i < info->enabledLayerCount; i++) {
+            layers.push_back(QByteArray::fromStdString(info->ppEnabledLayerNames[i]));
+        }
+        handle.setExtensions(exts);
+        handle.setLayers(layers);
+        handle.create();
 
-private:
-  SDL_Window* window{};
-};
-
-class SDLWSIPlatform final : public Vulkan::WSIPlatform {
-public:
-  explicit SDLWSIPlatform(SDL_Window* window) : window(window) {}
-  ~SDLWSIPlatform() = default;
-
-  std::vector<const char *> get_instance_extensions() override {
-    auto vec = std::vector<const char *>();
-    u32 extCount;
-    const auto &extensions = SDL_Vulkan_GetInstanceExtensions(&extCount);
-    vec.resize(extCount);
-
-    for (u32 i = 0; i < extCount; i++) {
-      vec[i] = extensions[i];
+        return handle.vkInstance();
     }
 
-    return vec;
-  }
-
-  VkSurfaceKHR create_surface(VkInstance instance, VkPhysicalDevice pDevice) override {
-    SDL_Vulkan_CreateSurface(window, instance, nullptr, &surface);
-    return surface;
-  }
-
-  void destroy_surface(VkInstance instance, VkSurfaceKHR surface) override {
-    SDL_Vulkan_DestroySurface(instance, surface, nullptr);
-  }
-
-  uint32_t get_surface_width() override { return 640; }
-
-  uint32_t get_surface_height() override { return 480; }
-
-  bool alive(Vulkan::WSI &) override { return true; }
-
-  void poll_input() override {}
-  void poll_input_async(Granite::InputTrackerHandler *handler) override {}
-
-  void event_frame_tick(double frame, double elapsed) override {}
-
-  const VkApplicationInfo *get_application_info() override { return &appInfo; }
-
-  VkApplicationInfo appInfo{.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, .apiVersion = VK_API_VERSION_1_3};
-
-  SDL_Window* window{};
-  VkSurfaceKHR surface;
-private:
-  bool gamepadConnected = false;
+    QVulkanInstance handle;
 };
 
-class RenderWidget final {
-public:
-  explicit RenderWidget(SDL_Window*);
+class RenderWidget final : public QWidget {
+    Q_OBJECT
+    QVulkanInstance inst;
 
-  std::shared_ptr<ParallelRDP::WindowInfo> windowInfo;
-  std::shared_ptr<SDLWSIPlatform> wsiPlatform;
+  public:
+    explicit RenderWidget();
+
+    QPaintEngine *paintEngine() const override { return nullptr; }
+
+    std::unique_ptr<QtInstanceFactory> qtVkInstanceFactory;
+    std::shared_ptr<ParallelRDP::WindowInfo> windowInfo;
+    std::shared_ptr<QtWSIPlatform> wsiPlatform;
+};
+
+
+class QtPrdpWindowInfo final : public ParallelRDP::WindowInfo {
+  public:
+    explicit QtPrdpWindowInfo(QWindow *window) : window(window) {}
+    CoordinatePair get_window_size() override {
+        return CoordinatePair{static_cast<float>(window->width()), static_cast<float>(window->height())};
+    }
+
+  private:
+    QWindow *window{};
+};
+
+class QtWSIPlatform final : public Vulkan::WSIPlatform {
+  public:
+    explicit QtWSIPlatform(QWindow *window) : window(window) {}
+    ~QtWSIPlatform() = default;
+
+    std::vector<const char *> get_instance_extensions() override {
+        auto vec = std::vector<const char *>();
+        auto extensions = window->vulkanInstance()->extensions();
+
+        vec.resize(extensions.size());
+
+        for (u32 i = 0; i < extensions.size(); i++) {
+            vec[i] = extensions[i];
+        }
+
+        return vec;
+    }
+
+    VkSurfaceKHR create_surface(VkInstance instance, VkPhysicalDevice pDevice) override {
+        return QVulkanInstance::surfaceForWindow(window);
+    }
+
+    void destroy_surface(VkInstance instance, VkSurfaceKHR surface) override {}
+
+    uint32_t get_surface_width() override { return 640; }
+
+    uint32_t get_surface_height() override { return 480; }
+
+    bool alive(Vulkan::WSI &) override { return true; }
+
+    void poll_input() override {}
+    void poll_input_async(Granite::InputTrackerHandler *handler) override {}
+
+    void event_frame_tick(double frame, double elapsed) override {}
+
+    const VkApplicationInfo *get_application_info() override { return &appInfo; }
+
+    VkApplicationInfo appInfo{.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, .apiVersion = VK_API_VERSION_1_3};
+
+    QWindow *window{};
+
+  private:
+    bool gamepadConnected = false;
 };