[Bf-blender-cvs] [1ee3c53ed2e] functions-experimental-refactor: prototyping vector array usage

Jacques Lucke noreply at git.blender.org
Tue Oct 15 15:56:46 CEST 2019


Commit: 1ee3c53ed2eb8fe56559e595f79598fe05529013
Author: Jacques Lucke
Date:   Thu Oct 10 11:03:45 2019 +0200
Branches: functions-experimental-refactor
https://developer.blender.org/rB1ee3c53ed2eb8fe56559e595f79598fe05529013

prototyping vector array usage

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

M	source/blender/blenkernel/BKE_generic_vector_array.h
M	source/blender/blenkernel/intern/node_functions.cc

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

diff --git a/source/blender/blenkernel/BKE_generic_vector_array.h b/source/blender/blenkernel/BKE_generic_vector_array.h
index 4f8e43f076e..312983c92c5 100644
--- a/source/blender/blenkernel/BKE_generic_vector_array.h
+++ b/source/blender/blenkernel/BKE_generic_vector_array.h
@@ -35,11 +35,7 @@ class GenericVectorArray : BLI::NonCopyable, BLI::NonMovable {
   GenericVectorArray() = delete;
 
   GenericVectorArray(CPPType &type, uint array_size)
-      : m_slices_allocator({}),
-        m_elements_allocator({}),
-        m_type(type),
-        m_array_size(array_size),
-        m_element_size(type.size())
+      : m_type(type), m_array_size(array_size), m_element_size(type.size())
   {
     uint slices_size_in_bytes = sizeof(BufferSlice) * array_size;
     m_slices = (BufferSlice *)m_slices_allocator.allocate(slices_size_in_bytes, __func__);
diff --git a/source/blender/blenkernel/intern/node_functions.cc b/source/blender/blenkernel/intern/node_functions.cc
index 3a22b52633b..cb52ee5cfd9 100644
--- a/source/blender/blenkernel/intern/node_functions.cc
+++ b/source/blender/blenkernel/intern/node_functions.cc
@@ -1,5 +1,6 @@
 #include "BKE_node_functions.h"
 #include "BKE_generic_array_ref.h"
+#include "BKE_generic_vector_array.h"
 
 #include "BLI_math_cxx.h"
 #include "BLI_lazy_init_cxx.h"
@@ -17,6 +18,8 @@ class MultiFunction {
   Vector<CPPType *> m_single_output_types;
   Vector<std::string> m_single_input_names;
   Vector<std::string> m_single_output_names;
+  Vector<CPPType *> m_vector_input_types;
+  Vector<std::string> m_vector_input_names;
 
  public:
   class Signature {
@@ -30,7 +33,7 @@ class MultiFunction {
     friend MultiFunction;
 
    public:
-    template<typename T> void single_input(StringRef name)
+    template<typename T> void readonly_single_input(StringRef name)
     {
       m_function.m_single_input_names.append(name);
       m_function.m_single_input_types.append(&GET_TYPE<T>());
@@ -41,35 +44,38 @@ class MultiFunction {
       m_function.m_single_output_names.append(name);
       m_function.m_single_output_types.append(&GET_TYPE<T>());
     }
-  };
 
-  class Inputs {
-   public:
-    template<typename T> ArrayOrSingleRef<T> get(uint index, StringRef name);
+    template<typename T> void readonly_vector_input(StringRef name)
+    {
+      m_function.m_vector_input_names.append(name);
+      m_function.m_vector_input_types.append(&GET_TYPE<T>());
+    }
   };
 
-  class Outputs {
+  class Params {
    public:
-    template<typename T> MutableArrayRef<T> get(uint index, StringRef name);
+    template<typename T> ArrayOrSingleRef<T> readonly_single_input(uint index, StringRef name);
+    template<typename T> MutableArrayRef<T> single_output(uint index, StringRef name);
+    const GenericVectorArray &readonly_vector_input(uint index, StringRef name);
   };
 
   virtual void signature(Signature &signature) const = 0;
-  virtual void call(ArrayRef<uint> indices, Inputs &inputs, Outputs &outputs) const = 0;
+  virtual void call(ArrayRef<uint> indices, Params &params) const = 0;
 };
 
 class MultiFunction_AddFloats : public MultiFunction {
   void signature(Signature &signature) const override
   {
-    signature.single_input<float>("A");
-    signature.single_input<float>("B");
+    signature.readonly_single_input<float>("A");
+    signature.readonly_single_input<float>("B");
     signature.single_output<float>("Result");
   }
 
-  void call(ArrayRef<uint> indices, Inputs &inputs, Outputs &outputs) const override
+  void call(ArrayRef<uint> indices, Params &params) const override
   {
-    auto a = inputs.get<float>(0, "A");
-    auto b = inputs.get<float>(1, "B");
-    auto result = outputs.get<float>(0, "Result");
+    auto a = params.readonly_single_input<float>(0, "A");
+    auto b = params.readonly_single_input<float>(1, "B");
+    auto result = params.single_output<float>(0, "Result");
 
     for (uint i : indices) {
       result[i] = a[i] + b[i];
@@ -80,16 +86,16 @@ class MultiFunction_AddFloats : public MultiFunction {
 class MultiFunction_VectorDistance : public MultiFunction {
   void signature(Signature &signature) const override
   {
-    signature.single_input<float3>("A");
-    signature.single_input<float3>("A");
+    signature.readonly_single_input<float3>("A");
+    signature.readonly_single_input<float3>("A");
     signature.single_output<float>("Distances");
   }
 
-  void call(ArrayRef<uint> indices, Inputs &inputs, Outputs &outputs) const override
+  void call(ArrayRef<uint> indices, Params &params) const override
   {
-    auto a = inputs.get<float3>(0, "A");
-    auto b = inputs.get<float3>(1, "B");
-    auto distances = outputs.get<float>(0, "Distances");
+    auto a = params.readonly_single_input<float3>(0, "A");
+    auto b = params.readonly_single_input<float3>(1, "B");
+    auto distances = params.single_output<float>(0, "Distances");
 
     for (uint i : indices) {
       distances[i] = float3::distance(a[i], b[i]);
@@ -97,4 +103,27 @@ class MultiFunction_VectorDistance : public MultiFunction {
   }
 };
 
+class MultiFunction_FloatArraySum : public MultiFunction {
+  void signature(Signature &signature) const override
+  {
+    signature.readonly_vector_input<float>("Array");
+    signature.single_output<float>("Sum");
+  }
+
+  void call(ArrayRef<uint> indices, Params &params) const override
+  {
+    const GenericVectorArray &arrays = params.readonly_vector_input(0, "Array");
+    MutableArrayRef<float> sums = params.single_output<float>(0, "Sum");
+
+    for (uint i : indices) {
+      ArrayRef<float> array = arrays.as_ref<float>(i);
+      float sum = 0.0f;
+      for (float value : array) {
+        sum += value;
+      }
+      sums[i] = sum;
+    }
+  }
+};
+
 }  // namespace BKE
\ No newline at end of file



More information about the Bf-blender-cvs mailing list