fix/crash deleting source during process path generator (#25)

* fixed output tab size declaration on update

Author: D3mh4

GBAP/GBAPModel.cpp

@@ -230,4 +230,4 @@ void GBAP::updateInterv(){
                     : 0;
 }
 
-}
+}

PathGenerator/PathGeneratorModel.cpp

@@ -4,14 +4,23 @@
 
 namespace Example {
 
+// Constants for angle calculations
 constexpr float TWO_PI = 2.0f * std::numbers::pi;
 constexpr float FOUR_PI = 4.0f * std::numbers::pi;
 
 void PathGenerator::operator()(const halp::tick_flicks& t) {
+  float relativePos = std::fmod(t.relative_position * inputs.speed, 1.0f);
+  bool reverse = static_cast<int>(t.relative_position * inputs.speed) % 2 != 0;
 
-  float relativePos = fmod(t.relative_position * inputs.speed, 1.0f);
-  bool reverse = (int(t.relative_position * inputs.speed) % 2) != 0;
+  outputs.OutTab.value.clear();
 
+  // Initialize output positions with first point from each input
+  for (const auto& val : inputs.pos.value) {
+    const auto& vec = val.get<std::vector<ossia::value>>();
+    outputs.OutTab.value.push_back(vec[0].get<ossia::vec2f>());
+  }
+
+  // Dispatch to path function
   switch (inputs.Path) {
     case 0: linear_path(t, relativePos, reverse); break;
     case 1: circle_path(t, relativePos, reverse); break;
@@ -20,52 +29,63 @@ void PathGenerator::operator()(const halp::tick_flicks& t) {
   }
 }
 
-void PathGenerator::linear_path(const halp::tick_flicks& t, float relativePos, bool reverse) {
-
-  for (size_t v = 0; v < outputs.OutTab.value.size(); v++) {
-    const auto start = inputs.pos.value[v].get<std::vector<ossia::value>>()[0].get<ossia::vec2f>();
-    const auto end   = inputs.pos.value[v].get<std::vector<ossia::value>>()[1].get<ossia::vec2f>();
-    auto& out  = outputs.OutTab.value[v].get<ossia::vec2f>();
+// Linear interpolation between two points
+void PathGenerator::linear_path(const halp::tick_flicks&, float relativePos, bool reverse) {
+  for (size_t i = 0; i < outputs.OutTab.value.size(); ++i) {
+    const auto& vec = inputs.pos.value[i].get<std::vector<ossia::value>>();
+    const auto& start = vec[0].get<ossia::vec2f>();
+    const auto& end   = vec[1].get<ossia::vec2f>();
+    auto& out = outputs.OutTab.value[i].get<ossia::vec2f>();
 
     if (inputs.loop && reverse) {
-      out[0] = end[0] - (end[0] - start[0]) * relativePos;
-      out[1] = end[1] - (end[1] - start[1]) * relativePos;
+      out = {
+          end[0] - (end[0] - start[0]) * relativePos,
+          end[1] - (end[1] - start[1]) * relativePos
+      };
     } else {
-      out[0] = start[0] + (end[0] - start[0]) * relativePos;
-      out[1] = start[1] + (end[1] - start[1]) * relativePos;
+      out = {
+          start[0] + (end[0] - start[0]) * relativePos,
+          start[1] + (end[1] - start[1]) * relativePos
+      };
     }
   }
 }
 
-void PathGenerator::circle_path(const halp::tick_flicks& t, const float relativePos, const bool reverse) {
+// Generate circular motion around a point
+void PathGenerator::circle_path(const halp::tick_flicks&, float relativePos, bool reverse) {
+  float angle = TWO_PI * (inputs.loop && reverse ? relativePos : 1.0f - relativePos);
 
-  const float angle = TWO_PI * (inputs.loop && reverse ? 1. - relativePos : relativePos);
+  for (size_t i = 0; i < outputs.OutTab.value.size(); ++i) {
+    const auto& center = inputs.pos.value[i].get<std::vector<ossia::value>>()[0].get<ossia::vec2f>();
+    auto& out = outputs.OutTab.value[i].get<ossia::vec2f>();
 
-  for (size_t v = 0; v < outputs.OutTab.value.size(); v++) {
-    const auto point = inputs.pos.value[v].get<std::vector<ossia::value>>()[0].get<ossia::vec2f>();
-    auto& out  = outputs.OutTab.value[v].get<ossia::vec2f>();
-
-    out[0] = point[0] + inputs.radius.value.x * std::cos(angle);
-    out[1] = point[1] + inputs.radius.value.y * std::sin(angle);
+    out = {
+        center[0] + inputs.radius.value.x * std::cos(angle),
+        center[1] + inputs.radius.value.y * std::sin(angle)
+    };
   }
 }
 
-void PathGenerator::spiral_path(const halp::tick_flicks& t,const float relativePos,const bool reverse) {
-
-  const float angle = relativePos * FOUR_PI;
-  const float radX = inputs.radius.value.x * relativePos;
-  const float radY = inputs.radius.value.y * relativePos;
+// Generate expanding spiral motion around a point
+void PathGenerator::spiral_path(const halp::tick_flicks&, float relativePos, bool reverse) {
+  float angle = FOUR_PI * (inputs.loop && reverse ? 1.0f - relativePos : relativePos);
+  float radX = inputs.radius.value.x * relativePos;
+  float radY = inputs.radius.value.y * relativePos;
 
-  for (size_t v = 0; v < outputs.OutTab.value.size(); v++) {
-    auto point = inputs.pos.value[v].get<std::vector<ossia::value>>()[0].get<ossia::vec2f>();
-    auto& out  = outputs.OutTab.value[v].get<ossia::vec2f>();
+  for (size_t i = 0; i < outputs.OutTab.value.size(); ++i) {
+    const auto& center = inputs.pos.value[i].get<std::vector<ossia::value>>()[0].get<ossia::vec2f>();
+    auto& out = outputs.OutTab.value[i].get<ossia::vec2f>();
 
     if (inputs.loop && reverse) {
-      out[0] = point[0] + (inputs.radius.value.x - radX) * std::cos((1 - relativePos) * FOUR_PI);
-      out[1] = point[1] + (inputs.radius.value.y - radY) * std::sin((1 - relativePos) * FOUR_PI);
+      out = {
+          center[0] + (inputs.radius.value.x - radX) * std::cos(angle),
+          center[1] + (inputs.radius.value.y - radY) * std::sin(angle)
+      };
     } else {
-      out[0] = point[0] + radX * std::cos(angle);
-      out[1] = point[1] + radY * std::sin(angle);
+      out = {
+          center[0] + radX * std::cos(angle),
+          center[1] + radY * std::sin(angle)
+      };
     }
   }
 }

PathGenerator/PathGeneratorModel.hpp

@@ -41,16 +41,6 @@ class PathGenerator {
     halp::val_port<"Output", std::vector<ossia::value>> OutTab;
   } outputs;
 
-  using setup = halp::setup;
-
-  void prepare(halp::setup info) {
-    for (size_t i = 0; i < inputs.pos.value.size(); i++) {
-      outputs.OutTab.value.push_back(
-          inputs.pos.value[i].get<std::vector<ossia::value>>()[0].get<ossia::vec2f>()
-          );
-    }
-  }
-
   using tick = halp::tick_flicks;
 
   void operator()(const halp::tick_flicks& t);