tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity

Cleanup: Use utility constructor to create field operations

This commit is contained in:
Hans Goudey 2023-04-23 14:03:50 -04:00
parent 18291930ce
commit 2f581a779c
10 changed files with 34 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/blenkernel/intern/type_conversions.cc
View File

@ -625,7 +625,7 @@ fn::GField DataTypeConversions::try_convert(fn::GField field, const CPPType &to_
}
const mf::MultiFunction &fn = *this->get_conversion_multi_function(
mf::DataType::ForSingle(from_type), mf::DataType::ForSingle(to_type));
return {std::make_shared<fn::FieldOperation>(fn, Vector<fn::GField>{std::move(field)})};
return {fn::FieldOperation::Create(fn, {std::move(field)})};
}
} // namespace blender::bke

2
source/blender/functions/intern/field.cc
View File

@ -522,7 +522,7 @@ Field<bool> invert_boolean_field(const Field<bool> &field)
{
static auto not_fn = mf::build::SI1_SO<bool, bool>(
"Not", [](bool a) { return !a; }, mf::build::exec_presets::AllSpanOrSingle());
auto not_op = std::make_shared<FieldOperation>(FieldOperation(not_fn, {field}));
auto not_op = FieldOperation::Create(not_fn, {field});
return Field<bool>(not_op);
}

31
source/blender/functions/tests/FN_field_test.cc
View File

