[Bf-blender-cvs] [f716060408b] temp-geometry-nodes-fields-prototype: improve
Jacques Lucke
noreply at git.blender.org
Wed Jul 28 14:14:20 CEST 2021
Commit: f716060408be700261f060402df56ff9d891f712
Author: Jacques Lucke
Date: Tue Jul 27 14:33:35 2021 +0200
Branches: temp-geometry-nodes-fields-prototype
https://developer.blender.org/rBf716060408be700261f060402df56ff9d891f712
improve
===================================================================
M source/blender/blenkernel/BKE_field.hh
M source/blender/modifiers/intern/MOD_nodes_evaluator.cc
M source/blender/nodes/geometry/nodes/node_geo_attribute.cc
M source/blender/nodes/geometry/nodes/node_geo_attribute_fill.cc
===================================================================
diff --git a/source/blender/blenkernel/BKE_field.hh b/source/blender/blenkernel/BKE_field.hh
index 83435ad8236..2604a095949 100644
--- a/source/blender/blenkernel/BKE_field.hh
+++ b/source/blender/blenkernel/BKE_field.hh
@@ -121,7 +121,7 @@ class FieldInputs {
using InputMap = Map<std::reference_wrapper<const FieldInputKey>, const FieldInputValue *>;
InputMap inputs_;
- friend class GField;
+ friend class Field;
public:
InputMap::KeyIterator begin() const
@@ -150,32 +150,12 @@ class FieldInputs {
}
};
-template<typename T> class FieldOutput {
- private:
- optional_ptr<const VArray<T>> varray_;
-
- public:
- FieldOutput(optional_ptr<const VArray<T>> varray) : varray_(std::move(varray))
- {
- }
-
- optional_ptr<const VArray<T>> extract()
- {
- return std::move(varray_);
- }
-
- const VArray<T> &varray() const
- {
- return *varray_;
- }
-};
-
-class GFieldOutput {
+class FieldOutput {
private:
optional_ptr<const GVArray> varray_;
public:
- GFieldOutput(optional_ptr<const GVArray> varray) : varray_(std::move(varray))
+ FieldOutput(optional_ptr<const GVArray> varray) : varray_(std::move(varray))
{
}
@@ -185,12 +165,12 @@ class GFieldOutput {
}
};
-class GField {
+class Field {
private:
mutable std::atomic<int> users_ = 1;
public:
- virtual ~GField() = default;
+ virtual ~Field() = default;
FieldInputs prepare_inputs() const
{
@@ -206,7 +186,7 @@ class GField {
virtual const CPPType &output_type() const = 0;
- virtual GFieldOutput evaluate_generic(IndexMask mask, const FieldInputs &inputs) const = 0;
+ virtual FieldOutput evaluate(IndexMask mask, const FieldInputs &inputs) const = 0;
void user_add() const
{
@@ -222,24 +202,9 @@ class GField {
}
};
-template<typename T> class Field : public GField {
- public:
- virtual FieldOutput<T> evaluate(IndexMask mask, const FieldInputs &inputs) const = 0;
+using FieldPtr = UserCounter<Field>;
- GFieldOutput evaluate_generic(IndexMask mask, const FieldInputs &inputs) const override
- {
- FieldOutput<T> output = this->evaluate(mask, inputs);
- return optional_ptr<const GVArray>{
- std::make_unique<fn::GVArray_For_VArray<T>>(output.extract().extract_owned())};
- }
-
- const CPPType &output_type() const override
- {
- return CPPType::get<T>();
- }
-};
-
-template<typename T> class ConstantField : public Field<T> {
+template<typename T> class ConstantField : public Field {
private:
T value_;
@@ -248,19 +213,24 @@ template<typename T> class ConstantField : public Field<T> {
{
}
- FieldOutput<T> evaluate(IndexMask mask, const FieldInputs &UNUSED(inputs)) const
+ const CPPType &output_type() const override
+ {
+ return CPPType::get<T>();
+ }
+
+ FieldOutput evaluate(IndexMask mask, const FieldInputs &UNUSED(inputs)) const
{
- return optional_ptr<const VArray<T>>{
- std::make_unique<VArray_For_Single<T>>(value_, mask.min_array_size())};
+ return optional_ptr<const GVArray>{std::make_unique<fn::GVArray_For_SingleValue>(
+ CPPType::get<T>(), mask.min_array_size(), &value_)};
}
};
-template<typename KeyT> class VArrayInputField : public GField {
+template<typename KeyT> class GVArrayInputField : public Field {
private:
KeyT key_;
public:
- template<typename... Args> VArrayInputField(Args &&... args) : key_(std::forward<Args>(args)...)
+ template<typename... Args> GVArrayInputField(Args &&...args) : key_(std::forward<Args>(args)...)
{
}
@@ -274,44 +244,26 @@ template<typename KeyT> class VArrayInputField : public GField {
return key_.type();
}
- GFieldOutput evaluate_generic(IndexMask mask, const FieldInputs &inputs) const override
+ FieldOutput evaluate(IndexMask mask, const FieldInputs &inputs) const override
{
const GVArrayFieldInputValue *input = inputs.get<GVArrayFieldInputValue>(key_);
if (input == nullptr) {
- return GFieldOutput{
+ return FieldOutput{
optional_ptr<const GVArray>{std::make_unique<fn::GVArray_For_SingleValueRef>(
key_.type(), mask.min_array_size(), key_.type().default_value())}};
}
- return GFieldOutput{optional_ptr<const GVArray>{input->varray()}};
+ return FieldOutput{optional_ptr<const GVArray>{input->varray()}};
}
};
-template<typename T, typename VArrayT> class VArrayField : public Field<T> {
+class MultiFunctionField : public Field {
private:
- T default_value_;
- VArrayT varray_;
-
- public:
- template<typename... Args>
- VArrayField(T default_value, Args &&... args)
- : default_value_(std::move(default_value)), varray_(std::forward<Args>(args)...)
- {
- }
-
- FieldOutput<T> evaluate(IndexMask UNUSED(mask), const FieldInputs &UNUSED(inputs)) const override
- {
- return {varray_};
- }
-};
-
-class MultiFunctionField : public GField {
- private:
- Vector<std::shared_ptr<GField>> input_fields_;
+ Vector<FieldPtr> input_fields_;
const MultiFunction *fn_;
const int output_param_index_;
public:
- MultiFunctionField(Vector<std::shared_ptr<GField>> input_fields,
+ MultiFunctionField(Vector<FieldPtr> input_fields,
const MultiFunction &fn,
const int output_param_index)
: input_fields_(std::move(input_fields)), fn_(&fn), output_param_index_(output_param_index)
@@ -323,7 +275,7 @@ class MultiFunctionField : public GField {
return fn_->param_type(output_param_index_).data_type().single_type();
}
- GFieldOutput evaluate_generic(IndexMask mask, const FieldInputs &inputs) const
+ FieldOutput evaluate(IndexMask mask, const FieldInputs &inputs) const
{
fn::MFParamsBuilder params{*fn_, mask.min_array_size()};
fn::MFContextBuilder context;
@@ -338,8 +290,8 @@ class MultiFunctionField : public GField {
fn::MFParamType param_type = fn_->param_type(param_index);
switch (param_type.category()) {
case fn::MFParamType::SingleInput: {
- const GField &field = *input_fields_[input_index];
- GFieldOutput &output = scope.add_value(field.evaluate_generic(mask, inputs), __func__);
+ const Field &field = *input_fields_[input_index];
+ FieldOutput &output = scope.add_value(field.evaluate(mask, inputs), __func__);
params.add_readonly_single_input(output.varray_ref());
input_index++;
}
@@ -375,10 +327,39 @@ class MultiFunctionField : public GField {
std::unique_ptr<GVArray> out_array = std::make_unique<fn::GVArray_For_OwnedGSpan>(output_span,
mask);
- return GFieldOutput{optional_ptr<const GVArray>{std::move(out_array)}};
+ return FieldOutput{optional_ptr<const GVArray>{std::move(out_array)}};
}
};
-template<typename T> using FieldPtr = UserCounter<Field<T>>;
+template<typename T> class FieldRef {
+ private:
+ FieldPtr field_;
+
+ public:
+ FieldRef(FieldPtr field) : field_(std::move(field))
+ {
+ }
+
+ const Field *operator->() const
+ {
+ return &*field_;
+ }
+
+ uint64_t hash() const
+ {
+ return get_default_hash(&*field_);
+ }
+
+ friend bool operator==(const FieldRef &a, const FieldRef &b)
+ {
+ return &*a.field_ == &*b.field_;
+ }
+
+ friend std::ostream &operator<<(std::ostream &stream, const FieldRef &a)
+ {
+ stream << &*a.field_;
+ return stream;
+ }
+};
} // namespace blender::bke
diff --git a/source/blender/modifiers/intern/MOD_nodes_evaluator.cc b/source/blender/modifiers/intern/MOD_nodes_evaluator.cc
index 3d655fda199..9e9e380b649 100644
--- a/source/blender/modifiers/intern/MOD_nodes_evaluator.cc
+++ b/source/blender/modifiers/intern/MOD_nodes_evaluator.cc
@@ -31,7 +31,7 @@
#include "BLI_task.hh"
#include "BLI_vector_set.hh"
-MAKE_CPP_TYPE(FloatFieldPtr, blender::bke::FieldPtr<float>, CPPTypeFlags::BasicType);
+MAKE_CPP_TYPE(FloatFieldRef, blender::bke::FieldRef<float>, CPPTypeFlags::BasicType);
namespace blender::modifiers::geometry_nodes {
@@ -307,7 +307,7 @@ static const CPPType *get_socket_cpp_type(const SocketRef &socket)
return nullptr;
}
if (type->is<float>()) {
- return &CPPType::get<FieldPtr<float>>();
+ return &CPPType::get<bke::FieldRef<float>>();
}
return type;
}
@@ -322,7 +322,7 @@ static void get_socket_value(const SocketRef &socket, void *r_value)
if (socket.typeinfo()->type == SOCK_FLOAT) {
float value;
socket.typeinfo()->get_cpp_value(*socket.bsocket(), &value);
- new (r_value) FieldPtr<float>(new bke::ConstantField<float>(value));
+ new (r_value) bke::FieldRef<float>(FieldPtr{new bke::ConstantField<float>(value)});
return;
}
blender::nodes::socket_cpp_value_get(*socket.bsocket(), r_value);
diff --git a/source/blender/nodes/geometry/nodes/node_geo_attribute.cc b/source/blender/nodes/geometry/nodes/node_geo_attribute.cc
index 77ecfdfd2c2..a62e4cb51e9 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_attribute.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_attribute.cc
@@ -83,9 +83,9 @@ static void geo_node_attribute_exec(GeoNodeExecParams params)
const CPPType *cpp_type = get_cpp_type((eNodeSocketDatatype)node_storage->output_type);
BLI_assert(cpp_type != nullptr);
- std::unique_ptr<bke::GField> field =
- std::make_unique<bke::VArrayInputField<bke::AttributeFieldInputKey>>(std::move(name),
- *cpp_type);
+ std::unique_ptr<bke::Field> field =
+ std::make_unique<bke::GVArrayInputField<bke::AttributeFieldInputKey>>(std::move(name),
+ *cpp_type);
// params.set_output("Attribute", std::move(field));
}
diff --git a/source/blender/nodes/geometry/nodes/node_geo_attribute_fill.cc b/source/blender/nodes/geometry/nodes/node_geo_attribute_fill.cc
index 48338f4ee93..406b72bc345 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_attribute_fill.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_attribute_fill.cc
@@ -121,14 +121,14 @@ static void fill_attribute(GeometryComponent &component, const GeoNodeExecParams
switch (data_type) {
case C
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list