extend single elements when necessary

3 files changed, 81 insertions, 16 deletions

diff --git a/source/blender/functions/FN_generic_virtual_list_list_ref.h b/source/blender/functions/FN_generic_virtual_list_list_ref.h
index 9ccaef6b019..358b40ed780 100644
--- a/source/blender/functions/FN_generic_virtual_list_list_ref.h
+++ b/source/blender/functions/FN_generic_virtual_list_list_ref.h
@@ -152,6 +152,28 @@ class GenericVirtualListListRef {
     BLI_assert(false);
     return {*m_type};
   }
+
+  GenericVirtualListListRef extended_single_list(uint new_virtual_size) const
+  {
+    BLI_assert(this->is_single_list());
+
+    switch (m_category) {
+      case Category::SingleArray:
+        return GenericVirtualListListRef::FromSingleArray(*m_type,
+                                                          m_data.single_array.data,
+                                                          m_data.single_array.real_array_size,
+                                                          new_virtual_size);
+      case Category::FullArrayList:
+        return GenericVirtualListListRef::FromSingleArray(
+            *m_type,
+            m_data.full_array_list.starts[0],
+            m_data.full_array_list.real_array_sizes[0],
+            new_virtual_size);
+    }
+
+    BLI_assert(false);
+    return {};
+  }
 };
 
 }  // namespace FN
diff --git a/source/blender/functions/intern/multi_functions/network.cc b/source/blender/functions/intern/multi_functions/network.cc
index fd22ef7f887..c53fb6cbafa 100644
--- a/source/blender/functions/intern/multi_functions/network.cc
+++ b/source/blender/functions/intern/multi_functions/network.cc
@@ -88,6 +88,26 @@ class MF_EvaluateNetwork_Storage {
     return new_vector_array;
   }
 
