[Bf-blender-cvs] [904966b3efb] functions: particle function contains two functions: with/without dependencies

Jacques Lucke noreply at git.blender.org
Mon Jul 29 17:57:09 CEST 2019


Commit: 904966b3efbf4db0daf41d4f6ae5f5ab7e6eccd0
Author: Jacques Lucke
Date:   Mon Jul 29 11:14:38 2019 +0200
Branches: functions
https://developer.blender.org/rB904966b3efbf4db0daf41d4f6ae5f5ab7e6eccd0

particle function contains two functions: with/without dependencies

===================================================================

M	source/blender/simulations/bparticles/inserters.cpp
M	source/blender/simulations/bparticles/particle_function.cpp
M	source/blender/simulations/bparticles/particle_function.hpp

===================================================================

diff --git a/source/blender/simulations/bparticles/inserters.cpp b/source/blender/simulations/bparticles/inserters.cpp
index 74c667e3ffe..00d4f2198ee 100644
--- a/source/blender/simulations/bparticles/inserters.cpp
+++ b/source/blender/simulations/bparticles/inserters.cpp
@@ -87,7 +87,12 @@ ValueOrError<ParticleFunction> create_particle_function(VirtualNode *main_vnode,
   FunctionGraph fgraph(data_graph.graph(), dependencies.sockets, sockets_to_compute);
   FN::fgraph_add_TupleCallBody(fn, fgraph);
 
-  ParticleFunction particle_function(fn);
+  FunctionBuilder empty_fn_builder;
+  SharedFunction empty_fn = empty_fn_builder.build("Empty");
+
+  Vector<bool> depends_on_particle(fn->output_amount(), true);
+
+  ParticleFunction particle_function(empty_fn, fn, depends_on_particle);
   return particle_function;
 }
 
