[Bf-blender-cvs] [2c06ccec82e] functions-experimental-refactor: initial params builder

Jacques Lucke noreply at git.blender.org
Tue Oct 15 15:57:35 CEST 2019


Commit: 2c06ccec82e76d7df3b295b89ea0e691941d6652
Author: Jacques Lucke
Date:   Tue Oct 15 12:05:43 2019 +0200
Branches: functions-experimental-refactor
https://developer.blender.org/rB2c06ccec82e76d7df3b295b89ea0e691941d6652

initial params builder

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

M	source/blender/blenkernel/BKE_multi_function.h
M	source/blender/modifiers/intern/MOD_functiondeform_cxx.cc

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

diff --git a/source/blender/blenkernel/BKE_multi_function.h b/source/blender/blenkernel/BKE_multi_function.h
index 71b65fa96cd..8a5f971184d 100644
--- a/source/blender/blenkernel/BKE_multi_function.h
+++ b/source/blender/blenkernel/BKE_multi_function.h
@@ -189,6 +189,8 @@ class MultiFunction {
 
   class Params {
    public:
+    Params() = default;
+
     Params(ArrayRef<GenericArrayOrSingleRef> array_or_single_refs,
            ArrayRef<GenericMutableArrayRef> mutable_array_refs,
            ArrayRef<GenericVectorArrayOrSingleRef> vector_array_or_single_refs,
@@ -198,33 +200,33 @@ class MultiFunction {
           m_mutable_array_refs(mutable_array_refs),
           m_vector_array_or_single_refs(vector_array_or_single_refs),
           m_vector_arrays(vector_arrays),
-          m_signature(signature)
+          m_signature(&signature)
     {
     }
 
     template<typename T> ArrayOrSingleRef<T> readonly_single_input(uint index, StringRef name)
     {
-      BLI_assert(m_signature.is_readonly_single_input<T>(index, name));
+      BLI_assert(m_signature->is_readonly_single_input<T>(index, name));
       return this->readonly_single_input(index, name).as_typed_ref<T>();
     }
     GenericArrayOrSingleRef readonly_single_input(uint index, StringRef name)
     {
       UNUSED_VARS_NDEBUG(name);
-      BLI_assert(m_signature.is_readonly_single_input(index, name));
-      uint corrected_index = m_signature.get_corrected_index(index);
+      BLI_assert(m_signature->is_readonly_single_input(index, name));
+      uint corrected_index = m_signature->get_corrected_index(index);
       return m_array_or_single_refs[corrected_index];
     }
 
     template<typename T> MutableArrayRef<T> single_output(uint index, StringRef name)
     {
-      BLI_assert(m_signature.is_single_output<T>(index, name));
+      BLI_assert(m_signature->is_single_output<T>(index, name));
       return this->single_output(index, name).get_ref<T>();
     }
     GenericMutableArrayRef single_output(uint index, StringRef name)
     {
       UNUSED_VARS_NDEBUG(name);
-      BLI_assert(m_signature.is_single_output(index, name));
-      uint corrected_index = m_signature.get_corrected_index(index);
+      BLI_assert(m_signature->is_single_output(index, name));
+      uint corrected_index = m_signature->get_corrected_index(index);
       return m_mutable_array_refs[corrected_index];
     }
 
@@ -232,36 +234,36 @@ class MultiFunction {
     const GenericVectorArrayOrSingleRef::TypedRef<T> readonly_vector_input(uint index,
                                                                            StringRef name)
     {
-      BLI_assert(m_signature.is_readonly_vector_input<T>(index, name));
+      BLI_assert(m_signature->is_readonly_vector_input<T>(index, name));
       return this->readonly_vector_input(index, name).as_typed_ref<T>();
     }
     GenericVectorArrayOrSingleRef readonly_vector_input(uint index, StringRef name)
     {
       UNUSED_VARS_NDEBUG(name);
-      BLI_assert(m_signature.is_readonly_vector_input(index, name));
-      uint corrected_index = m_signature.get_corrected_index(index);
+      BLI_assert(m_signature->is_readonly_vector_input(index, name));
+      uint corrected_index = m_signature->get_corrected_index(index);
       return m_vector_array_or_single_refs[corrected_index];
     }
 
     template<typename T>
     GenericVectorArray::MutableTypedRef<T> vector_output(uint index, StringRef name)
     {
-      BLI_assert(m_signature.is_vector_output<T>(index, name));
+      BLI_assert(m_signature->is_vector_output<T>(index, name));
       return this->vector_output(index, name).as_mutable_typed_ref<T>();
     }
     GenericVectorArray &vector_output(uint index, StringRef name)
     {
       UNUSED_VARS_NDEBUG(name);
-      BLI_assert(m_signature.is_vector_output(index, name));
-      uint corrected_index = m_signature.get_corrected_index(index);
+      BLI_assert(m_signature->is_vector_output(index, name));
+      uint corrected_index = m_signature->get_corrected_index(index);
       return *m_vector_arrays[corrected_index];
     }
 
     GenericVectorArray &mutable_vector(uint index, StringRef name)
     {
       UNUSED_VARS_NDEBUG(name);
-      BLI_assert(m_signature.is_mutable_vector(index, name));
-      uint corrected_index = m_signature.get_corrected_index(index);
+      BLI_assert(m_signature->is_mutable_vector(index, name));
+      uint corrected_index = m_signature->get_corrected_index(index);
       return *m_vector_arrays[corrected_index];
     }
 
@@ -270,7 +272,52 @@ class MultiFunction {
     ArrayRef<GenericMutableArrayRef> m_mutable_array_refs;
     ArrayRef<GenericVectorArrayOrSingleRef> m_vector_array_or_single_refs;
     ArrayRef<GenericVectorArray *> m_vector_arrays;
-    const Signature &m_signature;
+    const Signature *m_signature = nullptr;
+  };
+
+  class ParamsBuilder {
+   private:
+    Vector<GenericArrayOrSingleRef> m_array_or_single_refs;
+    Vector<GenericMutableArrayRef> m_mutable_array_refs;
+    Vector<GenericVectorArrayOrSingleRef> m_vector_array_or_single_refs;
+    Vector<GenericVectorArray *> m_vector_arrays;
+    const Signature *m_signature = nullptr;
+
+    Params m_params;
+
+   public:
+    ParamsBuilder() = default;
+
+    void start_new(const Signature &signature)
+    {
+      m_signature = &signature;
+
+      m_array_or_single_refs.clear();
+      m_mutable_array_refs.clear();
+      m_vector_array_or_single_refs.clear();
+      m_vector_arrays.clear();
+    }
+
+    template<typename T> void add_readonly_array_ref(ArrayRef<T> array)
+    {
+      m_array_or_single_refs.append(GenericArrayOrSingleRef::FromArray<T>(array));
+    }
+
+    template<typename T> void add_mutable_array_ref(ArrayRef<T> array)
+    {
+      m_mutable_array_refs.append(GenericMutableArrayRef(array));
+    }
+
+    Params &build()
+    {
+      BLI_assert(m_signature != nullptr);
+      m_params = Params(m_array_or_single_refs,
+                        m_mutable_array_refs,
+                        m_vector_array_or_single_refs,
+                        m_vector_arrays,
+                        *m_signature);
+      return m_params;
+    }
   };
 
   virtual void call(ArrayRef<uint> mask_indices, Params &params) const = 0;
diff --git a/source/blender/modifiers/intern/MOD_functiondeform_cxx.cc b/source/blender/modifiers/intern/MOD_functiondeform_cxx.cc
index ab8a5258f8f..db8c50e3e01 100644
--- a/source/blender/modifiers/intern/MOD_functiondeform_cxx.cc
+++ b/source/blender/modifiers/intern/MOD_functiondeform_cxx.cc
@@ -36,17 +36,13 @@ void MOD_functiondeform_do(FunctionDeformModifierData *fdmd, float (*vertexCos)[
   std::array<float, 4> values_b = {2, 6, 34, 1};
   std::array<float, 4> result;
 
-  Vector<BKE::GenericArrayOrSingleRef> array_or_single_refs;
-  array_or_single_refs.append(BKE::GenericArrayOrSingleRef::FromArray(ArrayRef<float>(values_a)));
-  array_or_single_refs.append(BKE::GenericArrayOrSingleRef::FromArray(ArrayRef<float>(values_b)));
+  BKE::MultiFunction::ParamsBuilder params;
+  params.start_new(function.signature());
+  params.add_readonly_array_ref<float>(values_a);
+  params.add_readonly_array_ref<float>(values_b);
+  params.add_mutable_array_ref<float>(result);
 
-  Vector<BKE::GenericMutableArrayRef> mutable_array_refs;
-  mutable_array_refs.append(BKE::GenericMutableArrayRef(ArrayRef<float>(result)));
-
-  BKE::MultiFunction::Params params{
-      array_or_single_refs, mutable_array_refs, {}, {}, function.signature()};
-
-  function.call({0, 1, 2, 3}, params);
+  function.call({0, 1, 2, 3}, params.build());
 
   std::cout << result[0] << ", " << result[1] << ", " << result[2] << ", " << result[3] << "\n";
 }



More information about the Bf-blender-cvs mailing list