cleanup and architecture

Author: Alloyed

.github/workflows/cmake-single-platform.yml

@@ -21,7 +21,7 @@ defaults:
     shell: bash
 
 jobs:
-  build-vst:
+  build-juce:
     # The CMake configure and build commands are platform agnostic and should work equally well on Windows or Mac.
     # You can convert this to a matrix build if you need cross-platform coverage.
     # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
@@ -59,6 +59,40 @@ jobs:
         # Build your program with the given configuration
         run: cmake --build "${{github.workspace}}/build" --config ${{env.BUILD_TYPE}}
 
+  build-clap:
+    name: clap ${{ matrix.name }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false # show all errors for each platform (vs. cancel jobs on error)
+      matrix:
+        include:
+          - name: Linux
+            os: ubuntu-22.04
+          # - name: macOS
+          #   os: macos-14
+          #   extra-flags: -DCMAKE_OSX_ARCHITECTURES="x86_64;arm64"
+          - name: Windows
+            os: windows-latest
+
+    steps:
+      - name: Install JUCE's Linux Deps
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update && sudo apt install ninja-build
+
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Configure CMake
+        # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
+        # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
+        run: cmake -B "${{github.workspace}}/build" -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} "${{github.workspace}}/clap" ${{matrix.extra-flags}}
+
+      - name: Build
+        # Build your program with the given configuration
+        run: cmake --build "${{github.workspace}}/build" --config ${{env.BUILD_TYPE}}
+
   #modify-plugin-version:
   #  name: Modify plugin version
   #  runs-on: ubuntu-latest

clap/template/CMakeLists.txt

@@ -6,6 +6,7 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
 add_library(${PROJECT_NAME} MODULE 
 	src/plugin.cpp
+	src/PluginHost.cpp
 	src/gui.cpp
 	src/audio.cpp
 )

clap/template/include/PluginHost.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <string>
+#include <functional>
+
+#include "clap/id.h"
+
+// forward declarations
+typedef struct clap_host clap_host_t;
+typedef struct clap_host_log clap_host_log_t;
+typedef struct clap_host_timer_support clap_host_timer_support_t;
+typedef struct clap_host_gui clap_host_gui_t;
+
+enum class LogSeverity {
+	Debug = 0,
+	Info = 1,
+	Warning = 2,
+	Error = 3,
+	Fatal = 4,
+};
+
+/**
+ * PluginHost wraps over the capabilities and methods that the plugin host
+ * (aka, the DAW) provide to us. this can be held onto for the lifetime of the
+ * plugin safely, but only call it from the main thread.
+ */
+class PluginHost {
+	public:
+		using TimerId = clap_id;
+		using TimerFn = std::function<void()>;
+
+		PluginHost(const clap_host_t* host);
+
+		/** Add a message to the host's log */
+		void Log(LogSeverity severity, const std::string& message) const;
+
+		/** Add a timer to be run every `periodMs` milliseconds. to run only once, call `CancelTimer()` in the body of your timer function. */
+		TimerId AddTimer(uint32_t periodMs, TimerFn timerFn);
+		/** Cancels an active timer with the provided id. this is safe to call from inside of timers. */
+		void CancelTimer(TimerId id);
+		/** implementation. TODO: friend declaration to hide this? */
+		void OnTimer(TimerId id) const;
+
+	private:
+		const clap_host_t* mHost;
+		const clap_host_log_t* mLog;
+		const clap_host_timer_support_t* mTimer;
+		const clap_host_gui_t* mGui;
+		std::unordered_map<TimerId, TimerFn> mActiveTimers;
+};

clap/template/include/audio.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <cstdint>
+
+namespace Audio {
+	void Render(uint32_t start, uint32_t end, float *outputL, float *outputR);
+}

clap/template/include/gui.h

@@ -5,6 +5,9 @@
 #include <cstdint>
 #include <memory>
 
+// Forward declares
+class PluginHost;
+
 // from reddit
 template<typename T>
 struct c_deleter;
