Blender V5.3
FN_field_test.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#include "testing/testing.h"
6
7#include "BKE_gtest_base.hh"
8
9#include "BLI_cpp_type.hh"
10
14
16
18
19TEST_F(FieldTest, ConstantFunction)
20{
21 GField constant_field{FieldOperation::from(std::make_unique<mf::CustomMF_Constant<int>>(10), {}),
22 0};
23
25
26 FieldContext context;
27 FieldEvaluator evaluator{context, 4};
28 evaluator.add_with_destination(constant_field, result.as_mutable_span());
29 evaluator.evaluate();
30 EXPECT_EQ(result[0], 10);
31 EXPECT_EQ(result[1], 10);
32 EXPECT_EQ(result[2], 10);
33 EXPECT_EQ(result[3], 10);
34}
35
37 public:
38 IndexFieldInput() : FieldInput(CPPType::get<int>(), "Index") {}
39
41 const IndexMask &mask,
42 ResourceScope & /*scope*/) const final
43 {
44 auto index_func = [](int i) { return i; };
45 return VArray<int>::from_func(mask.min_array_size(), index_func);
46 }
47};
48
49TEST_F(FieldTest, VArrayInput)
50{
52
53 Array<int> result_1(4);
54
55 FieldContext context;
56 FieldEvaluator evaluator{context, 4};
57 evaluator.add_with_destination(index_field, result_1.as_mutable_span());
58 evaluator.evaluate();
59 EXPECT_EQ(result_1[0], 0);
60 EXPECT_EQ(result_1[1], 1);
61 EXPECT_EQ(result_1[2], 2);
62 EXPECT_EQ(result_1[3], 3);
63
64 /* Evaluate a second time, just to test that the first didn't break anything. */
65 Array<int> result_2(10);
66
67 const Array<int64_t> indices = {2, 4, 6, 8};
68 IndexMaskMemory memory;
69 const IndexMask mask = IndexMask::from_indices<int64_t>(indices, memory);
70
71 FieldEvaluator evaluator_2{context, &mask};
72 evaluator_2.add_with_destination(index_field, result_2.as_mutable_span());
73 evaluator_2.evaluate();
74 EXPECT_EQ(result_2[2], 2);
75 EXPECT_EQ(result_2[4], 4);
76 EXPECT_EQ(result_2[6], 6);
77 EXPECT_EQ(result_2[8], 8);
78}
79
80TEST_F(FieldTest, VArrayInputMultipleOutputs)
81{
82 FieldInputPtr index_input{MEM_new<IndexFieldInput>(__func__)};
83 GField field_1{index_input};
84 GField field_2{index_input};
85
86 Array<int> result_1(10);
87 Array<int> result_2(10);
88
89 const Array<int64_t> indices = {2, 4, 6, 8};
90 IndexMaskMemory memory;
91 const IndexMask mask = IndexMask::from_indices<int64_t>(indices, memory);
92
93 FieldContext context;
94 FieldEvaluator evaluator{context, &mask};
95 evaluator.add_with_destination(field_1, result_1.as_mutable_span());
96 evaluator.add_with_destination(field_2, result_2.as_mutable_span());
97 evaluator.evaluate();
98 EXPECT_EQ(result_1[2], 2);
99 EXPECT_EQ(result_1[4], 4);
100 EXPECT_EQ(result_1[6], 6);
101 EXPECT_EQ(result_1[8], 8);
102 EXPECT_EQ(result_2[2], 2);
103 EXPECT_EQ(result_2[4], 4);
104 EXPECT_EQ(result_2[6], 6);
105 EXPECT_EQ(result_2[8], 8);
106}
107
108TEST_F(FieldTest, InputAndFunction)
109{
111
112 auto add_fn = mf::build::SI2_SO<int, int, int>("add", [](int a, int b) { return a + b; });
113 GField output_field{FieldOperation::from(add_fn, {index_field, index_field}), 0};
114
115 Array<int> result(10);
116
117 const Array<int64_t> indices = {2, 4, 6, 8};
118 IndexMaskMemory memory;
119 const IndexMask mask = IndexMask::from_indices<int64_t>(indices, memory);
120
121 FieldContext context;
122 FieldEvaluator evaluator{context, &mask};
123 evaluator.add_with_destination(output_field, result.as_mutable_span());
124 evaluator.evaluate();
125 EXPECT_EQ(result[2], 4);
126 EXPECT_EQ(result[4], 8);
127 EXPECT_EQ(result[6], 12);
128 EXPECT_EQ(result[8], 16);
129}
130
131TEST_F(FieldTest, TwoFunctions)
132{
134
135 auto add_fn = mf::build::SI2_SO<int, int, int>("add", [](int a, int b) { return a + b; });
136 GField add_field{FieldOperation::from(add_fn, {index_field, index_field}), 0};
137
138 auto add_10_fn = mf::build::SI1_SO<int, int>("add_10", [](int a) { return a + 10; });
139 GField result_field{FieldOperation::from(add_10_fn, {add_field}), 0};
140
141 Array<int> result(10);
142
143 const Array<int64_t> indices = {2, 4, 6, 8};
144 IndexMaskMemory memory;
145 const IndexMask mask = IndexMask::from_indices<int64_t>(indices, memory);
146
147 FieldContext context;
148 FieldEvaluator evaluator{context, &mask};
149 evaluator.add_with_destination(result_field, result.as_mutable_span());
150 evaluator.evaluate();
151 EXPECT_EQ(result[2], 14);
152 EXPECT_EQ(result[4], 18);
153 EXPECT_EQ(result[6], 22);
154 EXPECT_EQ(result[8], 26);
155}
156
157class TwoOutputFunction : public mf::MultiFunction {
158 private:
159 mf::Signature signature_;
160
161 public:
163 {
164 mf::SignatureBuilder builder{"Two Outputs", signature_};
165 builder.single_input<int>("In1");
166 builder.single_input<int>("In2");
167 builder.single_output<int>("Add");
168 builder.single_output<int>("Add10");
169 this->set_signature(&signature_);
170 }
171
172 void call(const IndexMask &mask, mf::Params params, mf::Context /*context*/) const override
173 {
174 const VArray<int> &in1 = params.readonly_single_input<int>(0, "In1");
175 const VArray<int> &in2 = params.readonly_single_input<int>(1, "In2");
176 MutableSpan<int> add = params.uninitialized_single_output<int>(2, "Add");
177 MutableSpan<int> add_10 = params.uninitialized_single_output<int>(3, "Add10");
178 mask.foreach_index([&](const int64_t i) {
179 add[i] = in1[i] + in2[i];
180 add_10[i] = add[i] + 10;
181 });
182 }
183};
184
185TEST_F(FieldTest, FunctionTwoOutputs)
186{
187 /* Also use two separate input fields, why not. */
190
191 FieldOperationPtr fn = FieldOperation::from(std::make_unique<TwoOutputFunction>(),
192 {index_field_1, index_field_2});
193
194 GField result_field_1{fn, 0};
195 GField result_field_2{fn, 1};
196
197 Array<int> result_1(10);
198 Array<int> result_2(10);
199
200 const Array<int64_t> indices = {2, 4, 6, 8};
201 IndexMaskMemory memory;
202 const IndexMask mask = IndexMask::from_indices<int64_t>(indices, memory);
203
204 FieldContext context;
205 FieldEvaluator evaluator{context, &mask};
206 evaluator.add_with_destination(result_field_1, result_1.as_mutable_span());
207 evaluator.add_with_destination(result_field_2, result_2.as_mutable_span());
208 evaluator.evaluate();
209 EXPECT_EQ(result_1[2], 4);
210 EXPECT_EQ(result_1[4], 8);
211 EXPECT_EQ(result_1[6], 12);
212 EXPECT_EQ(result_1[8], 16);
213 EXPECT_EQ(result_2[2], 14);
214 EXPECT_EQ(result_2[4], 18);
215 EXPECT_EQ(result_2[6], 22);
216 EXPECT_EQ(result_2[8], 26);
217}
218
219TEST_F(FieldTest, TwoFunctionsTwoOutputs)
220{
222
223 FieldOperationPtr fn = FieldOperation::from(std::make_unique<TwoOutputFunction>(),
224 {index_field, index_field});
225
226 Array<int64_t> mask_indices = {2, 4, 6, 8};
227 IndexMaskMemory memory;
228 IndexMask mask = IndexMask::from_indices<int64_t>(mask_indices, memory);
229
230 Field<int> result_field_1{fn, 0};
231 Field<int> intermediate_field{fn, 1};
232
233 auto add_10_fn = mf::build::SI1_SO<int, int>("add_10", [](int a) { return a + 10; });
234 Field<int> result_field_2{FieldOperation::from(add_10_fn, {intermediate_field}), 0};
235
236 FieldContext field_context;
237 FieldEvaluator field_evaluator{field_context, &mask};
238 VArray<int> result_1;
239 VArray<int> result_2;
240 field_evaluator.add(result_field_1, &result_1);
241 field_evaluator.add(result_field_2, &result_2);
242 field_evaluator.evaluate();
243
244 EXPECT_EQ(result_1.get(2), 4);
245 EXPECT_EQ(result_1.get(4), 8);
246 EXPECT_EQ(result_1.get(6), 12);
247 EXPECT_EQ(result_1.get(8), 16);
248 EXPECT_EQ(result_2.get(2), 24);
249 EXPECT_EQ(result_2.get(4), 28);
250 EXPECT_EQ(result_2.get(6), 32);
251 EXPECT_EQ(result_2.get(8), 36);
252}
253
254TEST_F(FieldTest, SameFieldTwice)
255{
256 GField constant_field{FieldOperation::from(std::make_unique<mf::CustomMF_Constant<int>>(10), {}),
257 0};
258
259 FieldContext field_context;
261 ResourceScope scope;
263 scope, {constant_field, constant_field}, mask, field_context);
264
265 VArray<int> varray1 = results[0].typed<int>();
266 VArray<int> varray2 = results[1].typed<int>();
267
268 EXPECT_EQ(varray1.get(0), 10);
269 EXPECT_EQ(varray1.get(1), 10);
270 EXPECT_EQ(varray2.get(0), 10);
271 EXPECT_EQ(varray2.get(1), 10);
272}
273
274TEST_F(FieldTest, IgnoredOutput)
275{
276 static mf::tests::OptionalOutputsFunction fn;
277 Field<int> field{FieldOperation::from(fn, {}), 0};
278
279 FieldContext field_context;
280 FieldEvaluator field_evaluator{field_context, 10};
281 VArray<int> results;
282 field_evaluator.add(field, &results);
283 field_evaluator.evaluate();
284
285 EXPECT_EQ(results.get(0), 5);
286 EXPECT_EQ(results.get(3), 5);
287}
288
289TEST_F(FieldTest, EvaluateWithVArrayPtr)
290{
291 VArray<int> dst_a;
292 VArraySpan<int> dst_b;
293
294 FieldContext field_context;
295 FieldEvaluator field_evaluator{field_context, 2};
296 field_evaluator.add(Field<int>(10), &dst_a);
297 field_evaluator.add(Field<int>(20), &dst_b);
298 field_evaluator.evaluate();
299
300 EXPECT_EQ(dst_a.size(), 2);
301 EXPECT_EQ(dst_b.size(), 2);
302 EXPECT_EQ(dst_a[0], 10);
303 EXPECT_EQ(dst_a[1], 10);
304 EXPECT_EQ(dst_b[0], 20);
305 EXPECT_EQ(dst_b[1], 20);
306}
307
308} // namespace blender::fn::tests
#define final(a, b, c)
Definition BLI_hash_c.hh:21
MutableSpan< T > as_mutable_span()
Definition BLI_array.hh:259
static IndexMask from_indices(Span< T > indices, LinearAllocator<> &memory)
constexpr IndexRange()=default
T get(const int64_t index) const
static VArray from_func(const int64_t size, GetFunc get_func)
constexpr int64_t size() const
int add(GField field, GVArray *varray_ptr)
int add_with_destination(GField field, GVMutableArray dst)
FieldInput(const CPPType &type, std::string debug_name="")
Definition field.cc:19
static FieldOperationPtr from(std::shared_ptr< const mf::MultiFunction > fn, Vector< GField > inputs)
Definition field.cc:252
static GField from_input(Args &&...args)
Definition FN_field.hh:482
void set_signature(const Signature *signature)
GVArray get_varray_for_context(const FieldContext &, const IndexMask &mask, ResourceScope &) const final
void call(const IndexMask &mask, mf::Params params, mf::Context) const override
TEST_F(FieldTest, ConstantFunction)
ImplicitSharingPtr< FieldOperation > FieldOperationPtr
Definition FN_field.hh:44
ImplicitSharingPtr< FieldInput > FieldInputPtr
Definition FN_field.hh:43
Vector< GVArray > evaluate_fields(ResourceScope &scope, Span< GFieldRef > fields_to_evaluate, const IndexMask &mask, const FieldContext &context, Span< GVMutableArray > dst_varrays={})
__int64 int64_t
Definition BKE_text.h:90
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)