[Bf-blender-cvs] [ca19757aec8] functions: refactor MFParamType
Jacques Lucke
noreply at git.blender.org
Sun Nov 17 13:57:54 CET 2019
Commit: ca19757aec8c20346aac487d57ad288ae2f8cd07
Author: Jacques Lucke
Date: Sun Nov 17 12:10:48 2019 +0100
Branches: functions
https://developer.blender.org/rBca19757aec8c20346aac487d57ad288ae2f8cd07
refactor MFParamType
===================================================================
M source/blender/functions/FN_multi_function.h
M source/blender/functions/FN_multi_function_param_type.h
M source/blender/functions/intern/multi_function_network.cc
M source/blender/functions/intern/multi_functions/lists.cc
M source/blender/functions/intern/multi_functions/lists.h
M source/blender/functions/intern/multi_functions/mixed.cc
M source/blender/functions/intern/multi_functions/mixed.h
M source/blender/functions/intern/multi_functions/network.cc
M source/blender/functions/intern/multi_functions/network.h
M source/blender/simulations/bparticles/particle_function.cpp
===================================================================
diff --git a/source/blender/functions/FN_multi_function.h b/source/blender/functions/FN_multi_function.h
index d4214620aed..30016442488 100644
--- a/source/blender/functions/FN_multi_function.h
+++ b/source/blender/functions/FN_multi_function.h
@@ -41,20 +41,23 @@ class MFSignature {
uint vector_arrays = 0;
for (MFParamType param_type : m_param_types) {
uint corrected_index = 0;
- switch (param_type.category()) {
- case MFParamType::ReadonlySingleInput:
+ switch (param_type.type()) {
+ case MFParamType::Type::SingleInput:
corrected_index = array_or_single_refs++;
break;
- case MFParamType::SingleOutput:
+ case MFParamType::Type::SingleOutput:
corrected_index = mutable_array_refs++;
break;
- case MFParamType::ReadonlyVectorInput:
+ case MFParamType::Type::VectorInput:
corrected_index = virtual_list_list_refs++;
break;
- case MFParamType::VectorOutput:
- case MFParamType::MutableVector:
+ case MFParamType::Type::VectorOutput:
+ case MFParamType::Type::MutableVector:
corrected_index = vector_arrays++;
break;
+ case MFParamType::Type::MutableSingle:
+ corrected_index = mutable_array_refs++;
+ break;
}
m_corrected_indices.append(corrected_index);
}
@@ -72,11 +75,11 @@ class MFSignature {
template<typename T> bool is_readonly_single_input(uint index, StringRef name) const
{
- return this->is_valid_param<T>(index, name, MFParamType::ReadonlySingleInput);
+ return this->is_valid_param<T>(index, name, MFParamType::SingleInput);
}
bool is_readonly_single_input(uint index, StringRef name) const
{
- return this->is_valid_param(index, name, MFParamType::ReadonlySingleInput);
+ return this->is_valid_param(index, name, MFParamType::SingleInput);
}
template<typename T> bool is_single_output(uint index, StringRef name) const
@@ -90,11 +93,11 @@ class MFSignature {
template<typename T> bool is_readonly_vector_input(uint index, StringRef name) const
{
- return this->is_valid_param<T>(index, name, MFParamType::ReadonlyVectorInput);
+ return this->is_valid_param<T>(index, name, MFParamType::VectorInput);
}
bool is_readonly_vector_input(uint index, StringRef name) const
{
- return this->is_valid_param(index, name, MFParamType::ReadonlyVectorInput);
+ return this->is_valid_param(index, name, MFParamType::VectorInput);
}
template<typename T> bool is_vector_output(uint index, StringRef name) const
@@ -113,30 +116,29 @@ class MFSignature {
private:
template<typename T>
- bool is_valid_param(uint index, StringRef name, MFParamType::Category category) const
+ bool is_valid_param(uint index, StringRef name, MFParamType::Type type) const
{
- if (!this->is_valid_param(index, name, category)) {
+ if (!this->is_valid_param(index, name, type)) {
return false;
}
- else if (ELEM(category, MFParamType::ReadonlySingleInput, MFParamType::SingleOutput)) {
- return CPP_TYPE<T>().is_same_or_generalization(m_param_types[index].type());
+ else if (ELEM(type, MFParamType::SingleInput, MFParamType::SingleOutput)) {
+ return CPP_TYPE<T>().is_same_or_generalization(m_param_types[index].data_type().type());
}
- else if (ELEM(category,
- MFParamType::ReadonlyVectorInput,
+ else if (ELEM(type,
+ MFParamType::VectorInput,
MFParamType::VectorOutput,
MFParamType::MutableVector)) {
- return CPP_TYPE<T>().is_same_or_generalization(m_param_types[index].base_type());
+ return CPP_TYPE<T>().is_same_or_generalization(m_param_types[index].data_type().base_type());
}
else {
return false;
}
}
- bool is_valid_param(uint index, StringRef name, MFParamType::Category category) const
+ bool is_valid_param(uint index, StringRef name, MFParamType::Type type) const
{
/* Empty name means that it should not be checked for. */
- return (m_param_names[index] == name || name == "") &&
- m_param_types[index].category() == category;
+ return (m_param_names[index] == name || name == "") && m_param_types[index].type() == type;
}
};
@@ -151,50 +153,68 @@ class MFSignatureBuilder {
{
}
- template<typename T> void readonly_single_input(StringRef name)
+ /* Input Param Types */
+
+ template<typename T> void single_input(StringRef name)
{
- this->readonly_single_input(name, CPP_TYPE<T>());
+ this->single_input(name, CPP_TYPE<T>());
}
- void readonly_single_input(StringRef name, const CPPType &type)
+ void single_input(StringRef name, const CPPType &type)
{
- m_param_names.append(name);
- m_param_types.append(MFParamType(MFParamType::ReadonlySingleInput, &type));
+ this->input(name, MFDataType::ForSingle(type));
}
-
- template<typename T> void single_output(StringRef name)
+ template<typename T> void vector_input(StringRef name)
{
- this->single_output(name, CPP_TYPE<T>());
+ this->vector_input(name, CPP_TYPE<T>());
}
- void single_output(StringRef name, const CPPType &type)
+ void vector_input(StringRef name, const CPPType &base_type)
+ {
+ this->input(name, MFDataType::ForVector(base_type));
+ }
+ void input(StringRef name, MFDataType data_type)
{
m_param_names.append(name);
- m_param_types.append(MFParamType(MFParamType::SingleOutput, &type));
+ m_param_types.append(MFParamType(MFParamType::Input, data_type));
}
- template<typename T> void readonly_vector_input(StringRef name)
+ /* Output Param Types */
+
+ template<typename T> void single_output(StringRef name)
{
- this->readonly_vector_input(name, CPP_TYPE<T>());
+ this->single_output(name, CPP_TYPE<T>());
}
- void readonly_vector_input(StringRef name, const CPPType &base_type)
+ void single_output(StringRef name, const CPPType &type)
{
- m_param_names.append(name);
- m_param_types.append(MFParamType(MFParamType::ReadonlyVectorInput, &base_type));
+ this->output(name, MFDataType::ForSingle(type));
}
-
template<typename T> void vector_output(StringRef name)
{
this->vector_output(name, CPP_TYPE<T>());
}
void vector_output(StringRef name, const CPPType &base_type)
+ {
+ this->output(name, MFDataType::ForVector(base_type));
+ }
+ void output(StringRef name, MFDataType data_type)
{
m_param_names.append(name);
- m_param_types.append(MFParamType(MFParamType::VectorOutput, &base_type));
+ m_param_types.append(MFParamType(MFParamType::Output, data_type));
}
+ /* Mutable Param Types */
+
+ void mutable_single(StringRef name, const CPPType &type)
+ {
+ this->mutable_param(name, MFDataType::ForSingle(type));
+ }
void mutable_vector(StringRef name, const CPPType &base_type)
+ {
+ this->mutable_param(name, MFDataType::ForVector(base_type));
+ }
+ void mutable_param(StringRef name, MFDataType data_type)
{
m_param_names.append(name);
- m_param_types.append(MFParamType(MFParamType::MutableVector, &base_type));
+ m_param_types.append(MFParamType(MFParamType::Mutable, data_type));
}
MFSignature build()
@@ -309,6 +329,12 @@ class MFParamsBuilder {
BLI_assert(vector_array.size() >= m_min_array_size);
m_vector_arrays.append(&vector_array);
}
+
+ void add_mutable_single(GenericMutableArrayRef array)
+ {
+ BLI_assert(array.size() >= m_min_array_size);
+ m_mutable_array_refs.append(array);
+ }
};
class MFParams {
diff --git a/source/blender/functions/FN_multi_function_param_type.h b/source/blender/functions/FN_multi_function_param_type.h
index 7c9adaa8b2f..380aa60836a 100644
--- a/source/blender/functions/FN_multi_function_param_type.h
+++ b/source/blender/functions/FN_multi_function_param_type.h
@@ -7,93 +7,105 @@ namespace FN {
struct MFParamType {
public:
- enum Category {
- ReadonlySingleInput,
+ enum InterfaceType {
+ Input,
+ Output,
+ Mutable,
+ };
+
+ enum Type {
+ SingleInput,
+ VectorInput,
SingleOutput,
- ReadonlyVectorInput,
VectorOutput,
+ MutableSingle,
MutableVector,
};
- public:
- MFParamType(Category category, const CPPType *base_type = nullptr)
- : m_category(category), m_base_type(base_type)
+ MFParamType(InterfaceType interface_type, MFDataType data_type)
+ : m_interface_type(interface_type), m_data_type(data_type)
+ {
+ }
+
+ bool is_single_input() const
{
+ return m_interface_type == Input && m_data_type.is_single();
}
- bool is_readonly_single_input() const
+ bool is_vector_input() const
{
- return m_category == ReadonlySingleInput;
+ return m_interface_type == Input && m_data_type.is_vector();
}
- bool is_readonly_vector_input() const
+ bool is_mutable_single() const
{
- return m_category == ReadonlyVectorInput;
+ return m_interface_type == Mutable && m_data_type.is_single();
}
bool is_mutable_vector() const
{
- return m_category == MutableVector;
+ return m_interface_type == Mutable && m_data_type.is_vector();
}
bool is_single_output() const
{
- return m_category == SingleOutput;
+ return m_interface_type == Output && m_data_type.is_single();
}
bool is_input_or_mutable() const
{
- return ELEM(m_category, ReadonlySingleInput, ReadonlyVectorInput, MutableVector);
+ return ELEM(m_interface_type, Input, Mutable);
}
bool is_output_or_mutable() const
{
- return ELEM(m_category, SingleOutput, VectorOutput, MutableVector);
+ return ELEM(m_interface_type, Output, Mutable);
}
bool is_vector_output() const
{
- return m_category == VectorOutput;
+ return m_interface_type == Output && m_data_type.is_vector();
}
- MFDataType as_data_type() const
+ Type type() const
{
- switch (m_category) {
- case ReadonlySingleInput:
- case SingleOutput:
- return MFDataType::ForSingle(*m_base_type);
- case ReadonlyVectorInput:
- case VectorOutput:
- case MutableVector:
- return MFDataType::ForVector(*m_base_type);
+ if (m_data_type.is_single()) {
+ sw
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list