avnd: use local implementation of reflection as much as possible with clang-22 to fix build issues

Author: jcelerier

3rdparty/avendish

@@ -154,7 +154,7 @@ struct generate_shaders
             ,
             C::binding(), C::name());
 
-        boost::pfr::for_each_field(field, write_binding{shader});
+        avnd::pfr::for_each_field(field, write_binding{shader});
 
         shader += fmt::format("}};\n\n");
       }
@@ -166,7 +166,7 @@ struct generate_shaders
             ,
             C::binding(), C::name());
 
-        boost::pfr::for_each_field(field, write_binding{shader});
+        avnd::pfr::for_each_field(field, write_binding{shader});
 
         shader += fmt::format("}};\n\n");
       }
@@ -180,24 +180,24 @@ struct generate_shaders
     std::string shader = "#version 450\n\n";
 
     if constexpr(requires { lay.vertex_input; })
-      boost::pfr::for_each_field(lay.vertex_input, write_input{shader});
+      avnd::pfr::for_each_field(lay.vertex_input, write_input{shader});
     else if constexpr(requires { typename T::vertex_input; })
-      boost::pfr::for_each_field(typename T::vertex_input{}, write_input{shader});
+      avnd::pfr::for_each_field(typename T::vertex_input{}, write_input{shader});
     else
-      boost::pfr::for_each_field(
+      avnd::pfr::for_each_field(
           DefaultPipeline::layout::vertex_input{}, write_input{shader});
 
     if constexpr(requires { lay.vertex_output; })
-      boost::pfr::for_each_field(lay.vertex_output, write_output{shader});
+      avnd::pfr::for_each_field(lay.vertex_output, write_output{shader});
     else if constexpr(requires { typename T::vertex_output; })
-      boost::pfr::for_each_field(typename T::vertex_output{}, write_output{shader});
+      avnd::pfr::for_each_field(typename T::vertex_output{}, write_output{shader});
 
     shader += "\n";
 
     if constexpr(requires { lay.bindings; })
-      boost::pfr::for_each_field(lay.bindings, write_bindings{shader});
+      avnd::pfr::for_each_field(lay.bindings, write_bindings{shader});
     else if constexpr(requires { typename T::bindings; })
-      boost::pfr::for_each_field(typename T::bindings{}, write_bindings{shader});
+      avnd::pfr::for_each_field(typename T::bindings{}, write_bindings{shader});
 
     return shader;
   }
@@ -208,21 +208,21 @@ struct generate_shaders
     std::string shader = "#version 450\n\n";
 
     if constexpr(requires { lay.fragment_input; })
-      boost::pfr::for_each_field(lay.fragment_input, write_input{shader});
+      avnd::pfr::for_each_field(lay.fragment_input, write_input{shader});
     else if constexpr(requires { typename T::fragment_input; })
-      boost::pfr::for_each_field(typename T::fragment_input{}, write_input{shader});
+      avnd::pfr::for_each_field(typename T::fragment_input{}, write_input{shader});
 
     if constexpr(requires { lay.fragment_output; })
-      boost::pfr::for_each_field(lay.fragment_output, write_output{shader});
+      avnd::pfr::for_each_field(lay.fragment_output, write_output{shader});
     else if constexpr(requires { typename T::fragment_output; })
-      boost::pfr::for_each_field(typename T::fragment_output{}, write_output{shader});
+      avnd::pfr::for_each_field(typename T::fragment_output{}, write_output{shader});
 
     shader += "\n";
 
     if constexpr(requires { lay.bindings; })
-      boost::pfr::for_each_field(lay.bindings, write_bindings{shader});
+      avnd::pfr::for_each_field(lay.bindings, write_bindings{shader});
     else if constexpr(requires { typename T::bindings; })
-      boost::pfr::for_each_field(typename T::bindings{}, write_bindings{shader});
+      avnd::pfr::for_each_field(typename T::bindings{}, write_bindings{shader});
 
     return shader;
   }
@@ -250,7 +250,7 @@ struct generate_shaders
     fstr.resize(fstr.size() - 2);
     fstr += ") in;\n\n";
 
-    boost::pfr::for_each_field(lay.bindings, write_bindings{fstr});
+    avnd::pfr::for_each_field(lay.bindings, write_bindings{fstr});
 
     return fstr;
   }

3rdparty/libossia

@@ -175,7 +175,7 @@ struct GpuComputeRenderer final : ComputeRendererBaseType<Node_T>
     QVarLengthArray<QRhiShaderResourceBinding, 8> bindings;
 
     using bindings_type = decltype(Node_T::layout::bindings);
