split/gpu interop

.gitmodules

@@ -115,3 +115,6 @@
 [submodule "3rdparty/opengametools"]
 	path = 3rdparty/opengametools
 	url = https://github.com/jpaver/opengametools
+[submodule "3rdparty/OffsetAllocator"]
+	path = 3rdparty/OffsetAllocator
+	url = https://github.com/sebbbi/OffsetAllocator

src/app/main.cpp

@@ -254,6 +254,9 @@ static void setup_x11(int argc, char** argv)
 
         helper_dylibs.run_under_x11 = true;
         helper_dylibs.xwayland = wayland;
+
+        // EGL is the only way to get zero-copy with dma-buf import
+        qputenv("QT_XCB_GL_INTEGRATION", "xcb_egl");
       }
     }
   };
@@ -499,6 +502,7 @@ static void setup_opengl(bool& enable_opengl_ui)
 
 #ifndef QT_NO_OPENGL
 #if (defined(__arm__) || defined(__aarch64__)) && !defined(_WIN32) && !defined(__APPLE__)
+  // Raspberry Pi & such
   QSurfaceFormat fmt = QSurfaceFormat::defaultFormat();
   fmt.setRenderableType(QSurfaceFormat::OpenGLES);
   fmt.setSwapInterval(1);
@@ -514,6 +518,7 @@ static void setup_opengl(bool& enable_opengl_ui)
   fmt.setDefaultFormat(fmt);
 #else
   {
+    // Desktop GL
     std::vector<std::pair<int, int>> versions_to_test
         = {{4, 6}, {4, 5}, {4, 4}, {4, 3}, {4, 2}, {4, 1}, {4, 0},
            {3, 3}, {3, 2}, {3, 1}, {3, 0}, {2, 1}, {2, 0}};
@@ -552,7 +557,9 @@ static void setup_opengl(bool& enable_opengl_ui)
 
     QSurfaceFormat fmt = QSurfaceFormat::defaultFormat();
     fmt.setProfile(QSurfaceFormat::CoreProfile);
+    fmt.setRenderableType(QSurfaceFormat::OpenGL);
     fmt.setSwapInterval(1);
+    fmt.setStencilBufferSize(8);
     bool ok = false;
     for(auto [maj, min] : versions_to_test)
     {

src/plugins/score-lib-process/Process/Drop/ProcessDropHandler.cpp

@@ -4,6 +4,7 @@
 
 #include <ossia/detail/algorithms.hpp>
 
+#include <QDebug>
 #include <QFile>
 #include <QFileInfo>
 #include <QSet>
@@ -19,8 +20,22 @@ void ProcessDropHandler::getCustomDrops(
     std::vector<ProcessDropHandler::ProcessDrop>& drops, const QMimeData& mime,
     const score::DocumentContext& ctx) const noexcept
 {
-  // Check for special mime handling code
-  return dropCustom(drops, mime, ctx);
+  // dropCustom is no longer noexcept (some overrides invoke parsers that
+  // can throw on malformed input — see ProcessDropHandler.hpp). Catch
+  // here so a throwing handler never escapes through the noexcept
+  // public API and tears down the editor.
+  try
+  {
+    dropCustom(drops, mime, ctx);
+  }
+  catch(const std::exception& e)
+  {
+    qWarning() << "ProcessDropHandler::dropCustom threw:" << e.what();
+  }
+  catch(...)
+  {
+    qWarning() << "ProcessDropHandler::dropCustom threw an unknown exception";
+  }
 }
 
 void ProcessDropHandler::getMimeDrops(
@@ -61,7 +76,7 @@ QSet<QString> ProcessDropHandler::fileExtensions() const noexcept
 
 void ProcessDropHandler::dropCustom(
     std::vector<ProcessDropHandler::ProcessDrop>&, const QMimeData& data,
-    const score::DocumentContext& ctx) const noexcept
+    const score::DocumentContext& ctx) const
 {
 }
 

src/plugins/score-lib-process/Process/Drop/ProcessDropHandler.hpp

@@ -59,7 +59,7 @@ class SCORE_LIB_PROCESS_EXPORT ProcessDropHandler : public score::InterfaceBase
 protected:
   virtual void dropCustom(
       std::vector<ProcessDrop>& drops, const QMimeData& mime,
-      const score::DocumentContext& ctx) const noexcept;
+      const score::DocumentContext& ctx) const;
 
   virtual void dropPath(
       std::vector<ProcessDrop>& drops, const score::FilePath& path,

src/plugins/score-plugin-avnd/Crousti/Concepts.hpp

@@ -448,7 +448,35 @@ make_control_in(avnd::field_index<N>, Id<Process::Port>&& id, QObject* parent)
       auto [Mx, My, Mz] = c.max;
       auto [ix, iy, iz] = c.init;
       return new Process::XYZSpinboxes{{mx, my, mz}, {Mx, My, Mz}, {ix, iy, iz},
-                                       qname,        id,           parent};
+                                       false,        qname,        id,           parent};
+    }
+  }
+  else if constexpr(widg.widget == avnd::widget_type::xyzw_spinbox)
+  {
+    static constexpr auto c = avnd::get_range<T>();
+    if constexpr(requires {
+                   c.min == 0.f;
+                   c.max == 0.f;
+                   c.init == 0.f;
+                 })
+    {
+      return new Process::XYZSpinboxes{
+          {c.min, c.min, c.min},
+          {c.max, c.max, c.max},
+          {c.init, c.init, c.init},
+          false,
+          qname,
+          id,
+          parent};
+    }
+    else
+    {
+      auto [mx, my, mz, mw] = c.min;
+      auto [Mx, My, Mz, Mw] = c.max;
+      auto [ix, iy, iz, iw] = c.init;
+      // FIXME we don't have a good 4-way widget
+      return new Process::XYZSpinboxes{{mx, my, mz}, {Mx, My, Mz}, {ix, iy, iz},
+                                       false,        qname,        id,           parent};
     }
   }
   else if constexpr(widg.widget == avnd::widget_type::color)

