[Bf-blender-cvs] [2ef5959f8ae] functions-experimental-refactor: GenericVectorArrayOrSingleRef

[Jacques Lucke]

Commit: 2ef5959f8ae6ad97ce6df38c6da0aa89bdefee19
Author: Jacques Lucke
Date:   Thu Oct 10 21:21:05 2019 +0200
Branches: functions-experimental-refactor
https://developer.blender.org/rB2ef5959f8ae6ad97ce6df38c6da0aa89bdefee19

GenericVectorArrayOrSingleRef

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

M	source/blender/blenkernel/BKE_generic_array_ref.h
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_array_ref.h b/source/blender/blenkernel/BKE_generic_array_ref.h
index 64cc7b3bd66..759b909adce 100644
--- a/source/blender/blenkernel/BKE_generic_array_ref.h
+++ b/source/blender/blenkernel/BKE_generic_array_ref.h
@@ -20,16 +20,16 @@ class GenericArrayRef {
   uint m_size;
 
  public:
-  GenericArrayRef(const CPPType *type) : GenericArrayRef(type, nullptr, 0)
+  GenericArrayRef(const CPPType &type) : GenericArrayRef(type, nullptr, 0)
   {
   }
 
-  GenericArrayRef(const CPPType *type, const void *buffer, uint size)
-      : m_type(type), m_buffer(buffer), m_size(size)
+  GenericArrayRef(const CPPType &type, const void *buffer, uint size)
+      : m_type(&type), m_buffer(buffer), m_size(size)
   {
-    BLI_assert(type != nullptr);
+    BLI_assert(&type != nullptr);
     BLI_assert(buffer != nullptr || size == 0);
-    BLI_assert(type->pointer_has_valid_alignment(buffer));
+    BLI_assert(type.pointer_has_valid_alignment(buffer));
   }
 
   uint size() const
@@ -50,7 +50,7 @@ class GenericArrayRef {
 
   template<typename T> ArrayRef<T> get_ref() const
   {
-    BLI_assert(GET_TYPE<T>().is_same_or_generalization(m_type));
+    BLI_assert(GET_TYPE<T>().is_same_or_generalization(*m_type));
     return ArrayRef<T>((const T *)m_buffer, m_size);
   }
 };
@@ -130,9 +130,15 @@ class GenericMutableArrayRef {
     return m_size;
   }
 
+  void *operator[](uint index)
+  {
+    BLI_assert(index < m_size);
+    return POINTER_OFFSET(m_buffer, m_type->size() * index);
+  }
+
   template<typename T> MutableArrayRef<T> get_ref()
   {
-    BLI_assert(GET_TYPE<T>().is_same_or_generalization(m_type));
+    BLI_assert(GET_TYPE<T>().is_same_or_generalization(*m_type));
     return MutableArrayRef<T>((T *)m_buffer, m_size);
   }
 };
@@ -147,7 +153,7 @@ class ArrayRefCPPType final : public CPPType {
   static void ConstructDefaultCB(const CPPType *self, void *ptr)
   {
     const ArrayRefCPPType *self_ = dynamic_cast<const ArrayRefCPPType *>(self);
-    new (ptr) GenericArrayRef(&self_->m_base_type);
+    new (ptr) GenericArrayRef(self_->m_base_type);
   }
 };
 
diff --git a/source/blender/blenkernel/BKE_generic_vector_array.h b/source/blender/blenkernel/BKE_generic_vector_array.h
index 959b9acc154..297936dc5d4 100644
--- a/source/blender/blenkernel/BKE_generic_vector_array.h
+++ b/source/blender/blenkernel/BKE_generic_vector_array.h
@@ -171,6 +171,18 @@ class GenericVectorArray : BLI::NonCopyable, BLI::NonMovable {
   }
 };
 
+class GenericVectorArrayOrSingleRef {
+ private:
+  CPPType *m_type;
+
+ public:
+  GenericArrayRef operator[](uint index)
+  {
+    /* TODO */
+    return GenericArrayRef(*m_type);
+  }
+};
+
 };  // namespace BKE
 
 #endif /* __BKE_GENERIC_MULTI_VECTOR_H__ */
\ No newline at end of file
diff --git a/source/blender/blenkernel/intern/node_functions.cc b/source/blender/blenkernel/intern/node_functions.cc
index 265a96386a8..413ea6656b9 100644
--- a/source/blender/blenkernel/intern/node_functions.cc
+++ b/source/blender/blenkernel/intern/node_functions.cc
@@ -41,10 +41,11 @@ class MultiFunction {
     GenericArrayOrSingleRef readonly_single_input(uint index, StringRef name);
 
     template<typename T> MutableArrayRef<T> single_output(uint index, StringRef name);
+    GenericMutableArrayRef single_output(uint index, StringRef name);
 
     template<typename T>
     const GenericVectorArray::TypedRef<T> readonly_vector_input(uint index, StringRef name);
-    const GenericVectorArray &readonly_vector_input(uint index, StringRef name);
+    GenericVectorArrayOrSingleRef readonly_vector_input(uint index, StringRef name);
 
     template<typename T>
     GenericVectorArray::MutableTypedRef<T> vector_output(uint index, StringRef name);
@@ -180,8 +181,23 @@ class MultiFunction_GetListElement : public MultiFunction {
 
   void call(ArrayRef<uint> mask_indices, Params &params) const override
   {
-    GenericVectorArray &lists = params.mutable_vector(0, "List");
-    ArrayOrSingleRef<int> input_indices = params.readonly_single_input<int>(1, "Index");
+    GenericVectorArrayOrSingleRef lists = params.readonly_vector_input(0, "List");
+    ArrayOrSingleRef<int> indices = params.readonly_single_input<int>(1, "Index");
+    GenericArrayOrSingleRef fallbacks = params.readonly_single_input(2, "Fallback");
+
+    GenericMutableArrayRef output_values = params.single_output(3, "Value");
+
+    for (uint i : mask_indices) {
+      int index = indices[i];
+      if (index >= 0) {
+        GenericArrayRef list = lists[i];
+        if (index < list.size()) {
+          m_base_type.copy_to_uninitialized(list[index], output_values[i]);
+          continue;
+        }
+      }
+      m_base_type.copy_to_uninitialized(fallbacks[i], output_values[i]);
+    }
   }
 };