[Bf-blender-cvs] [ad114f806b0] temp-varray-get-set-multiple: progress

[Jacques Lucke]

Commit: ad114f806b06b07d6738baa1004ebdcdbf98bc5e
Author: Jacques Lucke
Date:   Sat Sep 25 15:01:09 2021 +0200
Branches: temp-varray-get-set-multiple
https://developer.blender.org/rBad114f806b06b07d6738baa1004ebdcdbf98bc5e

progress

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

M	source/blender/blenlib/BLI_virtual_array.hh
M	source/blender/functions/FN_generic_virtual_array.hh
M	source/blender/functions/intern/generic_virtual_array.cc

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

diff --git a/source/blender/blenlib/BLI_virtual_array.hh b/source/blender/blenlib/BLI_virtual_array.hh
index 37be239e5bc..3beb75ff1c1 100644
--- a/source/blender/blenlib/BLI_virtual_array.hh
+++ b/source/blender/blenlib/BLI_virtual_array.hh
@@ -74,7 +74,7 @@ template<typename T> class VArray {
   {
     BLI_assert(mask.min_array_size() <= size_);
     BLI_assert(mask.min_array_size() <= dst_varray.size());
-    if (dst_varray.can_set_multiple_efficiently(*this)) {
+    if (dst_varray._can_set_multiple_efficiently(*this)) {
       dst_varray._set_multiple(*this, mask);
     }
     else {
@@ -87,7 +87,7 @@ template<typename T> class VArray {
     this->get_multiple_impl(dst_varray, mask);
   }
 
-  bool can_get_multiple_efficiently(const VMutableArray<T> &dst_varray) const
+  bool _can_get_multiple_efficiently(const VMutableArray<T> &dst_varray) const
   {
     return this->can_get_multiple_efficiently_impl(dst_varray);
   }
@@ -272,7 +272,7 @@ template<typename T> class VMutableArray : public VArray<T> {
   {
     BLI_assert(mask.min_array_size() <= this->size_);
     BLI_assert(mask.min_array_size() <= src_varray.size());
-    if (src_varray.can_get_multiple_efficiently_impl(*this)) {
+    if (src_varray._can_get_multiple_efficiently(*this)) {
       src_varray._get_multiple(*this, mask);
     }
     else {
@@ -285,7 +285,7 @@ template<typename T> class VMutableArray : public VArray<T> {
     this->set_multiple_impl(src_varray, mask);
   }
 
-  bool can_set_multiple_efficiently(const VArray<T> &src_varray) const
+  bool _can_set_multiple_efficiently(const VArray<T> &src_varray) const
   {
     return this->can_get_multiple_efficiently_impl(src_varray);
   }
diff --git a/source/blender/functions/FN_generic_virtual_array.hh b/source/blender/functions/FN_generic_virtual_array.hh
index 703118ba23e..ba6439ebed0 100644
--- a/source/blender/functions/FN_generic_virtual_array.hh
+++ b/source/blender/functions/FN_generic_virtual_array.hh
@@ -86,6 +86,11 @@ class GVArray {
     this->get_to_uninitialized_impl(index, r_value);
   }
 
+  void get_multiple(GVMutableArray &dst_varray) const;
+  void get_multiple(GVMutableArray &dst_varray, const IndexMask mask) const;
+  void _get_multiple(GVMutableArray &dst_varray, const IndexMask mask) const;
+  bool _can_get_multiple_efficiently(const GVMutableArray &dst_varray) const;
+
   /* Returns true when the virtual array is stored as a span internally. */
   bool is_span() const
   {
@@ -159,6 +164,9 @@ class GVArray {
   virtual void get_impl(const int64_t index, void *r_value) const;
   virtual void get_to_uninitialized_impl(const int64_t index, void *r_value) const = 0;
 
+  virtual void get_multiple_impl(GVMutableArray &dst_varray, IndexMask mask) const;
+  virtual bool can_get_multiple_efficiently_impl(const GVMutableArray &dst_varray) const;
+
   virtual bool is_span_impl() const;
   virtual GSpan get_internal_span_impl() const;
 
@@ -199,6 +207,11 @@ class GVMutableArray : public GVArray {
     this->set_by_relocate_impl(index, value);
   }
 
+  void set_multiple_by_copy(const GVArray &src_varray);
+  void set_multiple_by_copy(const GVArray &src_varray, const IndexMask mask);
+  void _set_multiple_by_copy(const GVArray &src_varray, const IndexMask mask);
+  bool _can_set_multiple_efficiently(const GVArray &src_varray) const;
+
   GMutableSpan get_internal_span()
   {
     BLI_assert(this->is_span());
@@ -231,6 +244,9 @@ class GVMutableArray : public GVArray {
   virtual void set_by_relocate_impl(const int64_t index, void *value);
   virtual void set_by_move_impl(const int64_t index, void *value) = 0;
 
+  virtual void set_multiple_by_copy_impl(const GVArray &src_varray, IndexMask mask);
+  virtual bool can_set_multiple_efficiently_impl(const GVArray &src_varray) const;
+
   virtual void set_all_impl(const void *src);
 
   virtual void *try_get_internal_mutable_varray_impl();
diff --git a/source/blender/functions/intern/generic_virtual_array.cc b/source/blender/functions/intern/generic_virtual_array.cc
index 9a83d8cd497..3b269a64d7c 100644
--- a/source/blender/functions/intern/generic_virtual_array.cc
+++ b/source/blender/functions/intern/generic_virtual_array.cc
@@ -53,6 +53,48 @@ class GVArray_For_ShallowCopy : public GVArray {
  * GVArray.
  */
 
+void GVArray::get_multiple(GVMutableArray &dst_varray) const
+{
+  this->get_multiple(dst_varray, IndexMask(size_));
+}
+
+void GVArray::get_multiple(GVMutableArray &dst_varray, const IndexMask mask) const
+{
+  if (dst_varray._can_set_multiple_efficiently(*this)) {
+    dst_varray._set_multiple_by_copy(*this, mask);
+  }
+  else {
+    this->_get_multiple(dst_varray, mask);
+  }
+}
+
+bool GVArray::_can_get_multiple_efficiently(const GVMutableArray &dst_varray) const
+{
+  return this->can_get_multiple_efficiently_impl(dst_varray);
+}
+
+void GVArray::_get_multiple(GVMutableArray &dst_varray, const IndexMask mask) const
+{
+  BLI_assert(dst_varray.type() == *type_);
+  BLI_assert(mask.min_array_size() <= size_);
+  BLI_assert(mask.min_array_size() <= dst_varray.size());
+  this->get_multiple_impl(dst_varray, mask);
+}
+
+void GVArray::get_multiple_impl(GVMutableArray &dst_varray, const IndexMask mask) const
+{
+  BUFFER_FOR_CPP_TYPE_VALUE(*type_, buffer);
+  for (const int i : mask) {
+    this->get_to_uninitialized(i, buffer);
+    dst_varray.set_by_relocate(i, buffer);
+  }
+}
+
+bool GVArray::can_get_multiple_efficiently_impl(const GVMutableArray &UNUSED(dst_varray)) const
+{
+  return false;
+}
+
 void GVArray::materialize(void *dst) const
 {
   this->materialize(IndexMask(size_), dst);
@@ -160,6 +202,48 @@ void GVMutableArray::set_by_relocate_impl(const int64_t index, void *value)
   type_->destruct(value);
 }
 
+void GVMutableArray::set_multiple_by_copy(const GVArray &src_varray)
+{
+  this->set_multiple_by_copy(src_varray, IndexMask(size_));
+}
+
+void GVMutableArray::set_multiple_by_copy(const GVArray &src_varray, const IndexMask mask)
+{
+  if (src_varray._can_get_multiple_efficiently(*this)) {
+    src_varray._get_multiple(*this, mask);
+  }
+  else {
+    this->_set_multiple_by_copy(src_varray, mask);
+  }
+}
+
+void GVMutableArray::_set_multiple_by_copy(const GVArray &src_varray, const IndexMask mask)
+{
+  BLI_assert(src_varray.type() == *type_);
+  BLI_assert(mask.min_array_size() <= size_);
+  BLI_assert(mask.min_array_size() <= src_varray.size());
+  this->set_multiple_by_copy_impl(src_varray, mask);
+}
+
+bool GVMutableArray::_can_set_multiple_efficiently(const GVArray &src_varray) const
+{
+  return this->can_set_multiple_efficiently_impl(src_varray);
+}
+
+void GVMutableArray::set_multiple_by_copy_impl(const GVArray &src_varray, const IndexMask mask)
+{
+  BUFFER_FOR_CPP_TYPE_VALUE(*type_, buffer);
+  for (const int i : mask) {
+    src_varray.get_to_uninitialized(i, buffer);
+    this->set_by_relocate(i, buffer);
+  }
+}
+
+bool GVMutableArray::can_set_multiple_efficiently_impl(const GVArray &UNUSED(src_varray)) const
+{
+  return false;
+}
+
 void GVMutableArray::set_all_impl(const void *src)
 {
   if (this->is_span()) {