@@ -18,10 +21,16 @@ struct c_deleter<SDL_Window> final {
 	}
 };
 
+/**
+ * Gui is the main abstraction for windowing and graphics.
+ * Right now we use SDL_Video to manage the window on all platforms, OpenGL for rendering, and imgui as the UI toolkit.
+ * Future version may make this an abstract class that can have multiple different implementations for different toolkits.
+ */
 class Gui {
 	// constants
 	public:
 		enum class WindowingApi {
+			None = 0,
 			X11,
 			Wayland,
 			Win32,
@@ -34,13 +43,19 @@ class Gui {
 			uint32_t aspectRatioWidth;
 			uint32_t aspectRatioHeight;
 		};
+		static constexpr char kDefaultWindowTitle[] = "Template";
+		static constexpr int32_t kDefaultWindowWidth = 400;
+		static constexpr int32_t kDefaultWindowHeight = 400;
 
 	// API methods
 	public:
 		static bool IsApiSupported(WindowingApi api, bool isFloating);
 		static bool GetPreferredApi(WindowingApi& outApi, bool& outIsFloating);
 
-		Gui(WindowingApi api, bool isFloating); // Create
+		static bool OnAppInit();
+		static bool OnAppQuit();
+
+		Gui(PluginHost* host, WindowingApi api, bool isFloating); // Create
 		~Gui(); // Destroy
 
 		bool SetScale(double scale);
@@ -51,7 +66,8 @@ class Gui {
 		bool SetSize(uint32_t width, uint32_t height);
 		bool SetParent(WindowingApi api, void* windowPointer);
 		bool SetTransient(WindowingApi api, void* windowPointer);
-		void SuggestTitle(std::string_view title);
+		// _must_ be c-string
+		void SuggestTitle(const char* title);
 		bool Show();
 		bool Hide();
 		void Update(float dt);
@@ -60,7 +76,10 @@ class Gui {
 	private:
 		c_unique_ptr<SDL_Window> mWindowHandle;
 		c_unique_ptr<SDL_Window> mParentHandle;
+		PluginHost* mHost;
+		SDL_GLContext mCtx;
 
 		void CreateWindow();
 		void CreateParentWindow(WindowingApi api, void* windowPointer);
+		void OnGui();
 };

clap/template/src/PluginHost.cpp

@@ -0,0 +1,35 @@
+#include "PluginHost.h"
+
+#include "clap/clap.h"
+
+PluginHost::PluginHost(const clap_host_t* host):
+	mHost(host),
+	mLog(static_cast<const clap_host_log_t *>(host->get_extension(host, CLAP_EXT_LOG))),
+	mTimer(static_cast<const clap_host_timer_support_t *>(host->get_extension(host, CLAP_EXT_TIMER_SUPPORT))),
+	mGui(static_cast<const clap_host_gui_t *>(host->get_extension(host, CLAP_EXT_GUI)))
+{
+}
+
+void PluginHost::Log(LogSeverity severity, const std::string& message) const
+{
+	return mLog->log(mHost, static_cast<clap_log_severity>(severity), message.c_str());
+}
+
+PluginHost::TimerId PluginHost::AddTimer(uint32_t periodMs, PluginHost::TimerFn fn)
+{
+	TimerId id;
+	mTimer->register_timer(mHost, periodMs, &id);
+	mActiveTimers.emplace(id, fn);
+	return id;
+}
+
+void PluginHost::OnTimer(PluginHost::TimerId id) const
+{
+	mActiveTimers.at(id) ();
+}
+
+void PluginHost::CancelTimer(PluginHost::TimerId id)
+{
+	mActiveTimers.erase(id);
+	mTimer->unregister_timer(mHost, id);
+}

clap/template/src/audio.cpp

@@ -1,4 +1,4 @@
-
+#include "audio.h"
 
 namespace Audio {
 	void Render(uint32_t start, uint32_t end, float *outputL, float *outputR) {