FN_field.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "BLI_function_ref.hh"
#include "BLI_generic_virtual_array.hh"
#include "BLI_string_ref.hh"
#include "BLI_vector.hh"
#include "BLI_vector_set.hh"
 
#include "FN_multi_function.hh"
 
namespace blender::fn {
 
class FieldInput;
struct FieldInputs;
 
enum class FieldNodeType {
  Input,
  Operation,
  Constant,
};
 
class FieldNode {
 private:
  FieldNodeType node_type_;
 
 protected:
  std::shared_ptr<const FieldInputs> field_inputs_;
 
 public:
  FieldNode(FieldNodeType node_type);
  virtual ~FieldNode();
 
  virtual const CPPType &output_cpp_type(int output_index) const = 0;
 
  FieldNodeType node_type() const;
  bool depends_on_input() const;
 
  const std::shared_ptr<const FieldInputs> &field_inputs() const;
 
  virtual uint64_t hash() const;
  virtual bool is_equal_to(const FieldNode &other) const;
 
  virtual void for_each_field_input_recursive(FunctionRef<void(const FieldInput &)> fn) const;
};
 
template<typename NodePtr> class GFieldBase {
 protected:
  NodePtr node_ = nullptr;
  int node_output_index_ = 0;
 
  GFieldBase(NodePtr node, const int node_output_index)
      : node_(std::move(node)), node_output_index_(node_output_index)
  {
  }
 
 public:
  GFieldBase() = default;
 
  operator bool() const
  {
    return node_ != nullptr;
  }
 
  friend bool operator==(const GFieldBase &a, const GFieldBase &b)
  {
    /* Two nodes can compare equal even when their pointer is not the same. For example, two
     * "Position" nodes are the same. */
    return *a.node_ == *b.node_ && a.node_output_index_ == b.node_output_index_;
  }
 
  uint64_t hash() const
  {
    return get_default_hash(*node_, node_output_index_);
  }
 
  const CPPType &cpp_type() const
  {
    return node_->output_cpp_type(node_output_index_);
  }
 
  const FieldNode &node() const
  {
    return *node_;
  }
 
  int node_output_index() const
  {
    return node_output_index_;
  }
};
 
class GField : public GFieldBase<std::shared_ptr<FieldNode>> {
 public:
  GField() = default;
 
  GField(std::shared_ptr<FieldNode> node, const int node_output_index = 0)
      : GFieldBase<std::shared_ptr<FieldNode>>(std::move(node), node_output_index)
  {
  }
};
 
class GFieldRef : public GFieldBase<const FieldNode *> {
 public:
  GFieldRef() = default;
 
  GFieldRef(const GField &field)
      : GFieldBase<const FieldNode *>(&field.node(), field.node_output_index())
  {
  }
 
  GFieldRef(const FieldNode &node, const int node_output_index = 0)
      : GFieldBase<const FieldNode *>(&node, node_output_index)
  {
  }
};
 
namespace detail {
/* Utility class to make #is_field_v work. */
struct TypedFieldBase {};
}  // namespace detail
 
template<typename T> class Field : public GField, detail::TypedFieldBase {
 public:
  using base_type = T;
 
  Field() = default;
 
  Field(GField field) : GField(std::move(field))
  {
    BLI_assert(this->cpp_type().template is<T>());
  }
 
  template<typename U> Field(Field<U> field) : GField(std::move(field))
  {
    static_assert(std::is_same_v<T, U>);
  }
 
  Field(std::shared_ptr<FieldNode> node, const int node_output_index = 0)
      : Field(GField(std::move(node), node_output_index))
  {
  }
};
 
template<typename T>
static constexpr bool is_field_v = std::is_base_of_v<detail::TypedFieldBase, T> &&
                                   !std::is_same_v<detail::TypedFieldBase, T>;
 
class FieldOperation : public FieldNode {
  std::shared_ptr<const mf::MultiFunction> owned_function_;
  const mf::MultiFunction *function_;
 
  blender::Vector<GField> inputs_;
 
 public:
  FieldOperation(std::shared_ptr<const mf::MultiFunction> function, Vector<GField> inputs = {});
  FieldOperation(const mf::MultiFunction &function, Vector<GField> inputs = {});
  ~FieldOperation() override;
 
  Span<GField> inputs() const;
  const mf::MultiFunction &multi_function() const;
 
