change particle function evaluation api

6 files changed, 77 insertions, 78 deletions

diff --git a/source/blender/simulations/bparticles/actions.cpp b/source/blender/simulations/bparticles/actions.cpp
index 9aa282baa6b..7f5ac3a3e58 100644
--- a/source/blender/simulations/bparticles/actions.cpp
+++ b/source/blender/simulations/bparticles/actions.cpp
@@ -43,8 +43,8 @@ static void update_position_and_velocity_offsets(ParticleActionContext &context)
 
 void ConditionAction::execute(ParticleActionContext &context)
 {
-  auto inputs = ParticleFunctionResult::Compute(
-      *m_inputs_fn, context.pindex_mask(), context.attributes());
+  ParticleFunctionEvaluator inputs{*m_inputs_fn, context.pindex_mask(), context.attributes()};
+  inputs.compute();
 
   Vector<uint> true_pindices, false_pindices;
   for (uint pindex : context.pindex_mask().indices()) {
@@ -71,8 +71,8 @@ void SetAttributeAction::execute(ParticleActionContext &context)
 
   GenericMutableArrayRef attribute = *attribute_opt;
 
-  auto inputs = ParticleFunctionResult::Compute(
-      m_inputs_fn, context.pindex_mask(), context.attributes());
+  ParticleFunctionEvaluator inputs{m_inputs_fn, context.pindex_mask(), context.attributes()};
+  inputs.compute();
 
   for (uint pindex : context.pindex_mask().indices()) {
     const void *value = inputs.get_single("Value", 0, pindex);
@@ -102,8 +102,8 @@ void SpawnParticlesAction::execute(ParticleActionContext &context)
 
   uint array_size = context.pindex_mask().min_array_size();
 
-  auto inputs = ParticleFunctionResult::Compute(
-      m_spawn_function, context.pindex_mask(), context.attributes());
+  ParticleFunctionEvaluator inputs{m_spawn_function, context.pindex_mask(), context.attributes()};
+  inputs.compute();
 
   LargeScopedArray<int> particle_counts(array_size, -1);
 
diff --git a/source/blender/simulations/bparticles/events.cpp b/source/blender/simulations/bparticles/events.cpp
index b98b6ad1e85..451b0e76af1 100644
--- a/source/blender/simulations/bparticles/events.cpp
+++ b/source/blender/simulations/bparticles/events.cpp
@@ -14,8 +14,8 @@ void AgeReachedEvent::filter(EventFilterInterface &interface)
 {
   AttributesRef attributes = interface.attributes();
 
-  auto inputs = ParticleFunctionResult::Compute(
-      *m_inputs_fn, interface.index_mask(), interface.attributes());
+  ParticleFunctionEvaluator inputs{*m_inputs_fn, interface.index_mask(), interface.attributes()};
+  inputs.compute();
 
   float end_time = interface.step_end_time();
   auto birth_times = attributes.get<float>("Birth Time");
@@ -63,12 +63,9 @@ void CustomEvent::filter(EventFilterInterface &interface)
 {
   FN::EventFilterEndTimeContext end_time_context = {interface.step_end_time()};
 
-  auto inputs = ParticleFunctionResult::Compute(
-      m_inputs_fn,
-      interface.index_mask(),
-      interface.attributes(),
-      {BLI::get_class_id<FN::EventFilterEndTimeContext>()},
-      {(const void *)&end_time_context});
+  ParticleFunctionEvaluator inputs{m_inputs_fn, interface.index_mask(), interface.attributes()};
+  inputs.context_builder().add_global_context(end_time_context);
+  inputs.compute();
 
   for (uint pindex : interface.index_mask().indices()) {
     bool condition = inputs.get_single<bool>("Condition", 0, pindex);
diff --git a/source/blender/simulations/bparticles/forces.cpp b/source/blender/simulations/bparticles/forces.cpp
index 015fa62bcde..f340bce8245 100644
--- a/source/blender/simulations/bparticles/forces.cpp
+++ b/source/blender/simulations/bparticles/forces.cpp
@@ -12,8 +12,8 @@ void CustomForce::add_force(ForceInterface &interface)
 {
   MutableArrayRef<float3> dst = interface.combined_destination();
 
-  auto inputs = ParticleFunctionResult::Compute(
-      *m_inputs_fn, interface.pindices(), interface.attributes());
+  ParticleFunctionEvaluator inputs{*m_inputs_fn, interface.pindices(), interface.attributes()};
+  inputs.compute();
 
   for (uint pindex : interface.pindices()) {
     dst[pindex] += inputs.get_single<float3>("Force", 0, pindex);
diff --git a/source/blender/simulations/bparticles/offset_handlers.cpp b/source/blender/simulations/bparticles/offset_handlers.cpp
index d9e3ebaf9b7..77af449ca04 100644
--- a/source/blender/simulations/bparticles/offset_handlers.cpp
+++ b/source/blender/simulations/bparticles/offset_handlers.cpp
@@ -10,8 +10,8 @@ void CreateTrailHandler::execute(OffsetHandlerInterface &interface)
   auto position_offsets = interface.attribute_offsets().get<float3>("Position");
   auto colors = interface.attributes().get<rgba_f>("Color");
 
-  auto inputs = ParticleFunctionResult::Compute(
-      *m_inputs_fn, interface.pindices(), interface.attributes());
+  ParticleFunctionEvaluator inputs{*m_inputs_fn, interface.pindices(), interface.attributes()};
+  inputs.compute();
 
   Vector<float3> new_positions;
   Vector<rgba_f> new_colors;
@@ -53,8 +53,8 @@ void SizeOverTimeHandler::execute(OffsetHandlerInterface &interface)
   auto birth_times = interface.attributes().get<float>("Birth Time");
   auto sizes = interface.attributes().get<float>("Size");
 
-  auto inputs = ParticleFunctionResult::Compute(
-      *m_inputs_fn, interface.pindices(), interface.attributes());
+  ParticleFunctionEvaluator inputs{*m_inputs_fn, interface.pindices(), interface.attributes()};
+  inputs.compute();
 
   for (uint pindex : interface.pindices()) {
     float final_size = inputs.get_single<float>("Final Size", 0, pindex);
diff --git a/source/blender/simulations/bparticles/particle_function.cpp b/source/blender/simulations/bparticles/particle_function.cpp
index 7654e1dd562..a0b7772a46d 100644
--- a/source/blender/simulations/bparticles/particle_function.cpp
+++ b/source/blender/simulations/bparticles/particle_function.cpp
@@ -41,32 +41,30 @@ ParticleFunction::ParticleFunction(const MultiFunction &fn,
   }
 }
 
-ParticleFunctionResult::~ParticleFunctionResult()
+ParticleFunctionEvaluator::~ParticleFunctionEvaluator()
 {
-  for (GenericVectorArray *vector_array : m_vector_arrays) {
+  BLI_assert(m_is_computed);
+  for (GenericVectorArray *vector_array : m_computed_vector_arrays) {
     delete vector_array;
   }
-  for (GenericMutableArrayRef array : m_arrays) {
+  for (GenericMutableArrayRef array : m_computed_arrays) {
     array.destruct_indices(m_mask.indices());
     MEM_freeN(array.buffer());
   }
 }
 
-ParticleFunctionResult ParticleFunctionResult::Compute(const ParticleFunction &particle_fn,
-                                                       IndexMask mask,
-                                                       AttributesRef attributes,
-                                                       ArrayRef<BLI::class_id_t> context_ids,
-                                                       ArrayRef<const void *> contexts)
+void ParticleFunctionEvaluator::compute()
 {
-  uint array_size = mask.min_array_size();
+  BLI_assert(!m_is_computed);
 
-  const MultiFunction &fn = particle_fn.m_fn;
+  uint array_size = m_mask.min_array_size();
 
-  ParticleFunctionResult result;
-  result.m_mask = mask;
-  result.m_index_mapping = particle_fn.m_index_mapping;
-  result.m_computed_names = particle_fn.m_computed_names;
+  FN::ParticleAttributesContext attributes_context(m_particle_attributes);
+  m_context_builder.add_element_context(attributes_context, IndexRange(array_size));
+  m_context_builder.add_global_context(m_particle_fn.m_id_data_cache);
+  m_context_builder.add_global_context(m_particle_fn.m_id_handle_lookup);
 
+  const MultiFunction &fn = m_particle_fn.fn();
   MFParamsBuilder params_builder(fn, array_size);
   for (uint param_index : fn.param_indices()) {
     MFParamType param_type = fn.param_type(param_index);
@@ -78,33 +76,21 @@ ParticleFunctionResult ParticleFunctionResult::Compute(const ParticleFunction &p
         void *buffer = MEM_mallocN_aligned(array_size * type.size(), type.alignment(), __func__);
         GenericMutableArrayRef array{type, buffer, array_size};
         params_builder.add_single_output(array);
-        result.m_arrays.append(array);
+        m_computed_arrays.append(array);
         break;
       }
       case MFDataType::Vector: {
         const CPPType &base_type = data_type.vector__cpp_base_type();
         GenericVectorArray *vector_array = new GenericVectorArray(base_type, array_size);
         params_builder.add_vector_output(*vector_array);
-        result.m_vector_arrays.append(vector_array);
+        m_computed_vector_arrays.append(vector_array);
         break;
       }
     }
   }
 
-  FN::ParticleAttributesContext attributes_context(attributes);
-
-  MFContextBuilder context_builder;
-  context_builder.add_element_context(attributes_context, IndexRange(array_size));
-  context_builder.add_global_context(particle_fn.m_id_data_cache);
-  context_builder.add_global_context(particle_fn.m_id_handle_lookup);
-
-  for (uint i : context_ids.index_iterator()) {
-    context_builder.add_global_context(context_ids[i], contexts[i]);
-  }
-
-  fn.call(mask, params_builder, context_builder);
-
-  return result;
+  fn.call(m_mask, params_builder, m_context_builder);
+  m_is_computed = true;
 }
 
 }  // namespace BParticles
diff --git a/source/blender/simulations/bparticles/particle_function.hpp b/source/blender/simulations/bparticles/particle_function.hpp
index 1611df2e5dc..c16a4e4a5c0 100644
--- a/source/blender/simulations/bparticles/particle_function.hpp
+++ b/source/blender/simulations/bparticles/particle_function.hpp
@@ -30,7 +30,7 @@ class ParticleFunction {
   const BKE::IDDataCache &m_id_data_cache;
   const BKE::IDHandleLookup &m_id_handle_lookup;
 
-  friend class ParticleFunctionResult;
+  friend class ParticleFunctionEvaluator;
 
  public:
   ParticleFunction(const MultiFunction &fn,
@@ -44,73 +44,89 @@ class ParticleFunction {
   }
 };
 
-class ParticleFunctionResult : BLI::NonCopyable {
+class ParticleFunctionEvaluator {
  private:
-  Vector<GenericVectorArray *> m_vector_arrays;
-  Vector<GenericMutableArrayRef> m_arrays;
-
-  ArrayRef<uint> m_index_mapping;
+  const ParticleFunction &m_particle_fn;
   IndexMask m_mask;
-  ArrayRef<std::string> m_computed_names;
+  AttributesRef m_particle_attributes;
+  bool m_is_computed = false;
+
+  FN::MFContextBuilder m_context_builder;
 
-  ParticleFunctionResult() = default;
+  Vector<GenericVectorArray *> m_computed_vector_arrays;
+  Vector<GenericMutableArrayRef> m_computed_arrays;
 
  public:
-  ~ParticleFunctionResult();
-  ParticleFunctionResult(ParticleFunctionResult &&other) = default;
+  ParticleFunctionEvaluator(const ParticleFunction &particle_fn,
+                            IndexMask mask,
+                            AttributesRef particle_attributes)
+      : m_particle_fn(particle_fn), m_mask(mask), m_particle_attributes(particle_attributes)
+  {
+  }
+
+  ~ParticleFunctionEvaluator();
+
+  FN::MFContextBuilder &context_builder()
+  {
+    return m_context_builder;
+  }
+
+  void compute();
 
-  static ParticleFunctionResult Compute(const ParticleFunction &particle_fn,
-                                        IndexMask mask,
-                                        AttributesRef attributes,
-                                        ArrayRef<BLI::class_id_t> context_ids = {},
-                                        ArrayRef<const void *> contexts = {});
+  /* Access computed values
+   *********************************************/
 
   const void *get_single(StringRef expected_name, uint param_index, uint pindex)
   {
+    BLI_assert(m_is_computed);
     UNUSED_VARS_NDEBUG(expected_name);
 #ifdef DEBUG
-    StringRef actual_name = m_computed_names[param_index];
+    StringRef actual_name = m_particle_fn.m_computed_names[param_index];
     BLI_assert(expected_name == actual_name);
 #endif
-    uint corrected_index = m_index_mapping[param_index];
-    return m_arrays[corrected_index][pindex];
+    uint corrected_index = m_particle_fn.m_index_mapping[param_index];
+    return m_computed_arrays[corrected_index][pindex];
   }
 
   template<typename T> const T &get_single(StringRef expected_name, uint param_index, uint pindex)
   {
+    BLI_assert(m_is_computed);
     UNUSED_VARS_NDEBUG(expected_name);
 #ifdef DEBUG
-    StringRef actual_name = m_computed_names[param_index];
+    StringRef actual_name = m_particle_fn.m_computed_names[param_index];
     BLI_assert(expected_name == actual_name);
 #endif
-    uint corrected_index = m_index_mapping[param_index];
-    ArrayRef<T> array = m_arrays[corrected_index].as_typed_ref<T>();
+    uint corrected_index = m_particle_fn.m_index_mapping[param_index];
+    ArrayRef<T> array = m_computed_arrays[corrected_index].as_typed_ref<T>();
     return array[pindex];
   }
 
   template<typename T>
   ArrayRef<T> get_vector(StringRef expected_name, uint param_index, uint pindex)
   {
+    BLI_assert(m_is_computed);
     UNUSED_VARS_NDEBUG(expected_name);
 #ifdef DEBUG
-    StringRef actual_name = m_computed_names[param_index];
+    StringRef actual_name = m_particle_fn.m_computed_names[param_index];
     BLI_assert(expected_name == actual_name);
 #endif
-    uint corrected_index = m_index_mapping[param_index];
-    GenericVectorArray &vector_array = *m_vector_arrays[corrected_index];
+    uint corrected_index = m_particle_fn.m_index_mapping[param_index];
+    GenericVectorArray &vector_array = *m_computed_vector_arrays[corrected_index];
     return vector_array[pindex].as_typed_ref<T>();
   }
 
   GenericVectorArray &computed_vector_array(uint param_index)
   {
-    uint corrected_index = m_index_mapping[param_index];
-    return *m_vector_arrays[corrected_index];
+    BLI_assert(m_is_computed);
+    uint corrected_index = m_particle_fn.m_index_mapping[param_index];
+    return *m_computed_vector_arrays[corrected_index];
   }
 
   GenericArrayRef computed_array(uint param_index)
   {
-    uint corrected_index = m_index_mapping[param_index];
-    return m_arrays[corrected_index];
+    BLI_assert(m_is_computed);
+    uint corrected_index = m_particle_fn.m_index_mapping[param_index];
+    return m_computed_arrays[corrected_index];
   }
 };