src/plugins/score-plugin-avnd/Crousti/CpuAnalysisNode.hpp

@@ -5,10 +5,10 @@
 
 namespace oscr
 {
-
 template <typename Node_T>
   requires(
-      (avnd::texture_output_introspection<Node_T>::size + avnd::buffer_output_introspection<Node_T>::size + avnd::geometry_output_introspection<Node_T>::size) == 0
+      (avnd::texture_output_introspection<Node_T>::size + avnd::buffer_output_introspection<Node_T>::size + avnd::geometry_output_introspection<Node_T>::size + scene_output_introspection<Node_T>::size) == 0
+      && (avnd::gpu_render_target_output_port_output_introspection<Node_T>::size == 0)
   )
 struct GfxRenderer<Node_T> final : score::gfx::OutputNodeRenderer
 {
@@ -19,6 +19,7 @@ struct GfxRenderer<Node_T> final : score::gfx::OutputNodeRenderer
   AVND_NO_UNIQUE_ADDRESS texture_inputs_storage<Node_T> texture_ins;
   AVND_NO_UNIQUE_ADDRESS buffer_inputs_storage<Node_T> buffer_ins;
   AVND_NO_UNIQUE_ADDRESS geometry_inputs_storage<Node_T> geometry_ins;
+  AVND_NO_UNIQUE_ADDRESS scene_inputs_storage<Node_T> scene_ins;
 
   const GfxNode<Node_T>& node() const noexcept
   {
@@ -44,9 +45,19 @@ struct GfxRenderer<Node_T> final : score::gfx::OutputNodeRenderer
     return {};
   }
 
-  void init(score::gfx::RenderList& renderer, QRhiResourceUpdateBatch& res) override
+  // See CpuFilterNode.hpp for the reasoning: init must live in initState
+  // so the incremental edge-rewire path also runs it.
+  void initState(score::gfx::RenderList& renderer, QRhiResourceUpdateBatch& res) override
   {
-    auto& parent = node();
+    if(m_initialized)
+      return;
+
+    // See CpuFilterNode for the reasoning: optional renderlist
+    // backchannel populated via SFINAE so nodes can reach the
+    // RenderList's GpuResourceRegistry / AssetTable without plumbing.
+    if constexpr(requires { state->renderlist = &renderer; })
+      state->renderlist = &renderer;
+
     if constexpr(requires { state->prepare(); })
     {
       this->node().processControlIn(
@@ -59,6 +70,13 @@ struct GfxRenderer<Node_T> final : score::gfx::OutputNodeRenderer
       texture_ins.init(*this, renderer);
 
     if_possible(state->init(renderer, res));
+
+    m_initialized = true;
+  }
+
+  void init(score::gfx::RenderList& renderer, QRhiResourceUpdateBatch& res) override
+  {
+    initState(renderer, res);
   }
 
   void update(
@@ -82,32 +100,69 @@ struct GfxRenderer<Node_T> final : score::gfx::OutputNodeRenderer
     }
   }
 
-  void release(score::gfx::RenderList& r) override
+  void releaseState(score::gfx::RenderList& r) override
   {
+    if(!m_initialized)
+      return;
+
     if constexpr(avnd::texture_input_introspection<Node_T>::size > 0)
       texture_ins.release();
 
     if constexpr(avnd::geometry_input_introspection<Node_T>::size > 0)
       geometry_ins.release(r);
 
+    if constexpr(scene_input_introspection<Node_T>::size > 0)
+      scene_ins.release(r);
+
     if constexpr(
         avnd::texture_input_introspection<Node_T>::size > 0
         || avnd::texture_output_introspection<Node_T>::size > 0)
     {
-      // FIXME this->defaultRelease(r);
+      // No call-through to GenericNodeRenderer::defaultRelease here:
+      // CpuAnalysisNode's GfxRenderer derives from OutputNodeRenderer,
+      // not GenericNodeRenderer, and OutputNodeRenderer has no
+      // defaultRelease equivalent (it owns no pipeline / passes — it
+      // is a sink, not a node renderer with m_p / m_pipelineCache).
+      // CpuFilterNode's mirror at line ~357 IS valid because that
+      // GfxRenderer derives from GenericNodeRenderer.
+      //
+      // If a future CpuAnalysisNode uses textures via OutputNodeRenderer
+      // surfaces, they'll need their own per-storage release path
+      // (texture_ins.release above already handles texture INPUTS).
     }
 
     if_possible(state->release(r));
+
+    // Clear the optional renderlist backchannel. Paired with initState;
+    // same SFINAE guard.
+    if constexpr(requires { state->renderlist = nullptr; })
+      state->renderlist = nullptr;
+
+    m_initialized = false;
+  }
+
+  void release(score::gfx::RenderList& r) override
+  {
+    releaseState(r);
   }
 
   void inputAboutToFinish(
       score::gfx::RenderList& renderer, const score::gfx::Port& p,
       QRhiResourceUpdateBatch*& res) override
   {
+    // Outer guard includes scene_input_introspection so a node with ONLY
+    // scene inputs (no texture / buffer / geometry) still allocates `res`
+    // — necessary if scene_inputs_storage ever grows an inputAboutToFinish
+    // method (today it's read-only via readInputScenes, but the storage's
+    // lifecycle is part of the new scene_port concept and may evolve).
+    // Without the include, a scene-only sink would silently skip the
+    // res allocation and any future scene-side write would have nowhere
+    // to land.
     if constexpr(
         avnd::texture_input_introspection<Node_T>::size > 0
         || avnd::buffer_input_introspection<Node_T>::size > 0
-        || avnd::geometry_input_introspection<Node_T>::size > 0)
+        || avnd::geometry_input_introspection<Node_T>::size > 0
+        || scene_input_introspection<Node_T>::size > 0)
     {
       res = renderer.state.rhi->nextResourceUpdateBatch();
 
@@ -118,6 +173,8 @@ struct GfxRenderer<Node_T> final : score::gfx::OutputNodeRenderer
       if constexpr(avnd::geometry_input_introspection<Node_T>::size > 0)
         geometry_ins.inputAboutToFinish(
             renderer, res, this->geometry, *state, this->node());
+      // No scene_ins.inputAboutToFinish today — the guard is forward-
+      // looking; add the call here when scene_inputs_storage grows one.
     }
 
     if_possible(state->inputAboutToFinish(renderer, p, res));
@@ -144,6 +201,8 @@ struct GfxRenderer<Node_T> final : score::gfx::OutputNodeRenderer
       buffer_ins.readInputBuffers(renderer, parent, *state);
     if constexpr(avnd::geometry_input_introspection<Node_T>::size > 0)
       geometry_ins.readInputGeometries(renderer, this->geometry, parent, *state);
+    if constexpr(scene_input_introspection<Node_T>::size > 0)
+      scene_ins.readInputScenes(this->scene, *state);
 
     parent.processControlIn(
         *this, *state, m_last_message, parent.last_message, parent.m_ctx);
@@ -158,9 +217,13 @@ struct GfxRenderer<Node_T> final : score::gfx::OutputNodeRenderer
 };
 
 template <typename Node_T>
-  requires(
-    (avnd::texture_output_introspection<Node_T>::size + avnd::buffer_output_introspection<Node_T>::size + avnd::geometry_output_introspection<Node_T>::size) == 0
-  )
+  requires((avnd::texture_output_introspection<Node_T>::size
+            + avnd::buffer_output_introspection<Node_T>::size
+            + avnd::geometry_output_introspection<Node_T>::size
+            + scene_output_introspection<Node_T>::size)
+               == 0
+           && (avnd::gpu_render_target_output_port_output_introspection<Node_T>::size
+               == 0))
 struct GfxNode<Node_T> final
     : CustomGpuOutputNodeBase
     , GpuNodeElements<Node_T>