Blender V5.3
FN_field.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2026 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#pragma once
6
28
29#include "BLI_cache_mutex.hh"
31#include "BLI_vector_set.hh"
32
33#include "FN_multi_function.hh"
34
35namespace blender::fn {
36
37class GField;
38class FieldInput;
39class FieldOperation;
40class FieldInputs;
41class FieldContext;
42
46template<typename T> class Field;
47
55class GField {
56 public:
57 struct Input {
59 };
60
61 struct MultiFn {
63 int output_i = 0;
64 };
65
70 struct FieldRef {
71 const GField *field_ref = nullptr;
72 };
73
74 struct ConstantRef {
75 const CPPType *type = nullptr;
77 const void *value = nullptr;
78 };
79
84 static constexpr int64_t inline_size = 16;
85 static constexpr int64_t inline_alignment = 8;
86
87 template<typename T>
88 static constexpr bool type_supported_v = std::is_trivially_destructible_v<T> &&
89 std::is_trivially_copyable_v<T> &&
90 sizeof(T) <= inline_size &&
91 alignof(T) <= inline_alignment;
92
93 static bool cpp_type_supported(const CPPType &type);
94
95 const CPPType *type = nullptr;
97 };
98
101 const CPPType *type = nullptr;
102 /* This value is owned by the #GField. */
103 void *value = nullptr;
104 };
105
106 template<typename T>
107 static constexpr bool is_constant_value_v =
109
110 using Variant =
111 std::variant<Input, MultiFn, FieldRef, ConstantRef, TrivialInlineConstant, OwnedConstant>;
112
113 private:
114 Variant variant_;
115
116 public:
121 GField() = delete;
123 explicit GField(const CPPType &type) noexcept;
125 explicit GField(FieldInputPtr node) noexcept;
127 explicit GField(FieldOperationPtr node, int output_i = 0) noexcept;
129 explicit GField(Variant variant) noexcept;
130
135 static GField from_non_owning_ref(const GField &field);
136
138 static GField from_constant(const CPPType &type, const void *value);
139
141 static GField from_non_owning_constant(const CPPType &type, const void *value);
142
144 template<typename InputT, typename... Args> static GField from_input(Args &&...args);
145
150 GField(const GField &other);
151 GField(GField &&other) noexcept;
152 GField &operator=(const GField &other);
153 GField &operator=(GField &&other) noexcept;
154 ~GField();
155
157 const CPPType &cpp_type() const;
158
160 const FieldInputsPtr &field_inputs() const;
161
166 const GField &deref_field_ref() const;
167
169 const Variant &variant() const;
170
172 bool depends_on_input() const;
173
175 template<typename InputT> const InputT *get_input_if() const;
176
177 const void *get_if_constant() const;
178
184 friend bool operator==(const GField &a, const GField &b);
185 uint64_t hash() const;
186
191 template<typename T> const Field<T> &typed() const;
192 template<typename T> Field<T> &typed();
193
200};
201
203template<typename T> class Field {
204 public:
205 using base_type = T;
206 using generic_type = GField;
207
208 private:
212 GField field_;
213
214 friend GField;
215
216 public:
222
225 explicit Field(FieldOperationPtr node, int output_i = 0);
226
228 explicit Field(T value);
229
231 operator const GField &() const;
232
234 bool depends_on_input() const;
235 template<typename InputT, typename... Args> static Field from_input(Args &&...args);
236 template<typename InputT> const InputT *get_input_if() const;
237 uint64_t hash() const;
238 static Field from_non_owning_ref(const Field &field);
239};
240
247 public:
248 struct Value {
249 const CPPType *type = nullptr;
250 const void *value = nullptr;
251 };
252 struct Input {
253 const FieldInput *node = nullptr;
254 };
255 struct MultiFn {
256 const FieldOperation *node = nullptr;
257 int output_i = 0;
258 };
259
260 using Variant = std::variant<Value, Input, MultiFn>;
261
262 private:
263 Variant variant_;
264
265 public:
270 GFieldRef(const GField &field);
271 template<typename T> GFieldRef(const Field<T> &field);
272 explicit GFieldRef(const FieldInput &field_input);
273 explicit GFieldRef(const FieldOperation &field_multi_fn, int output_i = 0);
274 explicit GFieldRef(Variant variant);
275
277 const Variant &variant() const;
278
280 const CPPType &cpp_type() const;
281 const FieldInputsPtr &field_inputs() const;
282 uint64_t hash() const;
283
284 static GFieldRef from_constant(const CPPType &type, const void *value);
285};
286
292 public:
293 virtual ~FieldContext() = default;
294
295 virtual GVArray get_varray_for_input(const FieldInput &field_input,
296 const IndexMask &mask,
297 ResourceScope &scope) const;
298};
299
308 UniqueHash ensure(const GFieldRef &field);
309 UniqueHash lookup(const GFieldRef &field) const
310 {
311 return this->cache.lookup(field);
312 }
313 bool contains(const GFieldRef &field) const
314 {
315 return this->cache.contains(field);
316 }
317};
318
331
340 protected:
342 std::string debug_name_;
343
350
351 public:
352 FieldInput(const CPPType &type, std::string debug_name = "");
353 ~FieldInput() override;
354
356 virtual std::string socket_inspection_name() const;
357
358 const CPPType &cpp_type() const;
359
360 const FieldInputsPtr &field_inputs() const;
361
362 uint64_t hash() const;
363 virtual void hash_unique(UniqueHashBytes &hash, FieldHashDeep &deep_hash_cache) const;
364
368 virtual void foreach_recursive_field(FunctionRef<void(const GField &)> fn) const;
369
374 const IndexMask &mask,
375 ResourceScope &scope) const = 0;
376
377 void delete_self() override;
378};
379
388 private:
390 Vector<GField> inputs_;
391
393 std::shared_ptr<const mf::MultiFunction> owned_fn_;
394 const mf::MultiFunction *fn_;
395
397 FieldInputsPtr field_inputs_;
398
399 public:
401 FieldOperation(std::shared_ptr<const mf::MultiFunction> fn, Vector<GField> inputs);
402 FieldOperation(const mf::MultiFunction &fn, Vector<GField> inputs);
403
404 static FieldOperationPtr from(std::shared_ptr<const mf::MultiFunction> fn,
406 static FieldOperationPtr from(const mf::MultiFunction &fn, Vector<GField> inputs);
407
409 const CPPType &output_cpp_type(int output_i) const;
410
411 const mf::MultiFunction &multi_function() const;
412 const FieldInputsPtr &field_inputs() const;
413 Span<GField> inputs() const;
414
415 void delete_self() override;
416
417 private:
418 void delete_input_fields();
419};
420
421bool operator==(const GField &a, const GField &b);
422bool operator==(const GFieldRef &a, const GFieldRef &b);
423
425template<typename T> constexpr bool is_field_v = false;
426template<typename T> constexpr bool is_field_v<Field<T>> = true;
427
429
431 public:
433
434 static GVArray get_index_varray(const IndexMask &mask);
435
437 const IndexMask &mask,
438 ResourceScope &scope) const final;
439
440 void hash_unique(UniqueHashBytes &hash, FieldHashDeep &deep_hash_cache) const override;
441
443 static const Field<int> &get_field();
444};
445
446/* -------------------------------------------------------------------- */
449
450inline GField::GField(const CPPType &type) noexcept
451 : variant_(ConstantRef{&type, type.default_value()})
452{
453}
454inline GField::GField(FieldInputPtr node) noexcept : variant_(Input{std::move(node)}) {}
455inline GField::GField(Variant variant) noexcept : variant_(std::move(variant)) {}
456inline GField::GField(FieldOperationPtr node, const int output_i) noexcept
457 : variant_(MultiFn{std::move(node), output_i})
458{
459}
460
462{
463 return GField(FieldRef{&field});
464}
465
471
472inline GField GField::from_non_owning_constant(const CPPType &type, const void *value)
473{
474 return GField(ConstantRef{&type, value});
475}
476
477template<typename T> inline Field<T> Field<T>::from_non_owning_ref(const Field &field)
478{
479 return GField::from_non_owning_ref(field).template typed<T>();
480}
481
482template<typename InputT, typename... Args> inline GField GField::from_input(Args &&...args)
483{
484 FieldInputPtr input{MEM_new<InputT>(__func__, std::forward<Args>(args)...)};
485 return GField(Input{std::move(input)});
486}
487
488template<typename T>
489template<typename InputT, typename... Args>
490inline Field<T> Field<T>::from_input(Args &&...args)
491{
492 return GField::from_input<InputT>(std::forward<Args>(args)...).template typed<T>();
493}
494
495template<typename T>
496inline Field<T>::Field(T value)
497 : field_([&]() {
498 const CPPType &type = CPPType::get<T>();
501 constant.type = &type;
502 new (constant.value.ptr()) T(std::move(value));
503 return GField(constant);
504 }
505 else {
506 T *new_value = MEM_new<T>(__func__, std::move(new_value));
507 return GField(GField::OwnedConstant{&type, new_value});
508 }
509 }())
510{
511}
512
513template<typename T> inline bool Field<T>::depends_on_input() const
514{
515 return field_.depends_on_input();
516}
517
518inline const CPPType &GField::cpp_type() const
519{
520 return std::visit(
521 []<typename T>(const T &v) -> const CPPType & {
522 if constexpr (std::is_same_v<T, Input>) {
523 return v.node->cpp_type();
524 }
525 else if constexpr (std::is_same_v<T, MultiFn>) {
526 return v.node->output_cpp_type(v.output_i);
527 }
528 else if constexpr (std::is_same_v<T, FieldRef>) {
529 return v.field_ref->cpp_type();
530 }
532 return *v.type;
533 }
534 else {
536 }
537 },
538 this->variant_);
539}
540
541inline const GField &GField::deref_field_ref() const
542{
543 if (const auto *field_ref = std::get_if<FieldRef>(&this->variant_)) {
544 return field_ref->field_ref->deref_field_ref();
545 }
546 return *this;
547}
548
549template<typename T> inline bool operator==(const Field<T> &a, const Field<T> &b)
550{
551 return static_cast<const GField &>(a) == static_cast<const GField &>(b);
552}
553
554template<typename T> inline uint64_t Field<T>::hash() const
555{
556 return field_.hash();
557}
558
559inline const CPPType &FieldInput::cpp_type() const
560{
561 return *this->type_;
562}
563
565{
566 return field_inputs_;
567}
568
570{
571 return debug_name_;
572}
573
574inline std::string FieldInput::socket_inspection_name() const
575{
576 return debug_name_;
577}
578
579template<typename T> inline Field<T>::operator const GField &() const
580{
581 return field_;
582}
583
584template<typename T> inline const Field<T> &GField::typed() const
585{
586 static_assert(sizeof(GField) == sizeof(Field<T>));
587 BLI_assert(this->cpp_type().is<T>());
588 return reinterpret_cast<const Field<T> &>(*this);
589}
590
591template<typename T> inline Field<T> &GField::typed()
592{
593 static_assert(sizeof(GField) == sizeof(Field<T>));
594 BLI_assert(this->cpp_type().is<T>());
595 return reinterpret_cast<Field<T> &>(*this);
596}
597
598inline const GField::Variant &GField::variant() const
599{
600 return variant_;
601}
602
603template<typename T> inline Field<T>::Field() : field_(CPPType::get<T>()) {}
604
605template<typename T> inline Field<T>::Field(FieldInputPtr node) : field_(GField(std::move(node)))
606{
607}
608template<typename T>
609inline Field<T>::Field(FieldOperationPtr node, const int output_i)
610 : field_(GField(std::move(node), output_i))
611{
612}
613
614inline bool GField::depends_on_input() const
615{
616 const FieldInputsPtr &inputs = this->field_inputs();
617 if (!inputs) {
618 return false;
619 }
620 return !inputs->inputs.is_empty();
621}
622
623template<typename InputT> inline const InputT *GField::get_input_if() const
624{
625 const GField &deref_field = this->deref_field_ref();
626 if (const auto *input = std::get_if<Input>(&deref_field.variant())) {
627 return dynamic_cast<const InputT *>(input->node.get());
628 }
629 return nullptr;
630}
631
632inline const void *GField::get_if_constant() const
633{
634 return std::visit(
635 []<typename T>(const T &v) -> const void * {
636 if constexpr (is_same_any_v<T, Input, MultiFn>) {
637 return nullptr;
638 }
639 else if constexpr (std::is_same_v<T, FieldRef>) {
640 return v.field_ref->get_if_constant();
641 }
642 else {
643 return v.value;
644 }
645 },
646 variant_);
647}
648
649template<typename T> template<typename InputT> inline const InputT *Field<T>::get_input_if() const
650{
651 return field_.get_input_if<InputT>();
652}
653
655{
656 return inputs_;
657}
658
659inline GFieldRef::GFieldRef(const FieldInput &field_input) : variant_(Input{&field_input}) {}
660
661inline GFieldRef::GFieldRef(const FieldOperation &field_multi_fn, int output_i)
662 : variant_(MultiFn{&field_multi_fn, output_i})
663{
664}
665
666inline GFieldRef::GFieldRef(Variant variant) : variant_(std::move(variant)) {}
667
668inline GFieldRef GFieldRef::from_constant(const CPPType &type, const void *value)
669{
670 return GFieldRef(Value{&type, value});
671}
672
673template<typename T>
674inline GFieldRef::GFieldRef(const Field<T> &field) : GFieldRef(static_cast<const GField &>(field))
675{
676}
677
679{
680 return variant_;
681}
682
683inline const CPPType &GFieldRef::cpp_type() const
684{
685 return std::visit(
686 []<typename T>(const T &v) -> const CPPType & {
687 if constexpr (std::is_same_v<T, Value>) {
688 return *v.type;
689 }
690 else if constexpr (std::is_same_v<T, Input>) {
691 return v.node->cpp_type();
692 }
693 else if constexpr (std::is_same_v<T, MultiFn>) {
694 return v.node->output_cpp_type(v.output_i);
695 }
696 else {
698 }
699 },
700 variant_);
701}
702
703inline bool operator==(const FieldInput &a, const FieldInput &b)
704{
705 return &a == &b;
706}
707
708inline const mf::MultiFunction &FieldOperation::multi_function() const
709{
710 return *this->fn_;
711}
712
714
715} // namespace blender::fn
#define final(a, b, c)
Definition BLI_hash_c.hh:21
#define BLI_assert_unreachable_static_t(T)
static const CPPType & get()
const Value & lookup(const Key &key) const
Definition BLI_map.hh:545
bool contains(const Key &key) const
Definition BLI_map.hh:353
static Field from_non_owning_ref(const Field &field)
Definition FN_field.hh:477
bool depends_on_input() const
Definition FN_field.hh:513
Field(FieldOperationPtr node, int output_i=0)
Definition FN_field.hh:609
uint64_t hash() const
Definition FN_field.hh:554
Field(FieldInputPtr node)
Definition FN_field.hh:605
const InputT * get_input_if() const
Definition FN_field.hh:649
virtual GVArray get_varray_for_input(const FieldInput &field_input, const IndexMask &mask, ResourceScope &scope) const
Definition field.cc:525
virtual ~FieldContext()=default
FieldInput(const CPPType &type, std::string debug_name="")
Definition field.cc:19
std::string debug_name_
Definition FN_field.hh:342
StringRefNull debug_name() const
Definition FN_field.hh:569
FieldInputsPtr field_inputs_
Definition FN_field.hh:349
virtual void hash_unique(UniqueHashBytes &hash, FieldHashDeep &deep_hash_cache) const
Definition field.cc:197
const FieldInputsPtr & field_inputs() const
Definition field.cc:175
void delete_self() override
Definition field.cc:211
uint64_t hash() const
Definition field.cc:185
virtual void foreach_recursive_field(FunctionRef< void(const GField &)> fn) const
Definition field.cc:195
CacheMutex field_inputs_mutex_
Definition FN_field.hh:348
const CPPType * type_
Definition FN_field.hh:341
const CPPType & cpp_type() const
Definition FN_field.hh:559
virtual GVArray get_varray_for_context(const FieldContext &context, const IndexMask &mask, ResourceScope &scope) const =0
virtual std::string socket_inspection_name() const
Definition FN_field.hh:574
void delete_self() override
Definition field.cc:247
VectorSet< std::reference_wrapper< const FieldInput > > inputs
Definition FN_field.hh:327
static FieldOperationPtr from(std::shared_ptr< const mf::MultiFunction > fn, Vector< GField > inputs)
Definition field.cc:252
void delete_self() override
Definition field.cc:216
const CPPType & output_cpp_type(int output_i) const
Definition field.cc:488
Span< GField > inputs() const
Definition FN_field.hh:654
FieldOperation(std::shared_ptr< const mf::MultiFunction > fn, Vector< GField > inputs)
Definition field.cc:476
const FieldInputsPtr & field_inputs() const
Definition FN_field.hh:564
const mf::MultiFunction & multi_function() const
Definition FN_field.hh:708
static Field from_non_owning_ref(const Field &field)
Definition FN_field.hh:477
bool depends_on_input() const
Definition FN_field.hh:513
uint64_t hash() const
Definition FN_field.hh:554
const InputT * get_input_if() const
Definition FN_field.hh:649
static Field from_input(Args &&...args)
const FieldInputsPtr & field_inputs() const
Definition field.cc:398
std::variant< Value, Input, MultiFn > Variant
Definition FN_field.hh:260
uint64_t hash() const
Definition field.cc:456
const CPPType & cpp_type() const
Definition FN_field.hh:683
const Variant & variant() const
Definition FN_field.hh:678
static GFieldRef from_constant(const CPPType &type, const void *value)
Definition FN_field.hh:668
GFieldRef(const GField &field)
Definition field.cc:373
bool depends_on_input() const
Definition FN_field.hh:614
static GField from_non_owning_ref(const GField &field)
Definition FN_field.hh:461
static GField from_input(Args &&...args)
Definition FN_field.hh:482
const Field< T > & typed() const
Definition FN_field.hh:584
const Variant & variant() const
Definition FN_field.hh:598
static GField from_constant(const CPPType &type, const void *value)
Definition field.cc:24
static GField from_non_owning_constant(const CPPType &type, const void *value)
Definition FN_field.hh:472
static constexpr bool is_constant_value_v
Definition FN_field.hh:107
uint64_t hash() const
Definition field.cc:87
const FieldInputsPtr & field_inputs() const
Definition field.cc:504
const InputT * get_input_if() const
Definition FN_field.hh:623
const void * get_if_constant() const
Definition FN_field.hh:632
FieldOperationPtr try_extract_operation()
Definition field.cc:202
std::variant< Input, MultiFn, FieldRef, ConstantRef, TrivialInlineConstant, OwnedConstant > Variant
Definition FN_field.hh:110
const CPPType & cpp_type() const
Definition FN_field.hh:518
const GField & deref_field_ref() const
Definition FN_field.hh:541
static GVArray get_index_varray(const IndexMask &mask)
Definition field.cc:536
GVArray get_varray_for_context(const FieldContext &context, const IndexMask &mask, ResourceScope &scope) const final
Definition field.cc:542
static const Field< int > & get_field()
Definition field.cc:557
void hash_unique(UniqueHashBytes &hash, FieldHashDeep &deep_hash_cache) const override
Definition field.cc:550
#define T
ImplicitSharingPtr< FieldOperation > FieldOperationPtr
Definition FN_field.hh:44
ImplicitSharingPtr< FieldInputs > FieldInputsPtr
Definition FN_field.hh:45
ImplicitSharingPtr< FieldInput > FieldInputPtr
Definition FN_field.hh:43
bool operator==(const GField &a, const GField &b)
Definition field.cc:37
Field< bool > invert_boolean_field(const Field< bool > &field)
Definition field.cc:564
constexpr bool is_field_v
Definition FN_field.hh:425
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
unsigned __int64 uint64_t
Definition BKE_text.h:91
__int64 int64_t
Definition BKE_text.h:90
constexpr bool is_same_any_v
ATTR_WARN_UNUSED_RESULT const BMVert * v
Map< GFieldRef, UniqueHash > cache
Definition FN_field.hh:307
bool contains(const GFieldRef &field) const
Definition FN_field.hh:313
UniqueHash ensure(const GFieldRef &field)
Definition field.cc:113
UniqueHash lookup(const GFieldRef &field) const
Definition FN_field.hh:309
const FieldInput * node
Definition FN_field.hh:253
const FieldOperation * node
Definition FN_field.hh:256
FieldOperationPtr node
Definition FN_field.hh:62
static constexpr int64_t inline_alignment
Definition FN_field.hh:85
static constexpr int64_t inline_size
Definition FN_field.hh:84
static bool cpp_type_supported(const CPPType &type)
Definition FN_field.hh:466
AlignedBuffer< inline_size, inline_alignment > value
Definition FN_field.hh:96