gui backend hardening

Author: Alloyed

clapeze/docs/intro/bring-your-own-gui.md

@@ -0,0 +1,63 @@
+# Bring your own GUI
+
+Clapeze doesn't come with any gui framework by default. Instead, you can subclass `clapeze::BaseGuiFeature`. This is a thin wrapper around the clap `EXT_GUI` extension.
+
+```c++
+#include "clapeze/ext/gui.h"
+
+class MyGuiFeature : public clapeze::BaseGuiFeature {
+    bool IsApiSupported(ClapWindowApi api, bool isFloating) override;
+    bool GetPreferredApi(ClapWindowApi& apiOut, bool& isFloatingOut) override;
+    bool Create(ClapWindowApi api, bool isFloating) override;
+    void Destroy() override;
+    bool SetScale(double scale) override;
+    bool GetSize(uint32_t& widthOut, uint32_t& heightOut) override;
+    bool CanResize() override;
+    bool GetResizeHints(clap_gui_resize_hints_t& hintsOut) override;
+    bool AdjustSize(uint32_t& widthInOut, uint32_t& heightInOut) override;
+    bool SetSize(uint32_t width, uint32_t height) override;
+    bool SetParent(WindowHandle handle) override;
+    bool SetTransient(WindowHandle handle) override;
+    void SuggestTitle(std::string_view title) override;
+    bool Show() override;
+    bool Hide() override;
+}
+```
+
+And then in your plugin:
+
+```c++
+void MyPlugin::Config()  {
+    ...
+    ConfigFeature<MyGuiFeature>(GetHost());
+    ...
+}
+```
+
+# How to implement
+
+the clap gui extension is not especially easy to implement, so let's discuss the requirements quickly.
+
+---
+
+### M Processes, N Windows
+
+The user might open up multiple instances of your plugin at the same time, so you should be robust to that. They may be sharing a "main" thread, so blocking event loops are not an option. Some hosts will seperate plugins (including those by third parties) by process, others won't, so if your framework has process-shared state be careful not to pollute it.
+
+### The Windowing Framework is the interface
+
+Clap doesn't define an event loop or surface system, instead, you get a `clap_window_t`, which is a native handle to the parent window. You're expected to figure out your own event loop. You're also expected to figure out highdpi support (though the host _might_ provide a desired zoom level).
+
+### Embed vs Floating
+
+Almost every host and windowing framework expects to "embed" a window into the parent handle it provides you. this means that the plugin host actually creates the stuff you'd normally associate with a window, the decorations around it, and often little widgets on the inside for managing it.
+
+Linux/Wayland doesn't have any kind of equivalent to the concept of embedding, so the API's surface area doubles to support "floating" windows. These are fully separate windows with a looser connection to the parent window; this is what happen when you spawn a dialog or file picker, for example. This is currently supported in very few hosts, so I might hide it from Clapeze's API. To be continued!
+
+### Create/Destroy are common
+
+Many hosts will create windows when the user focuses them, and then destroy those windows when the user changes focus in the parent app. this means you'll be calling create and delete multiple times in a given session, and it makes sense to optimize these as much as possible. In my own plugins I will create gui resources on the first call to create, but only delete them when the entire plugin is deleted; this is to avoid expensive recreate calls in this loop.
+
+---
+
+With these requirements added up, you may find it easier to write separate, per-platform window backends that ensure these rules are met, as opposed to using a cross-platform windowing api like SDL.

daw/assets/kitskeys.glb

@@ -2,5 +2,6 @@
 
 find assets -maxdepth 1 -name '*.glb' ! -name '*.packed.glb' -print0 |
 while IFS= read -r -d '' file; do
-  gltfpack -v -cc -tc -mi -i "$file" -o "${file%.glb}.packed.glb"
+  #gltfpack -v -cc -tc -mi -i "$file" -o "${file%.glb}.packed.glb"
+  gltfpack -v -i "$file" -o "${file%.glb}.packed.glb"
 done

daw/assets/kitskeys.packed.glb

@@ -6,7 +6,9 @@ add_library(imgui STATIC EXCLUDE_FROM_ALL
     ${IMGUI_DIR}/imgui_draw.cpp
     ${IMGUI_DIR}/imgui_tables.cpp
     ${IMGUI_DIR}/imgui_widgets.cpp
+    ${IMGUI_DIR}/misc/cpp/imgui_stdlib.cpp
 )