@ -11,10 +11,8 @@ namespace blender::fn::tests {
TEST(field, ConstantFunction)
{
/* TODO: Figure out how to not use another "FieldOperation(" inside of std::make_shared. */
GField constant_field{std::make_shared<FieldOperation>(
FieldOperation(std::make_unique<mf::CustomMF_Constant<int>>(10), {})),
0};
GField constant_field{
FieldOperation::Create(std::make_unique<mf::CustomMF_Constant<int>>(10), {}), 0};
Array<int> result(4);
@ -103,8 +101,7 @@ TEST(field, InputAndFunction)
GField index_field{std::make_shared<IndexFieldInput>()};
auto add_fn = mf::build::SI2_SO<int, int, int>("add", [](int a, int b) { return a + b; });
GField output_field{
std::make_shared<FieldOperation>(FieldOperation(add_fn, {index_field, index_field})), 0};
GField output_field{FieldOperation::Create(add_fn, {index_field, index_field}), 0};
Array<int> result(10);
@ -126,11 +123,10 @@ TEST(field, TwoFunctions)
GField index_field{std::make_shared<IndexFieldInput>()};
auto add_fn = mf::build::SI2_SO<int, int, int>("add", [](int a, int b) { return a + b; });
GField add_field{
std::make_shared<FieldOperation>(FieldOperation(add_fn, {index_field, index_field})), 0};
GField add_field{FieldOperation::Create(add_fn, {index_field, index_field}), 0};
auto add_10_fn = mf::build::SI1_SO<int, int>("add_10", [](int a) { return a + 10; });
GField result_field{std::make_shared<FieldOperation>(FieldOperation(add_10_fn, {add_field})), 0};
GField result_field{FieldOperation::Create(add_10_fn, {add_field}), 0};
Array<int> result(10);
@ -181,8 +177,8 @@ TEST(field, FunctionTwoOutputs)
GField index_field_1{std::make_shared<IndexFieldInput>()};
GField index_field_2{std::make_shared<IndexFieldInput>()};
std::shared_ptr<FieldOperation> fn = std::make_shared<FieldOperation>(
FieldOperation(std::make_unique<TwoOutputFunction>(), {index_field_1, index_field_2}));
std::shared_ptr<FieldOperation> fn = FieldOperation::Create(
std::make_unique<TwoOutputFunction>(), {index_field_1, index_field_2});
GField result_field_1{fn, 0};
GField result_field_2{fn, 1};
@ -212,8 +208,8 @@ TEST(field, TwoFunctionsTwoOutputs)
{
GField index_field{std::make_shared<IndexFieldInput>()};
std::shared_ptr<FieldOperation> fn = std::make_shared<FieldOperation>(
FieldOperation(std::make_unique<TwoOutputFunction>(), {index_field, index_field}));
std::shared_ptr<FieldOperation> fn = FieldOperation::Create(
std::make_unique<TwoOutputFunction>(), {index_field, index_field});
Array<int64_t> mask_indices = {2, 4, 6, 8};
IndexMask mask = mask_indices.as_span();
@ -222,8 +218,7 @@ TEST(field, TwoFunctionsTwoOutputs)
Field<int> intermediate_field{fn, 1};
auto add_10_fn = mf::build::SI1_SO<int, int>("add_10", [](int a) { return a + 10; });
Field<int> result_field_2{
std::make_shared<FieldOperation>(FieldOperation(add_10_fn, {intermediate_field})), 0};
Field<int> result_field_2{FieldOperation::Create(add_10_fn, {intermediate_field}), 0};
FieldContext field_context;
FieldEvaluator field_evaluator{field_context, &mask};
@ -245,8 +240,8 @@ TEST(field, TwoFunctionsTwoOutputs)
TEST(field, SameFieldTwice)
{
GField constant_field{
std::make_shared<FieldOperation>(std::make_unique<mf::CustomMF_Constant<int>>(10)), 0};
GField constant_field{FieldOperation::Create(std::make_unique<mf::CustomMF_Constant<int>>(10)),
0};
FieldContext field_context;
IndexMask mask{IndexRange(2)};
@ -266,7 +261,7 @@ TEST(field, SameFieldTwice)
TEST(field, IgnoredOutput)
{
static mf::tests::OptionalOutputsFunction fn;
Field<int> field{std::make_shared<FieldOperation>(fn), 0};
Field<int> field{FieldOperation::Create(fn), 0};
FieldContext field_context;
FieldEvaluator field_evaluator{field_context, 10};

9
source/blender/geometry/intern/resample_curves.cc
View File

@ -21,10 +21,7 @@ static fn::Field<int> get_count_input_max_one(const fn::Field<int> &count_field)
"Clamp Above One",
[](int value) { return std::max(1, value); },
mf::build::exec_presets::AllSpanOrSingle());
auto clamp_op = std::make_shared<fn::FieldOperation>(
fn::FieldOperation(max_one_fn, {count_field}));
return fn::Field<int>(std::move(clamp_op));
return fn::Field<int>(fn::FieldOperation::Create(max_one_fn, {count_field}));
}
static fn::Field<int> get_count_input_from_length(const fn::Field<float> &length_field)
@ -39,9 +36,9 @@ static fn::Field<int> get_count_input_from_length(const fn::Field<float> &length
},
mf::build::exec_presets::AllSpanOrSingle());
auto get_count_op = std::make_shared<fn::FieldOperation>(fn::FieldOperation(
auto get_count_op = fn::FieldOperation::Create(
get_count_fn,
{fn::Field<float>(std::make_shared<bke::CurveLengthFieldInput>()), length_field}));
{fn::Field<float>(std::make_shared<bke::CurveLengthFieldInput>()), length_field});
return fn::Field<int>(std::move(get_count_op));
}

5
source/blender/nodes/geometry/nodes/node_geo_extrude_mesh.cc
View File

@ -1343,9 +1343,8 @@ static void node_geo_exec(GeoNodeExecParams params)
"Scale",
[](const float3 &offset, const float scale) { return offset * scale; },
mf::build::exec_presets::AllSpanOrSingle());
std::shared_ptr<FieldOperation> multiply_op = std::make_shared<FieldOperation>(
FieldOperation(multiply_fn, {std::move(offset_field), std::move(scale_field)}));
const Field<float3> final_offset{std::move(multiply_op)};
const Field<float3> final_offset{
FieldOperation::Create(multiply_fn, {std::move(offset_field), std::move(scale_field)})};
AttributeOutputs attribute_outputs;
attribute_outputs.top_id = params.get_output_anonymous_attribute_id_if_needed("Top");

3
source/blender/nodes/geometry/nodes/node_geo_image_texture.cc
View File

@ -415,8 +415,7 @@ static void node_geo_exec(GeoNodeExecParams params)
Field<float3> vector_field = params.extract_input<Field<float3>>("Vector");
auto image_op = std::make_shared<FieldOperation>(
FieldOperation(std::move(image_fn), {std::move(vector_field)}));
auto image_op = FieldOperation::Create(std::move(image_fn), {std::move(vector_field)});
params.set_output("Color", Field<ColorGeometry4f>(image_op, 0));
params.set_output("Alpha", Field<float>(image_op, 1));

