[Bf-blender-cvs] [269488d1c3b] functions-experimental-refactor: use virtual list list ref in multi functions
Jacques Lucke
noreply at git.blender.org
Tue Oct 29 16:54:48 CET 2019
Commit: 269488d1c3bc84130cbf6ac4ca4b02ab8e2481a3
Author: Jacques Lucke
Date: Tue Oct 29 15:46:25 2019 +0100
Branches: functions-experimental-refactor
https://developer.blender.org/rB269488d1c3bc84130cbf6ac4ca4b02ab8e2481a3
use virtual list list ref in multi functions
===================================================================
M source/blender/blenkernel/BKE_generic_vector_array.h
A source/blender/blenkernel/BKE_generic_virtual_list_list_ref.h
M source/blender/blenkernel/BKE_generic_virtual_list_ref.h
M source/blender/blenkernel/BKE_multi_function.h
M source/blender/blenkernel/intern/multi_functions.cc
===================================================================
diff --git a/source/blender/blenkernel/BKE_generic_vector_array.h b/source/blender/blenkernel/BKE_generic_vector_array.h
index 1b4b4c9e853..9f7b3ee4aac 100644
--- a/source/blender/blenkernel/BKE_generic_vector_array.h
+++ b/source/blender/blenkernel/BKE_generic_vector_array.h
@@ -4,6 +4,7 @@
#include "BKE_cpp_type.h"
#include "BKE_cpp_types.h"
#include "BKE_generic_array_ref.h"
+#include "BKE_generic_virtual_list_list_ref.h"
#include "BLI_array_ref.h"
#include "BLI_index_range.h"
@@ -61,7 +62,7 @@ class GenericVectorArray : BLI::NonCopyable, BLI::NonMovable {
slice.length++;
}
- void extend_single__copy(uint index, GenericArrayRef values)
+ void extend_single__copy(uint index, const GenericVirtualListRef &values)
{
for (uint i = 0; i < values.size(); i++) {
this->append_single__copy(index, values[i]);
@@ -164,38 +165,6 @@ class GenericVectorArray : BLI::NonCopyable, BLI::NonMovable {
}
};
-class GenericVectorArrayOrSingleRef {
- private:
- CPPType *m_type;
-
- public:
- GenericArrayRef operator[](uint UNUSED(index)) const
- {
- /* TODO */
- return GenericArrayRef(*m_type);
- }
-
- template<typename T> class TypedRef {
- private:
- const GenericVectorArrayOrSingleRef *m_data;
-
- public:
- TypedRef(const GenericVectorArrayOrSingleRef &data) : m_data(&data)
- {
- }
-
- ArrayRef<T> operator[](uint index)
- {
- return (*m_data)[index].get_ref<T>();
- }
- };
-
- template<typename T> TypedRef<T> as_typed_ref() const
- {
- return TypedRef<T>(*this);
- }
-};
-
}; // namespace BKE
#endif /* __BKE_GENERIC_MULTI_VECTOR_H__ */
diff --git a/source/blender/blenkernel/BKE_generic_virtual_list_list_ref.h b/source/blender/blenkernel/BKE_generic_virtual_list_list_ref.h
new file mode 100644
index 00000000000..abe5483afc2
--- /dev/null
+++ b/source/blender/blenkernel/BKE_generic_virtual_list_list_ref.h
@@ -0,0 +1,113 @@
+#ifndef __BKE_GENERIC_VIRTUAL_LIST_LIST_REF_H__
+#define __BKE_GENERIC_VIRTUAL_LIST_LIST_REF_H__
+
+#include "BLI_virtual_list_list_ref.h"
+
+#include "BKE_generic_virtual_list_ref.h"
+
+namespace BKE {
+
+using BLI::VirtualListListRef;
+
+class GenericVirtualListListRef {
+ private:
+ enum Category {
+ SingleArray,
+ FullArrayList,
+ };
+
+ const CPPType *m_type;
+ uint m_virtual_list_size;
+ Category m_category;
+
+ union {
+ struct {
+ const void *data;
+ uint real_array_size;
+ } single_array;
+ struct {
+ const void *const *starts;
+ const uint *real_array_sizes;
+ } full_array_list;
+ } m_data;
+
+ GenericVirtualListListRef() = default;
+
+ public:
+ static GenericVirtualListListRef FromSingleArray(const CPPType &type,
+ const void *buffer,
+ uint real_array_size,
+ uint virtual_list_size)
+ {
+ GenericVirtualListListRef list;
+ list.m_type = &type;
+ list.m_virtual_list_size = virtual_list_size;
+ list.m_category = Category::SingleArray;
+ list.m_data.single_array.data = buffer;
+ list.m_data.single_array.real_array_size = real_array_size;
+ return list;
+ }
+
+ static GenericVirtualListListRef FromFullArrayList(const CPPType &type,
+ const void *const *starts,
+ const uint *real_array_sizes,
+ uint list_size)
+ {
+ GenericVirtualListListRef list;
+ list.m_type = &type;
+ list.m_virtual_list_size = list_size;
+ list.m_category = Category::FullArrayList;
+ list.m_data.full_array_list.starts = starts;
+ list.m_data.full_array_list.real_array_sizes = real_array_sizes;
+ return list;
+ }
+
+ static GenericVirtualListListRef FromFullArrayList(const CPPType &type,
+ ArrayRef<const void *> starts,
+ ArrayRef<uint> array_sizes)
+ {
+ BLI_assert(starts.size() == array_sizes.size());
+ return GenericVirtualListListRef::FromFullArrayList(
+ type, starts.begin(), array_sizes.begin(), starts.size());
+ }
+
+ GenericVirtualListRef operator[](uint index) const
+ {
+ BLI_assert(index < m_virtual_list_size);
+
+ switch (m_category) {
+ case Category::SingleArray:
+ return GenericVirtualListRef::FromFullArray(
+ *m_type, m_data.single_array.data, m_data.single_array.real_array_size);
+ case Category::FullArrayList:
+ return GenericVirtualListRef::FromFullArray(
+ *m_type,
+ m_data.full_array_list.starts[index],
+ m_data.full_array_list.real_array_sizes[index]);
+ }
+
+ BLI_assert(false);
+ return GenericVirtualListRef{*m_type};
+ }
+
+ template<typename T> VirtualListListRef<T> as_typed_ref() const
+ {
+ BLI_assert(GET_TYPE<T>().is_same_or_generalization(*m_type));
+ switch (m_category) {
+ case Category::SingleArray:
+ return VirtualListListRef<T>::FromSingleArray(
+ ArrayRef<T>((const T *)m_data.single_array.data, m_data.single_array.real_array_size),
+ m_virtual_list_size);
+ case Category::FullArrayList:
+ return VirtualListListRef<T>::FromListOfStartPointers(
+ ArrayRef<const T *>((const T **)m_data.full_array_list.starts, m_virtual_list_size),
+ ArrayRef<uint>(m_data.full_array_list.real_array_sizes, m_virtual_list_size));
+ }
+ BLI_assert(false);
+ return {};
+ }
+};
+
+} // namespace BKE
+
+#endif /* __BKE_GENERIC_VIRTUAL_LIST_LIST_REF_H__ */
diff --git a/source/blender/blenkernel/BKE_generic_virtual_list_ref.h b/source/blender/blenkernel/BKE_generic_virtual_list_ref.h
index 23f2bf69570..0acd74e0462 100644
--- a/source/blender/blenkernel/BKE_generic_virtual_list_ref.h
+++ b/source/blender/blenkernel/BKE_generic_virtual_list_ref.h
@@ -1,5 +1,5 @@
-#ifndef __BKE_GENERIC_VIRTUAL_LIST_REF_REF_H__
-#define __BKE_GENERIC_VIRTUAL_LIST_REF_REF_H__
+#ifndef __BKE_GENERIC_VIRTUAL_LIST_REF_H__
+#define __BKE_GENERIC_VIRTUAL_LIST_REF_H__
#include "BKE_cpp_types.h"
@@ -38,6 +38,14 @@ class GenericVirtualListRef {
GenericVirtualListRef() = default;
public:
+ GenericVirtualListRef(const CPPType &type)
+ {
+ m_virtual_size = 0;
+ m_type = &type;
+ m_category = Category::FullArray;
+ m_data.full_array.data = nullptr;
+ }
+
static GenericVirtualListRef FromSingle(const CPPType &type,
const void *buffer,
uint virtual_size)
@@ -121,4 +129,4 @@ class GenericVirtualListRef {
} // namespace BKE
-#endif /* __BKE_GENERIC_VIRTUAL_LIST_REF_REF_H__ */
+#endif /* __BKE_GENERIC_VIRTUAL_LIST_REF_H__ */
diff --git a/source/blender/blenkernel/BKE_multi_function.h b/source/blender/blenkernel/BKE_multi_function.h
index 4b343fc12f9..3ea30071107 100644
--- a/source/blender/blenkernel/BKE_multi_function.h
+++ b/source/blender/blenkernel/BKE_multi_function.h
@@ -4,6 +4,7 @@
#include "BKE_generic_array_ref.h"
#include "BKE_generic_vector_array.h"
#include "BKE_generic_virtual_list_ref.h"
+#include "BKE_generic_virtual_list_list_ref.h"
#include "BKE_tuple.h"
#include "BLI_vector.h"
@@ -36,6 +37,16 @@ struct MFDataType {
return m_category == Category::None;
}
+ bool is_single() const
+ {
+ return m_category == Category::Single;
+ }
+
+ bool is_vector() const
+ {
+ return m_category == Category::Vector;
+ }
+
Category category() const
{
return m_category;
@@ -178,7 +189,7 @@ class MFSignature {
{
uint array_or_single_refs = 0;
uint mutable_array_refs = 0;
- uint vector_array_or_single_refs = 0;
+ uint virtual_list_list_refs = 0;
uint vector_arrays = 0;
for (MFParamType param_type : m_param_types) {
uint corrected_index = 0;
@@ -193,7 +204,7 @@ class MFSignature {
corrected_index = mutable_array_refs++;
break;
case MFParamType::ReadonlyVectorInput:
- corrected_index = vector_array_or_single_refs++;
+ corrected_index = virtual_list_list_refs++;
break;
case MFParamType::VectorOutput:
case MFParamType::MutableVector:
@@ -362,12 +373,12 @@ class MFParams {
MFParams(ArrayRef<GenericVirtualListRef> virtual_list_refs,
ArrayRef<GenericMutableArrayRef> mutable_array_refs,
- ArrayRef<GenericVectorArrayOrSingleRef> vector_array_or_single_refs,
+ ArrayRef<GenericVirtualListListRef> virtual_list_list_refs,
ArrayRef<GenericVectorArray *> vector_arrays,
const MFSignature &signature)
: m_virtual_list_refs(virtual_list_refs),
m_mutable_array_refs(mutable_array_refs),
- m_vector_array_or_single_refs(vector_array_or_single_refs),
+ m_virtual_list_list_refs(virtual_list_list_refs),
m_vector_arrays(vector_arrays),
m_signature(&signature)
{
@@ -400,18 +411,17 @@ class MFParams {
}
template<typename T>
- const GenericVectorArrayOrSingleRef::TypedRef<T> readonly_vector_input(uint index,
- StringRef name)
+ const VirtualListListRef<T> readonly_vector_input(uint index, StringRef 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)
+ GenericVirtualListListRef 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);
- return m_vector_array_or_single_refs[corrected_index];
+ return m_virtual_list_list_refs[corrected_index];
}
template<typename T>
@@ -439,7 +449,7 @@ class MFParams {
private:
ArrayRef<GenericVirtualListRef> m_virtual_list_refs;
ArrayRef<GenericMutableArrayRef> m_mutable_array_refs;
- ArrayRef<GenericV
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list