+target_include_directories(imgui PRIVATE ${IMGUI_DIR})
 target_include_directories(imgui INTERFACE ${IMGUI_DIR})
 
 add_library(imgui_opengl STATIC EXCLUDE_FROM_ALL

daw/pack-meshes.sh

@@ -1,38 +1,71 @@
 #include <Magnum/Math/Color.h>
 #include <imgui.h>
+#include <misc/cpp/imgui_stdlib.h>
+#include <memory>
 #include "kitgui/app.h"
 #include "kitgui/context.h"
 #include "kitgui/gfx/scene.h"
 #include "kitgui/kitgui.h"
+#include "kitgui/types.h"
 
 class MyApp : public kitgui::BaseApp {
    public:
-    explicit MyApp(kitgui::Context& mContext) : kitgui::BaseApp(mContext), mScene(mContext) {
-        mContext.SetSizeConfig({400, 400});
-        mContext.SetClearColor(Magnum::Math::Color4(1.0f, 1.0f, 1.0f, 1.0f));
-    }
+    explicit MyApp(kitgui::Context& mContext)
+        : kitgui::BaseApp(mContext), mScene(std::make_unique<kitgui::Scene>(mContext)) {}
     ~MyApp() = default;
 
    protected:
     void OnActivate() override {
-        mScene.Load(PROJECT_DIR "/assets/duck.glb");
-        // mScene.PlayAnimationByName("Suzanne");
+        mScene->Load(mFilePath);
+        GetContext().SetClearColor(mClearColor);
     }
     void OnUpdate() override {
-        mScene.Update();
-        ImGui::Text("Oh yeah, gamer time!");
+        mScene->Update();
+        if (mShowUi) {
+            ImGui::SetNextWindowPos({ImGui::GetWindowWidth() - 300, ImGui::GetWindowHeight() - 200}, ImGuiCond_Once);
+            ImGui::SetNextWindowSize({300, 200}, ImGuiCond_Once);
+            if (ImGui::Begin("Viewer", &mShowUi)) {
+                ImGui::InputText("file", &mFilePath);
+                if (ImGui::IsItemDeactivatedAfterEdit()) {
+                    mScene.reset();
+                    mScene = std::make_unique<kitgui::Scene>(GetContext());
+                    mScene->Load(mFilePath);
+                }
+
+                uint32_t w{};
+                uint32_t h{};
+                GetContext().GetSize(w, h);
+                int32_t data[2] = {static_cast<int32_t>(w), static_cast<int32_t>(h)};
+                ImGui::InputInt2("size", data);
+                if (ImGui::IsItemDeactivatedAfterEdit()) {
+                    w = static_cast<uint32_t>(data[0]);
+                    h = static_cast<uint32_t>(data[1]);
+                    GetContext().SetSizeConfig({.startingWidth = w, .startingHeight = h});
+                    GetContext().SetSizeDirectly(w, h, false);
+                }
+
+                if (ImGui::ColorEdit4("bgcolor", reinterpret_cast<float*>(&mClearColor))) {
+                    GetContext().SetClearColor(mClearColor);
+                }
+            }
+            ImGui::End();
+        }
     }
-    void OnDraw() override { mScene.Draw(); }
+    void OnDraw() override { mScene->Draw(); }
 
    private:
-    kitgui::Scene mScene;
+    std::unique_ptr<kitgui::Scene> mScene;
+    bool mShowUi = true;
+    std::string mFilePath{PROJECT_DIR "/assets/duck.glb"};
+    kitgui::Color4 mClearColor{0.1f, 0.4f, 0.4f, 1.0f};
 };
 
 int main() {
     kitgui::Context::init(kitgui::WindowApi::Any, "kitgui");
 
     {
         kitgui::Context ctx1([](kitgui::Context& ctx) { return std::make_unique<MyApp>(ctx); });
+        ctx1.SetSizeConfig({400, 400, true, false});
         ctx1.Create(true);
         ctx1.Show();
 

kitgui/cmake/imgui.cmake

@@ -15,14 +15,14 @@ add_compile_definitions(-DPROJECT_DIR="${CMAKE_SOURCE_DIR}")
 #
 # and it'll be available to link, as below.
 
-add_executable(demo demo.cpp)
-target_link_libraries(demo kitgui)
+add_executable(imguiDemo imguiDemo.cpp)
+target_link_libraries(imguiDemo kitgui)
 
 add_executable(multiwindow multiwindow.cpp)
 target_link_libraries(multiwindow kitgui)
 
 add_executable(3dscene 3dscene.cpp)
 target_link_libraries(3dscene kitgui)
 
-add_executable(immediatemode immediatemode.cpp)
-target_link_libraries(immediatemode kitgui)
+add_executable(customControls customControls.cpp)
+target_link_libraries(customControls kitgui)

kitgui/examples/3dscene.cpp

@@ -7,26 +7,32 @@ using namespace Magnum;
 
 class MyApp2 : public kitgui::BaseApp {
    public:
-    explicit MyApp2(kitgui::Context& mContext) : kitgui::BaseApp(mContext) {}
+    explicit MyApp2(kitgui::Context& mContext, int32_t idx) : kitgui::BaseApp(mContext), mIdx(idx) {}
     ~MyApp2() = default;
 
    protected:
     void OnActivate() override {}
-    void OnUpdate() override { ImGui::Text("Window.... 2!!!"); }
+    void OnUpdate() override {
+        ImGui::Text("Window: %d", mIdx);
+        ImGui::Text("Scale: %f", GetContext().GetUIScale());
+    }
 
     void OnDraw() override {}
 
    private:
+    int32_t mIdx;
 };
 
 int main() {
     kitgui::Context::init(kitgui::WindowApi::Any, "kitgui");
 
     {
-        kitgui::Context ctx1([](kitgui::Context& ctx) { return std::make_unique<MyApp2>(ctx); });
+        kitgui::Context ctx1([](kitgui::Context& ctx) { return std::make_unique<MyApp2>(ctx, 1); });
+        ctx1.SetClearColor({0.4f, 0.1f, 0.4f, 1.0f});
         ctx1.Create(true);
 
-        kitgui::Context ctx2([](kitgui::Context& ctx) { return std::make_unique<MyApp2>(ctx); });
+        kitgui::Context ctx2([](kitgui::Context& ctx) { return std::make_unique<MyApp2>(ctx, 2); });
+        ctx2.SetClearColor({0.1f, 0.4f, 0.4f, 1.0f});
         ctx2.Create(true);
 
         ctx1.Show();