10
source/blender/nodes/geometry/nodes/node_geo_mesh_to_points.cc
View File

@ -47,9 +47,9 @@ static void node_init(bNodeTree * /*tree*/, bNode *node)
}
static void geometry_set_mesh_to_points(GeometrySet &geometry_set,
Field<float3> &position_field,
Field<float> &radius_field,
Field<bool> &selection_field,
const Field<float3> &position_field,
const Field<float> &radius_field,
const Field<bool> &selection_field,
const eAttrDomain domain,
const AnonymousAttributePropagationInfo &propagation_info)
{
@ -151,9 +151,7 @@ static void node_geo_exec(GeoNodeExecParams params)
__func__,
[](float value) { return std::max(0.0f, value); },
mf::build::exec_presets::AllSpanOrSingle());
auto max_zero_op = std::make_shared<FieldOperation>(
FieldOperation(max_zero_fn, {std::move(radius)}));
Field<float> positive_radius(std::move(max_zero_op), 0);
const Field<float> positive_radius(FieldOperation::Create(max_zero_fn, {std::move(radius)}), 0);
const NodeGeometryMeshToPoints &storage = node_storage(params.node());
const GeometryNodeMeshToPointsMode mode = (GeometryNodeMeshToPointsMode)storage.mode;

11
source/blender/nodes/geometry/nodes/node_geo_proximity.cc
View File

@ -198,10 +198,10 @@ class ProximityFunction : public mf::MultiFunction {
static void node_geo_exec(GeoNodeExecParams params)
{
GeometrySet geometry_set_target = params.extract_input<GeometrySet>("Target");
geometry_set_target.ensure_owns_direct_data();
GeometrySet target = params.extract_input<GeometrySet>("Target");
target.ensure_owns_direct_data();
if (!geometry_set_target.has_mesh() && !geometry_set_target.has_pointcloud()) {
if (!target.has_mesh() && !target.has_pointcloud()) {
params.set_default_remaining_outputs();
return;
}
@ -210,9 +210,8 @@ static void node_geo_exec(GeoNodeExecParams params)
Field<float3> position_field = params.extract_input<Field<float3>>("Source Position");
auto proximity_fn = std::make_unique<ProximityFunction>(
std::move(geometry_set_target), GeometryNodeProximityTargetType(storage.target_element));
auto proximity_op = std::make_shared<FieldOperation>(
FieldOperation(std::move(proximity_fn), {std::move(position_field)}));
std::move(target), GeometryNodeProximityTargetType(storage.target_element));
auto proximity_op = FieldOperation::Create(std::move(proximity_fn), {std::move(position_field)});
params.set_output("Position", Field<float3>(proximity_op, 0));
params.set_output("Distance", Field<float>(proximity_op, 1));

4
source/blender/nodes/geometry/nodes/node_geo_raycast.cc
View File

@ -407,9 +407,9 @@ static void node_geo_exec(GeoNodeExecParams params)
Field<float> length_field = params.extract_input<Field<float>>("Ray Length");
auto fn = std::make_unique<RaycastFunction>(std::move(target), std::move(field), mapping);
auto op = std::make_shared<FieldOperation>(FieldOperation(
auto op = FieldOperation::Create(
std::move(fn),
{std::move(position_field), std::move(direction_field), std::move(length_field)}));
{std::move(position_field), std::move(direction_field), std::move(length_field)});
params.set_output("Is Hit", Field<bool>(op, 0));
params.set_output("Hit Position", Field<float3>(op, 1));

4
source/blender/nodes/intern/geometry_nodes_lazy_function.cc
View File

@ -341,10 +341,10 @@ static void execute_multi_function_on_value_or_field(
/* Construct the new field node. */
std::shared_ptr<fn::FieldOperation> operation;
if (owned_fn) {
operation = std::make_shared<fn::FieldOperation>(owned_fn, std::move(input_fields));
operation = fn::FieldOperation::Create(owned_fn, std::move(input_fields));
}
else {
operation = std::make_shared<fn::FieldOperation>(fn, std::move(input_fields));
operation = fn::FieldOperation::Create(fn, std::move(input_fields));
}
/* Store the new fields in the output. */