+  GenericMutableArrayRef allocate_full_copy_from_single(GenericMutableArrayRef array)
+  {
+    BLI_assert(array.size() == 1);
+    GenericMutableArrayRef new_array = this->allocate_array(array.type());
+    for (uint i : m_mask.indices()) {
+      new_array.copy_in__uninitialized(i, array[0]);
+    }
+    return new_array;
+  }
+
+  GenericVectorArray &allocate_full_copy_from_single(GenericVectorArray &vector_array)
+  {
+    BLI_assert(vector_array.size() == 1);
+    GenericVectorArray &new_vector_array = this->allocate_vector_array(vector_array.type());
+    for (uint i : m_mask.indices()) {
+      new_vector_array.extend_single__copy(i, vector_array[0]);
+    }
+    return new_vector_array;
+  }
+
   void set_array_ref_for_input(const MFInputSocket &socket, GenericMutableArrayRef array)
   {
     m_array_ref_for_inputs.add_new(socket.id(), array);
@@ -330,9 +350,9 @@ BLI_NOINLINE void MF_EvaluateNetwork::compute_and_forward_outputs(
   const MultiFunction &function = function_node.function();
   MFParamsBuilder params_builder(function, storage.mask().min_array_size());
 
-  this->prepare_function_params(function_node, storage, params_builder);
+  this->prepare_function_params__all(function_node, storage, params_builder);
   function.call(storage.mask(), params_builder, global_context);
-  this->forward_computed_values(function_node, storage, params_builder);
+  this->forward_computed_values__all(function_node, storage, params_builder);
 }
 
 BLI_NOINLINE bool MF_EvaluateNetwork::can_evaluate_function_only_ones(
@@ -351,10 +371,11 @@ BLI_NOINLINE bool MF_EvaluateNetwork::can_evaluate_function_only_ones(
   return true;
 }
 
-BLI_NOINLINE void MF_EvaluateNetwork::prepare_function_params(
+BLI_NOINLINE void MF_EvaluateNetwork::prepare_function_params__all(
     const MFFunctionNode &function_node, Storage &storage, MFParamsBuilder &params_builder) const
 {
   const MultiFunction &function = function_node.function();
+  uint array_size = storage.mask().min_array_size();
 
   for (uint param_index : function.param_indices()) {
     MFParamType param_type = function.param_type(param_index);
@@ -362,12 +383,20 @@ BLI_NOINLINE void MF_EvaluateNetwork::prepare_function_params(
       case MFParamType::SingleInput: {
         const MFInputSocket &input_socket = function_node.input_for_param(param_index);
         GenericVirtualListRef values = storage.get_virtual_list_for_input(input_socket);
+        if (values.size() < array_size) {
+          BLI_assert(values.is_single_element());
+          values = GenericVirtualListRef::FromSingle(values.type(), values[0], array_size);
+        }
         params_builder.add_readonly_single_input(values);
         break;
       }
       case MFParamType::VectorInput: {
         const MFInputSocket &input_socket = function_node.input_for_param(param_index);
         GenericVirtualListListRef values = storage.get_virtual_list_list_for_input(input_socket);
+        if (values.size() < array_size) {
+          BLI_assert(values.is_single_list());
+          values = values.extended_single_list(array_size);
+        }
         params_builder.add_readonly_vector_input(values);
         break;
       }
@@ -383,23 +412,37 @@ BLI_NOINLINE void MF_EvaluateNetwork::prepare_function_params(
         params_builder.add_vector_output(values_destination);
         break;
       }
-      case MFParamType::MutableVector: {
+      case MFParamType::MutableSingle: {
         const MFInputSocket &input_socket = function_node.input_for_param(param_index);
-        GenericVectorArray &values = storage.get_vector_array_for_input(input_socket);
-        params_builder.add_mutable_vector(values);
+        GenericMutableArrayRef values = storage.get_array_ref_for_input(input_socket);
+        if (values.size() < array_size) {
+          BLI_assert(values.size() == 1);
+          GenericMutableArrayRef new_values = storage.allocate_full_copy_from_single(values);
+          params_builder.add_mutable_single(new_values);
+        }
+        else {
+          params_builder.add_mutable_single(values);
+        }
         break;
       }
-      case MFParamType::MutableSingle: {
+      case MFParamType::MutableVector: {
         const MFInputSocket &input_socket = function_node.input_for_param(param_index);
-        GenericMutableArrayRef values = storage.get_array_ref_for_input(input_socket);
-        params_builder.add_mutable_single(values);
+        GenericVectorArray &values = storage.get_vector_array_for_input(input_socket);
+        if (values.size() < array_size) {
+          BLI_assert(values.size() == 1);
+          GenericVectorArray &new_values = storage.allocate_full_copy_from_single(values);
+          params_builder.add_mutable_vector(new_values);
+        }
+        else {
+          params_builder.add_mutable_vector(values);
+        }
         break;
       }
     }
   }
 }
 
-BLI_NOINLINE void MF_EvaluateNetwork::forward_computed_values(
+BLI_NOINLINE void MF_EvaluateNetwork::forward_computed_values__all(
     const MFFunctionNode &function_node, Storage &storage, MFParamsBuilder &params_builder) const
 {
   const MultiFunction &function = function_node.function();
diff --git a/source/blender/functions/intern/multi_functions/network.h b/source/blender/functions/intern/multi_functions/network.h
index 32dc2402f8e..fb1f899b0e1 100644
--- a/source/blender/functions/intern/multi_functions/network.h
+++ b/source/blender/functions/intern/multi_functions/network.h
@@ -39,12 +39,12 @@ class MF_EvaluateNetwork final : public MultiFunction {
                                    const MFFunctionNode &function_node,
                                    Storage &storage) const;
   bool can_evaluate_function_only_ones(const MFFunctionNode &function_node, Storage &storage);
-  void prepare_function_params(const MFFunctionNode &function_node,
-                               Storage &storage,
-                               MFParamsBuilder &params_builder) const;
-  void forward_computed_values(const MFFunctionNode &function_node,
-                               Storage &storage,
-                               MFParamsBuilder &params_builder) const;
+  void prepare_function_params__all(const MFFunctionNode &function_node,
+                                    Storage &storage,
+                                    MFParamsBuilder &params_builder) const;
+  void forward_computed_values__all(const MFFunctionNode &function_node,
+                                    Storage &storage,
+                                    MFParamsBuilder &params_builder) const;
 
   void copy_computed_values_to_outputs(MFParams params, Storage &storage) const;
 };