actually working knobs (WOAH)

Author: Alloyed

daw/src/gui/debugui.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <string_view>
 #include "clap/ext/params.h"
 #include "clapeze/params/baseParameter.h"
 #include "kitgui/controls/knob.h"
@@ -70,14 +71,16 @@ void DebugParam(TParamsFeature& feature) {
 
 class BaseParamKnob : public kitgui::Knob {
    public:
-    explicit BaseParamKnob(const clapeze::BaseParam& param, clap_id id) : mParam(param), mId(id) {
+    explicit BaseParamKnob(const clapeze::BaseParam& param, clap_id id, std::string_view sceneNode)
+        : mParam(param), mId(id), mSceneNode(sceneNode) {
         // TODO: we'll need to listen for rescans if names can ever change
         clap_param_info_t info;
         mParam.FillInformation(id, &info);
         mName = info.name;
     }
     ~BaseParamKnob() override = default;
     clap_id GetParamId() const { return mId; }
+    const std::string& GetSceneNode() const { return mSceneNode; }
 
    protected:
     const std::string& GetName() const override { return mName; }
@@ -93,14 +96,9 @@ class BaseParamKnob : public kitgui::Knob {
    private:
     const clapeze::BaseParam& mParam;
     const clap_id mId;
+    std::string mSceneNode;
     std::string mName{};
 };
-
-/* Helper class for creating a knob based on a parameter*/
-template <typename TParamsFeature, TParamsFeature::Id id>
-class ParamKnob : kitgui::Knob {
-   public:
-};
 }  // namespace kitgui
 
 #endif

daw/src/gui/kitguiFeature.cpp

@@ -129,6 +129,7 @@ void KitguiFeature::Destroy() {
     mCtx.Destroy();
     sInitCount--;
     if (sInitCount <= 0) {
+        // todo: deinit only once
         kitgui::Context::deinit();
         if (sTimerId) {
             mHost.CancelTimer(sTimerId);

daw/src/keysynth/keysynth.cpp

@@ -13,14 +13,15 @@
 #include <memory>
 
 #include "descriptor.h"
+#include "kitdsp/math/util.h"
+#include "kitgui/context.h"
 
 #if KITSBLIPS_ENABLE_GUI
 #include <imgui.h>
 #include <kitgui/app.h>
 #include "clapeze/ext/assets.h"
 #include "gui/debugui.h"
 #include "gui/kitguiFeature.h"
-#include "kitgui/controls/knob.h"
 #include "kitgui/gfx/scene.h"
 #endif
 
@@ -294,18 +295,41 @@ class Processor : public clapeze::InstrumentProcessor<ParamsFeature::ProcessorHa
 class GuiApp : public kitgui::BaseApp {
    public:
     GuiApp(kitgui::Context& ctx, ParamsFeature& params)
-        : kitgui::BaseApp(ctx), mParams(params), mScene(std::make_unique<kitgui::Scene>(ctx)) {
-        // ctx.SetSizeConfig({1000, 600});
-        ctx.SetClearColor(Magnum::Math::Color4(0.3f, 0.7f, 0.3f, 1.0f));
-    }
+        : kitgui::BaseApp(ctx), mParams(params), mScene(std::make_unique<kitgui::Scene>(ctx)) {}
     ~GuiApp() = default;
 
     void OnActivate() override {
-        mScene->Load("assets/kitskeys.packed.glb");
+        mScene->Load("assets/kitskeys.glb");
+        // TODO: to update all this if the viewport changes
+        mScene->SetViewport({600.0f, 400.0f});
+
+        struct KnobSetupInfo {
+            Params param;
+            std::string node;
+        };
+        const std::vector<KnobSetupInfo> knobs{
+            {Params::PolyMode, "knob-mid-Davies-1900h"},         {Params::PolyCount, "knob-mid-Davies-1900h.001"},
+            {Params::OscOctave, "knob-mid-Davies-1900h.003"},    {Params::OscTune, "knob-mid-Davies-1900h.004"},
+            {Params::FilterCutoff, "knob-mid-Davies-1900h.006"}, {Params::FilterResonance, "knob-mid-Davies-1900h.005"},
+        };
+
         // TODO: data-driven
-        clap_id id = static_cast<clap_id>(Params::OscTune);
-        mKnobs.push_back(std::make_unique<kitgui::BaseParamKnob>(*mParams.GetBaseParam(id), id));
+        for (const auto& knobInfo : knobs) {
+            clap_id id = static_cast<clap_id>(knobInfo.param);
+            mKnobs.push_back(std::make_unique<kitgui::BaseParamKnob>(*mParams.GetBaseParam(id), id, knobInfo.node));
+            auto pos = mScene->GetObjectScreenPositionByName(knobInfo.node);
+            if (pos) {
+                // TODO: to size the knob appropriately we need the bounding range of the object and then transform the
+                // corners of that into screen positions. for now, hardcoded.
+                float w = 40.0f;
+                float hw = w * 0.5f;
+                mKnobs.back()->mPos = {pos->x() - hw, pos->y() - hw};
+                mKnobs.back()->mWidth = w;
+                mKnobs.back()->mShowDebug = false;
+            }
+        }
     }
+
     void DebugParamList() {
         ImGui::TextWrapped("WIP keys synthesizer. don't tell anybody but this is a volca keys for ur computer");
 
@@ -358,6 +382,9 @@ class GuiApp : public kitgui::BaseApp {
             if (knob->Update(raw)) {
                 mParams.GetMainHandle().SetRawValue(id, raw);
             }
+            // we assume the knob is at 12-o-clock, and knobs have 0.75turn(270deg) ranges
+            constexpr float maxTurn = kitdsp::kPi * 2.0f * 0.75f;
+            mScene->SetObjectRotationByName(knob->GetSceneNode(), (static_cast<float>(raw) - 0.5f) * -maxTurn);
         }
 
         if (mShowDebugWindow) {
@@ -418,8 +445,10 @@ class Plugin : public InstrumentPlugin {
         ConfigFeature<clapeze::TomlStateFeature<ParamsFeature>>();
 #if KITSBLIPS_ENABLE_GUI
         ConfigFeature<clapeze::AssetsFeature>(GetHost());
-        ConfigFeature<KitguiFeature>(GetHost(),
-                                     [&params](kitgui::Context& ctx) { return std::make_unique<GuiApp>(ctx, params); });
+        // aspect ratio 1.5
+        kitgui::SizeConfig cfg{600, 400, true, true};
+        ConfigFeature<KitguiFeature>(
+            GetHost(), [&params](kitgui::Context& ctx) { return std::make_unique<GuiApp>(ctx, params); }, cfg);
 #endif
 
         ConfigProcessor<Processor>(params.GetProcessorHandle());

kitgui/README.md

@@ -20,6 +20,26 @@ Tech design notes
 - complex/dynamic visual heirarchies and layouts
 - full DAW ui (that is to say, piano rolls and such)
 
+### GLTF
+
+We use gltf as our scene presentation format. your file should include
+
+- a camera
+- any lighting you want
+
+in addition to the subjects of your scene. we support
+
+- png/jpeg/webp textures
+- PBR materials + lights
+
+we don't support:
+
+- any other kind of texture
+- mesh compression
+- transparent materials
+
+but we'd like to! someday. To make your file manipulatable, export your scene with node names included. You can query based off of them.
+
 ### TODO
 
 - Cocoa!!

kitgui/include/kitgui/controls/knob.h

@@ -13,7 +13,7 @@ class Knob {
 
     // defaults to showing for imgui display
     bool mShowDebug = true;
-    // if not provided, uses imgui cursor
+    // if not provided, uses imgui cursor. represents top left
     std::optional<Vector2> mPos = {};
     // if not provided, works off of imgui normal sizing
     std::optional<float> mWidth = {};

kitgui/include/kitgui/gfx/scene.h

@@ -22,10 +22,12 @@ class Scene {
     void Update();
     /** Draws the scene. */
     void Draw();
+    /** Sets the viewport size, recalculating any cameras as needed. */
+    void SetViewport(const kitgui::Vector2& size);
 
     // These methods are added as needed, so no rhyme or reason to what's supported really
     void PlayAnimationByName(std::string_view name);
-    void SetObjectRotationByName(std::string_view name, const kitgui::Quaternion& rot);
+    void SetObjectRotationByName(std::string_view name, float angleRadians);
     std::optional<kitgui::Vector2> GetObjectScreenPositionByName(std::string_view name);
 
    private:

kitgui/include/kitgui/types.h

@@ -8,5 +8,4 @@ namespace kitgui {
 // All magnum types that exist in the public interface should go through here instead
 using Vector2 = Magnum::Vector2;
 using Color4 = Magnum::Color4;
-using Quaternion = Magnum::Quaternion;
 }  // namespace kitgui

kitgui/src/gfx/lights.cpp

@@ -1,10 +1,10 @@
 #include "gfx/lights.h"
 
-// enable conversion to stl
+// IWYU pragma: begin_keep
 #include <Corrade/Containers/OptionalStl.h>
 #include <Corrade/Containers/PairStl.h>
 #include <Corrade/Containers/StringStl.h>
-// done
+// IWYU pragma: end_keep
 
 #include <Magnum/Math/Color.h>
 #include <Magnum/Trade/AbstractImporter.h>

kitgui/src/gfx/materials.cpp

@@ -1,8 +1,10 @@
 #include "gfx/materials.h"
 
+// IWYU pragma: begin_keep
 #include <Corrade/Containers/OptionalStl.h>
 #include <Corrade/Containers/PairStl.h>
 #include <Corrade/Containers/StringStl.h>
+// IWYU pragma: end_keep
 
 #include <Corrade/Containers/Array.h>
 #include <Corrade/Utility/Algorithms.h>
@@ -11,14 +13,14 @@
 #include <Magnum/GL/Texture.h>
 #include <Magnum/GL/TextureFormat.h>
 #include <Magnum/ImageView.h>
-#include <Magnum/Math/Functions.h>
 #include <Magnum/PixelFormat.h>
 #include <Magnum/Trade/AbstractImporter.h>
 #include <Magnum/Trade/ImageData.h>
 #include <Magnum/Trade/MaterialData.h>
 #include <Magnum/Trade/PhongMaterialData.h>
 #include <Magnum/Trade/TextureData.h>
 #include <fmt/format.h>
+#include <cstddef>
 #include <optional>
 #include "log.h"
 
@@ -33,15 +35,17 @@ void loadImage(Magnum::GL::Texture2D& texture, const Magnum::Trade::ImageData2D&
         const uint32_t channelCount = pixelFormatChannelCount(image.format());
         if (channelCount == 1 || channelCount == 2) {
             if (GL::Context::current().isExtensionSupported<GL::Extensions::ARB::texture_swizzle>()) {
-                if (channelCount == 1)
+                if (channelCount == 1) {
                     texture.setSwizzle<'r', 'r', 'r', '1'>();
-                else if (channelCount == 2)
+                } else if (channelCount == 2) {
                     texture.setSwizzle<'r', 'r', 'r', 'g'>();
+                }
             } else {
                 const PixelFormat imageFormat =
                     pixelFormat(image.format(), channelCount == 2 ? 4 : 3, isPixelFormatSrgb(image.format()));
                 Debug{} << "Texture swizzle not supported, expanding a" << image.format() << "image to" << imageFormat;
-                const std::size_t rowStride = 4 * ((pixelFormatSize(imageFormat) * image.size().x() + 3) / 4);
+                const std::size_t rowStride =
+                    static_cast<std::size_t>(4 * ((pixelFormatSize(imageFormat) * image.size().x() + 3) / 4));
                 usedImageStorage = Containers::Array<char>{NoInit, std::size_t(rowStride * image.size().y())};
                 const MutableImageView2D usedMutableImage{imageFormat, image.size(), usedImageStorage};
                 usedImage = usedMutableImage;
@@ -53,11 +57,12 @@ void loadImage(Magnum::GL::Texture2D& texture, const Magnum::Trade::ImageData2D&
                     usedMutableImage.pixels().expanded<2>(Containers::Size2D{dstChannelCount, channelSize});
                 Utility::copy(src.exceptSuffix({0, 0, channelCount == 2 ? 1 : 0, 0}).broadcasted<2>(3),
                               dst.exceptSuffix({0, 0, channelCount == 2 ? 1 : 0, 0}));
-                if (channelCount == 2)
+                if (channelCount == 2) {
                     Utility::copy(src.exceptPrefix({0, 0, 1, 0}), dst.exceptPrefix({0, 0, 3, 0}));
+                }
             }
         }
-        GL::TextureFormat format;
+        GL::TextureFormat format{};
         switch (usedImage.format()) {
             case PixelFormat::R8Unorm:
             case PixelFormat::RG8Unorm:
@@ -84,11 +89,10 @@ void loadImage(Magnum::GL::Texture2D& texture, const Magnum::Trade::ImageData2D&
                     fmt::format("cannot load image of format {} ", static_cast<uint32_t>(usedImage.format())));
                 return;
         }
-        texture.setStorage(Math::log2(usedImage.size().max()) + 1, format, usedImage.size())
-            .setSubImage(0, {}, usedImage)
-            .generateMipmap();
+        int32_t levels = static_cast<int32_t>(std::log2<int32_t>(usedImage.size().max()) + 1);
+        texture.setStorage(levels, format, usedImage.size()).setSubImage(0, {}, usedImage).generateMipmap();
     } else {
-        GL::TextureFormat format;
+        GL::TextureFormat format{};
         switch (image.compressedFormat()) {
             case CompressedPixelFormat::Bc4RSnorm:
             case CompressedPixelFormat::Bc5RGSnorm:

kitgui/src/gfx/meshes.cpp

@@ -1,6 +1,9 @@
 #include "gfx/meshes.h"
 
+// IWYU pragma: begin_keep
 #include <Corrade/Containers/OptionalStl.h>
+// IWYU pragma: end_keep
+
 #include <Magnum/GL/Mesh.h>
 #include <Magnum/MeshTools/Compile.h>
 #include <Magnum/MeshTools/GenerateIndices.h>