46template<
typename T>
class Field;
89 std::is_trivially_copyable_v<T> &&
111 std::variant<Input, MultiFn, FieldRef, ConstantRef, TrivialInlineConstant, OwnedConstant>;
144 template<typename InputT, typename... Args> static
GField from_input(Args &&...args);
175 template<typename InputT> const InputT *
get_input_if() const;
231 operator const GField &()
const;
260 using Variant = std::variant<Value, Input, MultiFn>;
311 return this->cache.
lookup(field);
393 std::shared_ptr<const mf::MultiFunction> owned_fn_;
394 const mf::MultiFunction *fn_;
418 void delete_input_fields();
451 : variant_(
ConstantRef{&type, type.default_value()})
484 FieldInputPtr input{MEM_new<InputT>(__func__, std::forward<Args>(args)...)};
489template<
typename InputT,
typename... Args>
501 constant.
type = &type;
502 new (constant.
value.ptr())
T(std::move(value));
506 T *new_value = MEM_new<T>(__func__, std::move(new_value));
515 return field_.depends_on_input();
521 []<
typename T>(
const T &
v) ->
const CPPType & {
522 if constexpr (std::is_same_v<T, Input>) {
523 return v.node->cpp_type();
525 else if constexpr (std::is_same_v<T, MultiFn>) {
526 return v.node->output_cpp_type(
v.output_i);
528 else if constexpr (std::is_same_v<T, FieldRef>) {
529 return v.field_ref->cpp_type();
543 if (
const auto *field_ref = std::get_if<FieldRef>(&this->variant_)) {
544 return field_ref->field_ref->deref_field_ref();
551 return static_cast<const GField &
>(a) ==
static_cast<const GField &
>(
b);
556 return field_.hash();
566 return field_inputs_;
588 return reinterpret_cast<const Field<T> &
>(*this);
595 return reinterpret_cast<Field<T> &
>(*this);
610 : field_(GField(std::move(
node), output_i))
620 return !inputs->inputs.is_empty();
626 if (
const auto *input = std::get_if<Input>(&deref_field.
variant())) {
627 return dynamic_cast<const InputT *
>(input->node.get());
635 []<
typename T>(
const T &
v) ->
const void * {
639 else if constexpr (std::is_same_v<T, FieldRef>) {
640 return v.field_ref->get_if_constant();
651 return field_.get_input_if<InputT>();
662 : variant_(
MultiFn{&field_multi_fn, output_i})
686 []<
typename T>(
const T &
v) ->
const CPPType & {
687 if constexpr (std::is_same_v<T, Value>) {
690 else if constexpr (std::is_same_v<T, Input>) {
691 return v.node->cpp_type();
693 else if constexpr (std::is_same_v<T, MultiFn>) {
694 return v.node->output_cpp_type(
v.output_i);
#define BLI_assert_unreachable_static_t(T)
static const CPPType & get()
const Value & lookup(const Key &key) const
bool contains(const Key &key) const
static Field from_non_owning_ref(const Field &field)
bool depends_on_input() const
Field(FieldOperationPtr node, int output_i=0)
Field(FieldInputPtr node)
const InputT * get_input_if() const
virtual GVArray get_varray_for_input(const FieldInput &field_input, const IndexMask &mask, ResourceScope &scope) const
virtual ~FieldContext()=default
static FieldOperationPtr from(std::shared_ptr< const mf::MultiFunction > fn, Vector< GField > inputs)
void delete_self() override
const CPPType & output_cpp_type(int output_i) const
Span< GField > inputs() const
FieldOperation(std::shared_ptr< const mf::MultiFunction > fn, Vector< GField > inputs)
const FieldInputsPtr & field_inputs() const
const mf::MultiFunction & multi_function() const
static Field from_non_owning_ref(const Field &field)
bool depends_on_input() const
const InputT * get_input_if() const
static Field from_input(Args &&...args)
const FieldInputsPtr & field_inputs() const
std::variant< Value, Input, MultiFn > Variant
const CPPType & cpp_type() const
const Variant & variant() const
static GFieldRef from_constant(const CPPType &type, const void *value)
GFieldRef(const GField &field)
bool depends_on_input() const
static GField from_non_owning_ref(const GField &field)
static GField from_input(Args &&...args)
const Field< T > & typed() const
const Variant & variant() const
static GField from_constant(const CPPType &type, const void *value)
static GField from_non_owning_constant(const CPPType &type, const void *value)
static constexpr bool is_constant_value_v
const FieldInputsPtr & field_inputs() const
const InputT * get_input_if() const
const void * get_if_constant() const
FieldOperationPtr try_extract_operation()
std::variant< Input, MultiFn, FieldRef, ConstantRef, TrivialInlineConstant, OwnedConstant > Variant
const CPPType & cpp_type() const
const GField & deref_field_ref() const
ImplicitSharingPtr< FieldOperation > FieldOperationPtr
ImplicitSharingPtr< FieldInputs > FieldInputsPtr
ImplicitSharingPtr< FieldInput > FieldInputPtr
bool operator==(const GField &a, const GField &b)
Field< bool > invert_boolean_field(const Field< bool > &field)
constexpr bool is_field_v
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
unsigned __int64 uint64_t
constexpr bool is_same_any_v
ATTR_WARN_UNUSED_RESULT const BMVert * v
Map< GFieldRef, UniqueHash > cache
bool contains(const GFieldRef &field) const
UniqueHash ensure(const GFieldRef &field)
UniqueHash lookup(const GFieldRef &field) const
const FieldOperation * node
static constexpr int64_t inline_alignment
static constexpr int64_t inline_size
static bool cpp_type_supported(const CPPType &type)
static constexpr bool type_supported_v
AlignedBuffer< inline_size, inline_alignment > value