-    boost::pfr::for_each_field(
+    avnd::pfr::for_each_field(
         bindings_type{}, [&](auto f) { bindings.push_back(initBinding(renderer, f)); });
 
     srb->setBindings(bindings.begin(), bindings.end());

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

@@ -113,14 +113,14 @@ struct CustomGpuRenderer final : score::gfx::NodeRenderer
     if constexpr(requires { decltype(Node_T::layout::bindings){}; })
     {
       using bindings_type = decltype(Node_T::layout::bindings);
-      boost::pfr::for_each_field(bindings_type{}, [&](auto f) {
+      avnd::pfr::for_each_field(bindings_type{}, [&](auto f) {
         bindings.push_back(initBinding(renderer, f));
       });
     }
     else if constexpr(requires { sizeof(typename Node_T::layout::bindings); })
     {
       using bindings_type = typename Node_T::layout::bindings;
-      boost::pfr::for_each_field(bindings_type{}, [&](auto f) {
+      avnd::pfr::for_each_field(bindings_type{}, [&](auto f) {
         bindings.push_back(initBinding(renderer, f));
       });
     }

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

@@ -459,9 +459,25 @@ struct port_to_type_enum
   {
     using value_type = std::remove_cvref_t<decltype(F::value)>;
 
-    if constexpr(std::is_aggregate_v<value_type>)
+    if constexpr(std::is_array_v<value_type>)
     {
-      constexpr int sz = boost::pfr::tuple_size_v<value_type>;
+      static constexpr int sz = sizeof(value_type) / sizeof(value_type{}[0]);
+      if constexpr(sz == 2)
+      {
+        return score::gfx::Types::Vec2;
+      }
+      else if constexpr(sz == 3)
+      {
+        return score::gfx::Types::Vec3;
+      }
+      else if constexpr(sz == 4)
+      {
+        return score::gfx::Types::Vec4;
+      }
+    }
+    else if constexpr(std::is_aggregate_v<value_type>)
+    {
+      static constexpr int sz = avnd::pfr::tuple_size_v<value_type>;
       if constexpr(sz == 2)
       {
         return score::gfx::Types::Vec2;

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

@@ -15,6 +15,8 @@
 
 #include <avnd/concepts/layout.hpp>
 
+#include <avnd/common/aggregates.hpp>
+
 namespace oscr
 {
 template <typename Item>
@@ -333,13 +335,11 @@ struct LayoutBuilder final : Process::LayoutBuilderBase
     createdLayouts.push_back(new_l);
 
     {
-      using namespace boost::pfr;
-      using namespace boost::pfr::detail;
-      static constexpr int N = boost::pfr::tuple_size_v<Item>;
-      auto t = boost::pfr::structure_tie(item);
+      static constexpr int N = avnd::pfr::tuple_size_v<Item>;
+      auto t = avnd::pfr::detail::tie_as_tuple(item);
       [&]<std::size_t... I>(std::index_sequence<I...>) {
         using namespace std;
-        using namespace boost::pfr;
+        using namespace avnd::pfr;
 
         (this->walkLayout(get<I>(t), recursive_members...), ...);
       }(std::make_index_sequence<N>{});

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

@@ -19,7 +19,7 @@ struct Serializer
     if constexpr(std::is_arithmetic_v<F>)
       r.stream().stream << f;
     else if constexpr(std::is_aggregate_v<F>)
-      boost::pfr::for_each_field(f, *this);
+      avnd::pfr::for_each_field(f, *this);
     else if constexpr(avnd::list_ish<F>)
     {
       r.stream().stream << (int64_t)std::ssize(f);
@@ -115,8 +115,11 @@ struct Deserializer
   DataStreamWriter& r;
 
   template <typename F>
-  requires std::is_aggregate_v<F>
-  void operator()(F& f) { boost::pfr::for_each_field(f, *this); }
+    requires std::is_aggregate_v<F>
+  void operator()(F& f)
+  {
+    avnd::pfr::for_each_field(f, *this);
+  }
 
   template <typename F>
     requires(std::is_arithmetic_v<F>)

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

@@ -5,7 +5,6 @@
 #include <ossia/dataflow/safe_nodes/port.hpp>
 
 #include <boost/mp11/algorithm.hpp>
-#include <boost/pfr.hpp>
 
 #include <avnd/introspection/input.hpp>
 #include <avnd/introspection/output.hpp>

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

@@ -19,8 +19,6 @@
 #include <ossia/detail/type_if.hpp>
 #include <ossia/detail/typelist.hpp>
 
-#include <boost/pfr.hpp>
-
 #include <QTimer>
 
 #include <avnd/binding/ossia/data_node.hpp>