28 constant.
type = &type;
40 const GField &b_ref =
b.deref_field_ref();
43 [&]<
typename T>(
const T &v_a) ->
bool {
44 if constexpr (std::is_same_v<T, GField::Input>) {
45 if (
const auto *v_b = std::get_if<GField::Input>(&b_ref.variant_)) {
46 return v_a.node == v_b->node;
50 else if constexpr (std::is_same_v<T, GField::MultiFn>) {
51 if (
const auto *v_b = std::get_if<GField::MultiFn>(&b_ref.variant_)) {
52 return v_a.node == v_b->node && v_a.output_i == v_b->output_i;
56 else if constexpr (std::is_same_v<T, GField::FieldRef>) {
62 const CPPType &type_a = *v_a.type;
63 const void *constant_a = v_a.value;
65 [&]<
typename U>(
const U &v_b) ->
bool {
67 const CPPType &type_b = *v_b.type;
68 if (type_a != type_b) {
71 const void *constant_b = v_b.value;
92 if constexpr (std::is_same_v<T, Input>) {
95 else if constexpr (std::is_same_v<T, MultiFn>) {
98 else if constexpr (std::is_same_v<T, FieldRef>) {
104 return v.type->hash_or_fallback(
v.value,
uint64_t(
v.type));
129 if (this->
cache.contains(current)) {
135 [&]<
typename T>(
const T &
v) {
136 if constexpr (std::is_same_v<T, GFieldRef::Value>) {
137 v.type->hash_unique(
v.value, hash_context);
138 hash_context.
add(
v.type);
140 else if constexpr (std::is_same_v<T, GFieldRef::Input>) {
141 v.node->hash_unique(hash_context, *
this);
143 else if constexpr (std::is_same_v<T, GFieldRef::MultiFn>) {
144 v.node->multi_function().hash_unique(hash_context);
145 hash_context.
add(
v.output_i);
146 for (
const GField &input_field :
v.node->inputs()) {
147 hash_context.
add(this->
cache.lookup(input_field));
155 const Span bytes = hash_context.
data.as_span();
157 const XXH128_hash_t xxhash = XXH3_128bits(bytes.
data(), bytes.
size());
158 static_assert(
sizeof(
UniqueHash) ==
sizeof(xxhash));
159 memcpy(
static_cast<void *
>(&
hash), &xxhash,
sizeof(xxhash));
163 visited.
add(current);
165 if (
const auto *multi_fn = std::get_if<GFieldRef::MultiFn>(¤t.
variant())) {
166 for (
const GField &input : multi_fn->node->inputs()) {
172 return this->
cache.lookup(field);
178 FieldInputs *inputs = MEM_new<FieldInputs>(
"field_inputs");
179 inputs->
inputs.add(*
this);
204 MultiFn *multi_fn = std::get_if<MultiFn>(&variant_);
205 if (!multi_fn || !multi_fn->
node) {
208 return std::move(multi_fn->
node);
218 this->delete_input_fields();
222void FieldOperation::delete_input_fields()
228 for (
GField &input : inputs_) {
230 remaining.
append(std::move(input_op));
235 if (!op->is_mutable()) {
239 for (GField &input : op_ref.inputs_) {
241 remaining.
append(std::move(input_op));
269 bool candidate_valid =
true;
271 for (
const GField &field : fields) {
273 if (!field_inputs_ptr) {
277 candidate = &field_inputs_ptr;
280 if (field_inputs_ptr == *candidate) {
285 if ((*smaller_candidate)->inputs.size() > (*larger_candidate)->inputs.size()) {
286 std::swap(smaller_candidate, larger_candidate);
289 for (
const FieldInput &field_input : (*smaller_candidate)->inputs) {
290 if (!(*larger_candidate)->inputs.contains(field_input)) {
291 candidate_valid =
false;
295 if (!candidate_valid) {
298 candidate = larger_candidate;
300 if (candidate_valid) {
308 FieldInputs *new_field_inputs = MEM_new<FieldInputs>(__func__);
309 for (
const GField &field : fields) {
311 if (!field_inputs_ptr) {
315 new_field_inputs->
inputs.add(field_input);
324 [&]<
typename T>(
T &
v) {
325 if constexpr (std::is_same_v<T, OwnedConstant>) {
327 v.type->size,
v.type->alignment,
"GField::GField()");
328 v.type->copy_construct(
v.value, new_value);
343 if (
this == &other) {
353 if (
this == &other) {
357 new (
this)
GField(std::move(other));
364 [&]<
typename T>(
T &
v) {
365 if constexpr (std::is_same_v<T, OwnedConstant>) {
366 v.type->destruct(
v.value);
374 : variant_(std::visit(
377 return Input{
v.node.get()};
379 else if constexpr (std::is_same_v<T, GField::MultiFn>) {
380 return MultiFn{
v.node.get(),
v.output_i};
382 else if constexpr (std::is_same_v<T, GField::FieldRef>) {
394 field.deref_field_ref().variant()))
403 if constexpr (std::is_same_v<T, Input>) {
404 return v.node->field_inputs();
406 else if constexpr (std::is_same_v<T, MultiFn>) {
407 return v.node->field_inputs();
409 else if constexpr (std::is_same_v<T, Value>) {
422 [&]<
typename T>(
const T &v_a) ->
bool {
423 if constexpr (std::is_same_v<T, GFieldRef::Value>) {
424 if (
const auto *v_b = std::get_if<GFieldRef::Value>(&
b.variant())) {
425 if (v_a.type != v_b->type) {
428 if (v_a.value == v_b->value) {
433 return v_a.type->is_equal_or_false(v_a.value, v_b->value);
437 else if constexpr (std::is_same_v<T, GFieldRef::Input>) {
438 if (
const auto *v_b = std::get_if<GFieldRef::Input>(&
b.variant())) {
439 return v_a.node == v_b->node;
443 else if constexpr (std::is_same_v<T, GFieldRef::MultiFn>) {
444 if (
const auto *v_b = std::get_if<GFieldRef::MultiFn>(&
b.variant())) {
445 return v_a.node == v_b->node && v_a.output_i == v_b->output_i;
460 if constexpr (std::is_same_v<T, Value>) {
461 return v.type->hash_or_fallback(
v.value,
uint64_t(
v.type));
463 else if constexpr (std::is_same_v<T, Input>) {
466 else if constexpr (std::is_same_v<T, MultiFn>) {
479 owned_fn_ = std::move(
fn);
491 for (
const int param_index : fn_->param_indices()) {
492 const mf::ParamType param_type = fn_->param_type(param_index);
493 if (param_type.is_output()) {
494 if (count == output_i) {
495 return param_type.data_type().single_type();
510 return v.node->field_inputs();
512 else if constexpr (std::is_same_v<T, FieldRef>) {
513 return v.field_ref->field_inputs();
538 auto index_func = [](
int i) {
return i; };
553 static constexpr int8_t id = 0;
568 return GField(not_op, 0).typed<
bool>();
#define BLI_assert_unreachable()
#define BLI_assert_unreachable_static_t(T)
static const CPPType & get()
bool is_equal_or_false(const void *a, const void *b) const
void copy_construct(const void *src, void *dst) const
const void * default_value() const
void ensure(const FunctionRef< void()> compute_cache)
bool contains(const Key &key) const
constexpr const T * data() const
constexpr int64_t size() const
void push(const T &value)
static VArray from_func(const int64_t size, GetFunc get_func)
void append(const T &value)
virtual GVArray get_varray_for_input(const FieldInput &field_input, const IndexMask &mask, ResourceScope &scope) const
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)
static Field from_non_owning_ref(const Field &field)
static Field from_input(Args &&...args)
const FieldInputsPtr & field_inputs() const
std::variant< Value, Input, MultiFn > Variant
const Variant & variant() const
GFieldRef(const GField &field)
static GField from_constant(const CPPType &type, const void *value)
static constexpr bool is_constant_value_v
friend bool operator==(const GField &a, const GField &b)
const FieldInputsPtr & field_inputs() const
GField & operator=(const GField &other)
FieldOperationPtr try_extract_operation()
const CPPType & cpp_type() const
const GField & deref_field_ref() const
const MultiFunction & lookup(UString id)
ImplicitSharingPtr< FieldOperation > FieldOperationPtr
ImplicitSharingPtr< FieldInputs > FieldInputsPtr
static FieldInputsPtr combine_field_inputs(const Span< GField > &fields)
bool operator==(const GField &a, const GField &b)
Field< bool > invert_boolean_field(const Field< bool > &field)
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
void MEM_delete_void(void *vmemh)
void * MEM_new_uninitialized_aligned(size_t len, size_t alignment, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(3)
constexpr uint64_t get_default_hash(const T &v, const Args &...args)
Vector< std::byte, 256 > data
Map< GFieldRef, UniqueHash > cache
UniqueHash ensure(const GFieldRef &field)
static bool cpp_type_supported(const CPPType &type)
AlignedBuffer< inline_size, inline_alignment > value