  const CPPType &output_cpp_type(int output_index) const override;
 
  static std::shared_ptr<FieldOperation> Create(std::shared_ptr<const mf::MultiFunction> function,
                                                Vector<GField> inputs = {})
  {
    return std::make_shared<FieldOperation>(FieldOperation(std::move(function), inputs));
  }
  static std::shared_ptr<FieldOperation> Create(const mf::MultiFunction &function,
                                                Vector<GField> inputs = {})
  {
    return std::make_shared<FieldOperation>(FieldOperation(function, inputs));
  }
};
 
class FieldContext;
 
class FieldInput : public FieldNode {
 public:
  /* The order is also used for sorting in socket inspection. */
  enum class Category {
    NamedAttribute = 0,
    Generated = 1,
    AnonymousAttribute = 2,
    Unknown,
  };
 
 protected:
  const CPPType *type_;
  std::string debug_name_;
  Category category_ = Category::Unknown;
 
 public:
  FieldInput(const CPPType &type, std::string debug_name = "");
  ~FieldInput() override;
 
  virtual GVArray get_varray_for_context(const FieldContext &context,
                                         const IndexMask &mask,
                                         ResourceScope &scope) const = 0;
 
  virtual std::string socket_inspection_name() const;
  blender::StringRef debug_name() const;
  const CPPType &cpp_type() const;
  Category category() const;
 
  const CPPType &output_cpp_type(int output_index) const override;
};
 
class FieldConstant : public FieldNode {
 private:
  const CPPType &type_;
  void *value_;
 
 public:
  FieldConstant(const CPPType &type, const void *value);
  ~FieldConstant() override;
 
  const CPPType &output_cpp_type(int output_index) const override;
  const CPPType &type() const;
  GPointer value() const;
};
 
struct FieldInputs {
  VectorSet<const FieldInput *> nodes;
  VectorSet<std::reference_wrapper<const FieldInput>> deduplicated_nodes;
};
 
class FieldContext {
 public:
  virtual ~FieldContext() = default;
 
  virtual GVArray get_varray_for_input(const FieldInput &field_input,
                                       const IndexMask &mask,
                                       ResourceScope &scope) const;
};
 
class FieldEvaluator : NonMovable, NonCopyable {
  struct OutputPointerInfo {
    void *dst = nullptr;
    /* When a destination virtual array is provided for an input, this is
     * unnecessary, otherwise this is used to construct the required virtual array. */
    void (*set)(void *dst, const GVArray &varray, ResourceScope &scope) = nullptr;
  };
 
  ResourceScope scope_;
  const FieldContext &context_;
  const IndexMask &mask_;
  Vector<GField> fields_to_evaluate_;
  Vector<GVMutableArray> dst_varrays_;
  Vector<GVArray> evaluated_varrays_;
  Vector<OutputPointerInfo> output_pointer_infos_;
  bool is_evaluated_ = false;
 
  Field<bool> selection_field_;
  IndexMask selection_mask_;
 
 public:
  FieldEvaluator(const FieldContext &context, const IndexMask *mask)
      : context_(context), mask_(*mask)
  {
  }
 
  FieldEvaluator(const FieldContext &context, const int64_t size)
      : context_(context), mask_(scope_.construct<IndexMask>(size))
  {
  }
 
  ~FieldEvaluator()
  {
    /* While this assert isn't strictly necessary, and could be replaced with a warning,
     * it will catch cases where someone forgets to call #evaluate(). */
    BLI_assert(is_evaluated_);
  }
 
  void set_selection(Field<bool> selection)
  {
    selection_field_ = std::move(selection);
  }
 
  int add_with_destination(GField field, GVMutableArray dst);
 
  template<typename T> int add_with_destination(Field<T> field, VMutableArray<T> dst)
  {
    return this->add_with_destination(GField(std::move(field)), GVMutableArray(std::move(dst)));
  }
 
  int add_with_destination(GField field, GMutableSpan dst);
 
  template<typename T> int add_with_destination(Field<T> field, MutableSpan<T> dst)
  {
    return this->add_with_destination(std::move(field), VMutableArray<T>::ForSpan(dst));
  }
 
  int add(GField field, GVArray *varray_ptr);
 
