[Bf-blender-cvs] [b4130c3d2ac] functions-experimental-refactor: more generic vector array functionality
Jacques Lucke
noreply at git.blender.org
Tue Oct 15 15:56:48 CEST 2019
Commit: b4130c3d2acef443d401c4abb33772c04b1fccd7
Author: Jacques Lucke
Date: Thu Oct 10 20:38:25 2019 +0200
Branches: functions-experimental-refactor
https://developer.blender.org/rBb4130c3d2acef443d401c4abb33772c04b1fccd7
more generic vector array functionality
===================================================================
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 312983c92c5..959b9acc154 100644
--- a/source/blender/blenkernel/BKE_generic_vector_array.h
+++ b/source/blender/blenkernel/BKE_generic_vector_array.h
@@ -48,14 +48,7 @@ class GenericVectorArray : BLI::NonCopyable, BLI::NonMovable {
m_slices_allocator.deallocate((void *)m_slices);
}
- template<typename T> ArrayRef<T> as_ref(uint index) const
- {
- BLI_assert(GET_TYPE<T>().is_same_or_generalization(m_type));
- const BufferSlice &slice = this->slices()[index];
- return ArrayRef<T>((const T *)slice.start, slice.length);
- }
-
- void append_single__copy(uint index, void *src)
+ void append_single__copy(uint index, const void *src)
{
MutableArrayRef<BufferSlice> slices = this->slices();
BufferSlice &slice = slices[index];
@@ -88,6 +81,54 @@ class GenericVectorArray : BLI::NonCopyable, BLI::NonMovable {
}
}
+ template<typename T> class TypedRef {
+ private:
+ const GenericVectorArray *m_data;
+
+ public:
+ TypedRef(const GenericVectorArray &data) : m_data(&data)
+ {
+ }
+
+ ArrayRef<T> operator[](uint index) const
+ {
+ const BufferSlice &slice = m_data->slices()[index];
+ return ArrayRef<T>((const T *)slice.start, slice.length);
+ }
+ };
+
+ template<typename T> class MutableTypedRef {
+ private:
+ GenericVectorArray *m_data;
+
+ public:
+ MutableTypedRef(GenericVectorArray &data) : m_data(&data)
+ {
+ }
+
+ operator TypedRef<T>() const
+ {
+ return TypedRef<T>(*m_data);
+ }
+
+ MutableArrayRef<T> operator[](uint index) const
+ {
+ const BufferSlice &slice = m_data->slices()[index];
+ return MutableArrayRef<T>((T *)slice.start, slice.length);
+ }
+
+ void append_single(uint index, const T &value)
+ {
+ m_data->append_single__copy(index, (void *)&value);
+ }
+ };
+
+ template<typename T> const TypedRef<T> as_typed_ref() const
+ {
+ BLI_assert(GET_TYPE<T>().is_same_or_generalization(m_type));
+ return TypedRef<T>(*this);
+ }
+
private:
void grow_single(BufferSlice &slice, uint min_capacity)
{
diff --git a/source/blender/blenkernel/intern/node_functions.cc b/source/blender/blenkernel/intern/node_functions.cc
index cb52ee5cfd9..6c7909aa7fe 100644
--- a/source/blender/blenkernel/intern/node_functions.cc
+++ b/source/blender/blenkernel/intern/node_functions.cc
@@ -13,14 +13,6 @@ using BLI::ArrayOrSingleRef;
using BLI::float3;
class MultiFunction {
- private:
- Vector<CPPType *> m_single_input_types;
- 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 {
private:
@@ -33,34 +25,35 @@ class MultiFunction {
friend MultiFunction;
public:
- 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>());
- }
-
- template<typename T> void single_output(StringRef name)
- {
- m_function.m_single_output_names.append(name);
- m_function.m_single_output_types.append(&GET_TYPE<T>());
- }
-
- 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>());
- }
+ template<typename T> void readonly_single_input(StringRef name);
+ void readonly_single_input(StringRef name, CPPType &type);
+ template<typename T> void single_output(StringRef name);
+ void single_output(StringRef name, CPPType &base_type);
+ template<typename T> void readonly_vector_input(StringRef name);
+ void readonly_vector_input(StringRef name, CPPType &base_type);
+ template<typename T> void vector_output(StringRef name);
+ void mutable_vector(StringRef name, CPPType &base_type);
};
class Params {
public:
template<typename T> ArrayOrSingleRef<T> readonly_single_input(uint index, StringRef name);
+ const GenericArrayRef &readonly_single_input(uint index, StringRef name);
+
template<typename T> MutableArrayRef<T> 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);
+
+ template<typename T>
+ GenericVectorArray::MutableTypedRef<T> vector_output(uint index, StringRef name);
+ GenericVectorArray &vector_output(uint index, StringRef name);
+ GenericVectorArray &mutable_vector(uint index, StringRef name);
};
virtual void signature(Signature &signature) const = 0;
- virtual void call(ArrayRef<uint> indices, Params ¶ms) const = 0;
+ virtual void call(ArrayRef<uint> mask_indices, Params ¶ms) const = 0;
};
class MultiFunction_AddFloats : public MultiFunction {
@@ -71,13 +64,13 @@ class MultiFunction_AddFloats : public MultiFunction {
signature.single_output<float>("Result");
}
- void call(ArrayRef<uint> indices, Params ¶ms) const override
+ void call(ArrayRef<uint> mask_indices, Params ¶ms) const override
{
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");
+ auto result = params.single_output<float>(2, "Result");
- for (uint i : indices) {
+ for (uint i : mask_indices) {
result[i] = a[i] + b[i];
}
}
@@ -91,13 +84,13 @@ class MultiFunction_VectorDistance : public MultiFunction {
signature.single_output<float>("Distances");
}
- void call(ArrayRef<uint> indices, Params ¶ms) const override
+ void call(ArrayRef<uint> mask_indices, Params ¶ms) const override
{
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");
+ auto distances = params.single_output<float>(2, "Distances");
- for (uint i : indices) {
+ for (uint i : mask_indices) {
distances[i] = float3::distance(a[i], b[i]);
}
}
@@ -110,15 +103,14 @@ class MultiFunction_FloatArraySum : public MultiFunction {
signature.single_output<float>("Sum");
}
- void call(ArrayRef<uint> indices, Params ¶ms) const override
+ void call(ArrayRef<uint> mask_indices, Params ¶ms) const override
{
- const GenericVectorArray &arrays = params.readonly_vector_input(0, "Array");
- MutableArrayRef<float> sums = params.single_output<float>(0, "Sum");
+ auto arrays = params.readonly_vector_input<float>(0, "Array");
+ MutableArrayRef<float> sums = params.single_output<float>(1, "Sum");
- for (uint i : indices) {
- ArrayRef<float> array = arrays.as_ref<float>(i);
+ for (uint i : mask_indices) {
float sum = 0.0f;
- for (float value : array) {
+ for (float value : arrays[i]) {
sum += value;
}
sums[i] = sum;
@@ -126,4 +118,71 @@ class MultiFunction_FloatArraySum : public MultiFunction {
}
};
+class MultiFunction_FloatRange : public MultiFunction {
+ void signature(Signature &signature) const override
+ {
+ signature.readonly_single_input<float>("Start");
+ signature.readonly_single_input<float>("Step");
+ signature.readonly_single_input<uint>("Amount");
+ signature.vector_output<float>("Range");
+ }
+
+ void call(ArrayRef<uint> mask_indices, Params ¶ms) const override
+ {
+ auto starts = params.readonly_single_input<float>(0, "Start");
+ auto steps = params.readonly_single_input<float>(1, "Step");
+ auto amounts = params.readonly_single_input<uint>(2, "Amount");
+ auto ranges = params.vector_output<float>(3, "Range");
+
+ for (uint i : mask_indices) {
+ for (uint j = 0; j < amounts[i]; j++) {
+ float value = starts[i] + j * steps[i];
+ ranges.append_single(i, value);
+ }
+ }
+ }
+};
+
+class MultiFunction_AppendToList : public MultiFunction {
+ private:
+ CPPType &m_base_type;
+
+ public:
+ void signature(Signature &signature) const override
+ {
+ signature.mutable_vector("List", m_base_type);
+ signature.readonly_single_input("Value", m_base_type);
+ }
+
+ void call(ArrayRef<uint> mask_indices, Params ¶ms) const override
+ {
+ GenericVectorArray &lists = params.mutable_vector(0, "List");
+ GenericArrayRef values = params.readonly_single_input(1, "Value");
+
+ for (uint i : mask_indices) {
+ lists.append_single__copy(i, values[i]);
+ }
+ }
+};
+
+class MultiFunction_GetListElement : public MultiFunction {
+ private:
+ CPPType &m_base_type;
+
+ public:
+ void signature(Signature &signature) const override
+ {
+ signature.readonly_vector_input("List", m_base_type);
+ signature.readonly_single_input<int>("Index");
+ signature.readonly_single_input("Fallback", m_base_type);
+ signature.single_output("Value", m_base_type);
+ }
+
+ void call(ArrayRef<uint> mask_indices, Params ¶ms) const override
+ {
+ GenericVectorArray &lists = params.mutable_vector(0, "List");
+ ArrayOrSingleRef<int> input_indices = params.readonly_single_input<int>(1, "Index");
+ }
+};
+
} // namespace BKE
\ No newline at end of file
More information about the Bf-blender-cvs
mailing list