@@ -241,13 +246,13 @@ static std::unique_ptr<Event> BUILD_EVENT_close_by_points(BuildContext &ctx,
                                                           VirtualNode *vnode,
                                                           ParticleFunction compute_inputs)
 {
-  if (compute_inputs.depends_on_particle()) {
+  if (compute_inputs.parameter_depends_on_particle("Points", 0)) {
     return {};
   }
 
   auto action = build_action_for_trigger(ctx, vnode->output(0));
 
-  SharedFunction &fn = compute_inputs.function();
+  SharedFunction &fn = compute_inputs.function_no_deps();
   BLI_assert(fn->input_amount() == 0);
   TupleCallBody &body = fn->body<TupleCallBody>();
   FN_TUPLE_CALL_ALLOC_TUPLES(body, fn_in, fn_out);
diff --git a/source/blender/simulations/bparticles/particle_function.cpp b/source/blender/simulations/bparticles/particle_function.cpp
index ca31936ba04..b002d36217f 100644
--- a/source/blender/simulations/bparticles/particle_function.cpp
+++ b/source/blender/simulations/bparticles/particle_function.cpp
@@ -41,37 +41,46 @@ std::unique_ptr<ParticleFunctionResult> ParticleFunction::compute(ArrayAllocator
                                                                   AttributeArrays attributes,
                                                                   ActionContext *action_context)
 {
-  if (m_fn->input_amount() == 0) {
-    BLI_assert(array_allocator.array_size() >= 1);
+  uint parameter_amount = m_parameter_depends_on_particle.size();
 
-    ParticleFunctionResult *result = new ParticleFunctionResult();
-    result->m_fn = m_fn.ptr();
-    result->m_array_allocator = &array_allocator;
+  ParticleFunctionResult *result = new ParticleFunctionResult();
+  result->m_array_allocator = &array_allocator;
+  result->m_buffers.append_n_times(nullptr, parameter_amount);
+  result->m_only_first.append_n_times(false, parameter_amount);
+  result->m_strides.append_n_times(0, parameter_amount);
 
-    FN_TUPLE_CALL_ALLOC_TUPLES(*m_body, fn_in, fn_out);
-    m_body->call__setup_execution_context(fn_in, fn_out);
+  if (m_fn_no_deps->output_amount() > 0) {
+    TupleCallBody &body = m_fn_no_deps->body<TupleCallBody>();
 
-    for (uint i = 0; i < m_fn->output_amount(); i++) {
-      CPPTypeInfo &type_info = m_fn->output_type(i)->extension<CPPTypeInfo>();
+    FN_TUPLE_CALL_ALLOC_TUPLES(body, fn_in, fn_out);
+    body.call__setup_execution_context(fn_in, fn_out);
+
+    for (uint parameter_index = 0; parameter_index < parameter_amount; parameter_index++) {
+      if (m_parameter_depends_on_particle[parameter_index]) {
+        continue;
+      }
+      uint output_index = m_output_indices[parameter_index];
+      CPPTypeInfo &type_info = m_fn_no_deps->output_type(output_index)->extension<CPPTypeInfo>();
 
       uint output_stride = type_info.size_of_type();
       void *output_buffer = array_allocator.allocate(output_stride);
 
-      result->m_buffers.append(output_buffer);
-      result->m_strides.append(output_stride);
-      result->m_only_first.append(true);
+      result->m_buffers[parameter_index] = output_buffer;
+      result->m_strides[parameter_index] = output_stride;
+      result->m_only_first[parameter_index] = true;
 
-      fn_out.relocate_out__dynamic(i, output_buffer);
+      fn_out.relocate_out__dynamic(output_index, output_buffer);
     }
-
-    return std::unique_ptr<ParticleFunctionResult>(result);
   }
-  else {
+
+  if (m_fn_with_deps->output_amount() > 0) {
+    TupleCallBody &body = m_fn_with_deps->body<TupleCallBody>();
+
     Vector<void *> input_buffers;
     Vector<uint> input_strides;
 
-    for (uint i = 0; i < m_fn->input_amount(); i++) {
-      StringRef input_name = m_fn->input_name(i);
+    for (uint i = 0; i < m_fn_with_deps->input_amount(); i++) {
+      StringRef input_name = m_fn_with_deps->input_name(i);
       void *input_buffer = nullptr;
       uint input_stride = 0;
       if (input_name.startswith("Attribute")) {
@@ -95,25 +104,32 @@ std::unique_ptr<ParticleFunctionResult> ParticleFunction::compute(ArrayAllocator
       input_strides.append(input_stride);
     }
 
-    ParticleFunctionResult *result = new ParticleFunctionResult();
-    result->m_fn = m_fn.ptr();
-    result->m_array_allocator = &array_allocator;
+    Vector<void *> output_buffers;
+    Vector<uint> output_strides;
 
-    for (uint i = 0; i < m_fn->output_amount(); i++) {
-      CPPTypeInfo &type_info = m_fn->output_type(i)->extension<CPPTypeInfo>();
+    for (uint parameter_index = 0; parameter_index < parameter_amount; parameter_index++) {
+      if (!m_parameter_depends_on_particle[parameter_index]) {
+        continue;
+      }
+
+      uint output_index = m_output_indices[parameter_index];
+      CPPTypeInfo &type_info = m_fn_with_deps->output_type(output_index)->extension<CPPTypeInfo>();
 
       uint output_stride = type_info.size_of_type();
       void *output_buffer = array_allocator.allocate(output_stride);
 
-      result->m_buffers.append(output_buffer);
-      result->m_strides.append(output_stride);
-      result->m_only_first.append(false);
+      result->m_buffers[parameter_index] = output_buffer;
+      result->m_strides[parameter_index] = output_stride;
+      result->m_only_first[parameter_index] = false;
+
+      output_buffers.append(output_buffer);
+      output_strides.append(output_stride);
     }
 
     ExecutionStack stack;
     ExecutionContext execution_context(stack);
 
-    FN_TUPLE_CALL_ALLOC_TUPLES(*m_body, fn_in, fn_out);
+    FN_TUPLE_CALL_ALLOC_TUPLES(body, fn_in, fn_out);
 
     for (uint pindex : pindices) {
       for (uint i = 0; i < input_buffers.size(); i++) {
@@ -121,16 +137,16 @@ std::unique_ptr<ParticleFunctionResult> ParticleFunction::compute(ArrayAllocator
         fn_in.copy_in__dynamic(i, ptr);
       }
 
-      m_body->call(fn_in, fn_out, execution_context);
+      body.call(fn_in, fn_out, execution_context);
 
-      for (uint i = 0; i < result->m_buffers.size(); i++) {
-        void *ptr = POINTER_OFFSET(result->m_buffers[i], pindex * result->m_strides[i]);
+      for (uint i = 0; i < output_buffers.size(); i++) {
+        void *ptr = POINTER_OFFSET(output_buffers[i], pindex * output_strides[i]);
         fn_out.relocate_out__dynamic(i, ptr);
       }
     }
-
-    return std::unique_ptr<ParticleFunctionResult>(result);
   }
+
+  return std::unique_ptr<ParticleFunctionResult>(result);
 }
 
 }  // namespace BParticles
diff --git a/source/blender/simulations/bparticles/particle_function.hpp b/source/blender/simulations/bparticles/particle_function.hpp
index 203e1dce93e..4eb2c867cc3 100644
--- a/source/blender/simulations/bparticles/particle_function.hpp
+++ b/source/blender/simulations/bparticles/particle_function.hpp
@@ -24,7 +24,6 @@ class ParticleFunctionResult {
   Vector<uint> m_strides;
   Vector<bool> m_only_first;
   ArrayAllocator *m_array_allocator;
-  FN::Function *m_fn;
 
   friend ParticleFunction;
 
@@ -42,11 +41,11 @@ class ParticleFunctionResult {
 
   template<typename T> T get(StringRef expected_name, uint parameter_index, uint pindex)
   {
-#ifdef DEBUG
-    BLI_assert(sizeof(T) == m_strides[parameter_index]);
-    StringRefNull real_name = m_fn->output_name(parameter_index);
-    BLI_assert(real_name == expected_name);
-#endif
+    // #ifdef DEBUG
+    //     BLI_assert(sizeof(T) == m_strides[parameter_index]);
+    //     StringRefNull real_name = m_fn->output_name(parameter_index);
+    //     BLI_assert(real_name == expected_name);
+    // #endif
     UNUSED_VARS_NDEBUG(expected_name);
 
     T *buffer = (T *)m_buffers[parameter_index];
@@ -61,23 +60,57 @@ class ParticleFunctionResult {
 
 class ParticleFunction {
  private:
-  SharedFunction m_fn;
-  TupleCallBody *m_body;
+  SharedFunction m_fn_no_deps;
+  SharedFunction m_fn_with_deps;
+  Vector<bool> m_parameter_depends_on_particle;
+  Vector<uint> m_output_indices;
 
  public:
-  ParticleFunction(SharedFunction fn) : m_fn(std::move(fn)), m_body(&m_fn->body<TupleCallBody>())
+  ParticleFunction(SharedFunction fn_no_deps,
+                   SharedFunction fn_with_deps,
+                   Vector<bool> parameter_depends_on_particle)
+      : m_fn_no_deps(std::move(fn_no_deps)),
+        m_fn_with_deps(std::move(fn_with_deps)),
+        m_parameter_depends_on_particle(std::move(parameter_depends_on_particle))
   {
-    BLI_assert(m_body != nullptr);
+    BLI_assert(m_fn_no_deps->output_amount() + m_fn_with_deps->output_amount() ==
+               m_parameter_depends_on_particle.size());
+
+    uint no_deps_index = 0;
+    uint with_deps_index = 0;
+    for (uint i = 0; i < m_parameter_depends_on_particle.size(); i++) {
+      if (m_parameter_depends_on_particle[i]) {
+        m_output_indices.append(with_deps_index);
+        with_deps_index++;
+      }
+      else {
+        m_output_indices.append(no_deps_index);
+        no_deps_index++;
+      }
+    }
   }
 
-  bool depends_on_particle()
+  SharedFunction &function_no_deps()
   {
-    return m_fn->input_amount() > 0;
+    return m_fn_no_deps;
   }
 
-  SharedFunction &function()
+  bool parameter_depends_on_particle(StringRef expected_name, uint parameter_index)
   {
-    return m_fn;
+    bool depends_on_particle = m_parameter_depends_on_particle[parameter_index];
+#ifdef DEBUG
+    uint output_index = m_output_indices[parameter_index];
+    if (depends_on_particle) {
+      StringRefNull real_name = m_fn_with_deps->output_name(outp

@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list