  template<typename T> int add(Field<T> field, VArray<T> *varray_ptr)
  {
    const int field_index = fields_to_evaluate_.append_and_get_index(std::move(field));
    dst_varrays_.append({});
    output_pointer_infos_.append(OutputPointerInfo{
        varray_ptr, [](void *dst, const GVArray &varray, ResourceScope & /*scope*/) {
          *(VArray<T> *)dst = varray.typed<T>();
        }});
    return field_index;
  }
 
  int add(GField field);
 
  void evaluate();
 
  const GVArray &get_evaluated(const int field_index) const
  {
    BLI_assert(is_evaluated_);
    return evaluated_varrays_[field_index];
  }
 
  template<typename T> VArray<T> get_evaluated(const int field_index)
  {
    return this->get_evaluated(field_index).typed<T>();
  }
 
  IndexMask get_evaluated_selection_as_mask() const;
 
  IndexMask get_evaluated_as_mask(int field_index);
};
 
Vector<GVArray> evaluate_fields(ResourceScope &scope,
                                Span<GFieldRef> fields_to_evaluate,
                                const IndexMask &mask,
                                const FieldContext &context,
                                Span<GVMutableArray> dst_varrays = {});
 
/* -------------------------------------------------------------------- */
void evaluate_constant_field(const GField &field, void *r_value);
 
template<typename T> T evaluate_constant_field(const Field<T> &field)
{
  T value;
  value.~T();
  evaluate_constant_field(field, &value);
  return value;
}
 
Field<bool> invert_boolean_field(const Field<bool> &field);
 
GField make_constant_field(const CPPType &type, const void *value);
 
template<typename T> Field<T> make_constant_field(T value)
{
  return make_constant_field(CPPType::get<T>(), &value);
}
 
GField make_field_constant_if_possible(GField field);
 
class IndexFieldInput final : public FieldInput {
 public:
  IndexFieldInput();
 
  static GVArray get_index_varray(const IndexMask &mask);
 
  GVArray get_varray_for_context(const FieldContext &context,
                                 const IndexMask &mask,
                                 ResourceScope &scope) const final;
 
  uint64_t hash() const override;
  bool is_equal_to(const fn::FieldNode &other) const override;
};
 
/* -------------------------------------------------------------------- */
inline FieldNode::FieldNode(const FieldNodeType node_type) : node_type_(node_type) {}
 
inline FieldNodeType FieldNode::node_type() const
{
  return node_type_;
}
 
inline bool FieldNode::depends_on_input() const
{
  return field_inputs_ && !field_inputs_->nodes.is_empty();
}
 
inline const std::shared_ptr<const FieldInputs> &FieldNode::field_inputs() const
{
  return field_inputs_;
}
 
inline uint64_t FieldNode::hash() const
{
  return get_default_hash(this);
}
 
inline bool FieldNode::is_equal_to(const FieldNode &other) const
{
  return this == &other;
}
 
inline bool operator==(const FieldNode &a, const FieldNode &b)
{
  return a.is_equal_to(b);
}
 
inline bool operator!=(const FieldNode &a, const FieldNode &b)
{
  return !(a == b);
}
 
/* -------------------------------------------------------------------- */
inline Span<GField> FieldOperation::inputs() const
{
  return inputs_;
}
 
inline const mf::MultiFunction &FieldOperation::multi_function() const
{
  return *function_;
}
 
inline const CPPType &FieldOperation::output_cpp_type(int output_index) const
{
  int output_counter = 0;
  for (const int param_index : function_->param_indices()) {
    mf::ParamType param_type = function_->param_type(param_index);
    if (param_type.is_output()) {
      if (output_counter == output_index) {
        return param_type.data_type().single_type();
      }
      output_counter++;
    }
  }
  BLI_assert_unreachable();
  return CPPType::get<float>();
}
 
/* -------------------------------------------------------------------- */
inline std::string FieldInput::socket_inspection_name() const
{
  return debug_name_;
}
 
inline StringRef FieldInput::debug_name() const
{
  return debug_name_;
}
 
inline const CPPType &FieldInput::cpp_type() const
{
  return *type_;
}
 
inline FieldInput::Category FieldInput::category() const
{
  return category_;
}
 
inline const CPPType &FieldInput::output_cpp_type(int output_index) const
{
  BLI_assert(output_index == 0);
  UNUSED_VARS_NDEBUG(output_index);
  return *type_;
}
 
}  // namespace blender::fn