26#include <fmt/format.h>
60 if (drawing->strokes().attributes().domain_supported(this->domain())) {
62 return curves_field_input->get_varray_for_context(context,
mask, scope);
72 : geometry_(other.geometry_),
75 curves_id_(other.curves_id_),
76 grease_pencil_layer_index_(other.grease_pencil_layer_index_)
101 switch (component.
type()) {
102 case GeometryComponent::Type::Mesh: {
103 const MeshComponent &mesh_component = static_cast<const MeshComponent &>(component);
104 geometry_ = mesh_component.get();
108 const CurveComponent &curve_component = static_cast<const CurveComponent &>(component);
109 const Curves *curves = curve_component.get();
110 geometry_ = curves ? &curves->geometry.wrap() : nullptr;
111 curves_id_ = curve_component.get();
115 const PointCloudComponent &pointcloud_component = static_cast<const PointCloudComponent &>(
117 geometry_ = pointcloud_component.get();
121 const GreasePencilComponent &grease_pencil_component =
122 static_cast<const GreasePencilComponent &>(component);
123 geometry_ = grease_pencil_component.get();
125 BLI_assert(domain == AttrDomain::Layer);
129 const InstancesComponent &instances_component = static_cast<const InstancesComponent &>(
131 geometry_ = instances_component.get();
168 const int layer_index)
172 grease_pencil_layer_index_(layer_index)
185 return mesh->attributes();
188 return curves->attributes();
200 return drawing->strokes().attributes();
248 return &drawing->strokes();
259 static_cast<const Instances *
>(geometry_) :
269 return *geometry_context;
276 if (
const Curves *curves_id = curve_context->curves_id()) {
295 grease_pencil_context->domain(),
296 grease_pencil_context->layer_index());
337 if (
const Mesh *
mesh = geometry_context->mesh()) {
389 if (
const PointCloud *pointcloud = geometry_context->pointcloud()) {
408 if (
const Instances *instances = geometry_context->instances()) {
428 return *layer_attributes.
lookup(name_, data_type);
431 const int layer_index = context.grease_pencil_layer_index();
441 reader.varray.get_to_uninitialized(layer_index, value);
442 const int domain_size = curves_attributes.
domain_size(domain);
451 else if (
auto attributes = context.attributes()) {
452 return *attributes->lookup(name_, domain, data_type);
463 const AttributeAccessor layer_attributes = context.grease_pencil()->attributes();
465 const bool exists = layer_attributes.
contains(name_);
471 const bool exists = layer_attributes.
contains(name_) || curve_attributes.
contains(name_);
472 const int domain_size = curve_attributes.
domain_size(domain);
475 const bool exists = context.attributes()->contains(name_);
476 const int domain_size = context.attributes()->domain_size(domain);
483 static constexpr int8_t id = 0;
485 hash.data.extend(
Span(name_.data(), name_.size()).cast<std::byte>());
496 if (socket_inspection_name_) {
497 return *socket_inspection_name_;
499 return fmt::format(fmt::runtime(
TIP_(
"\"{}\" attribute from geometry")), name_);
505 hash.data.extend(
Span(name_.data(), name_.size()).cast<std::byte>());
512 const std::optional<AttributeAccessor> attributes = component.
attributes();
513 if (!attributes.has_value()) {
516 const std::optional<AttributeMetaData> meta_data = attributes->lookup_meta_data(name_);
517 if (!meta_data.has_value()) {
520 return meta_data->domain;
525 const std::optional<AttributeAccessor> attributes = component.
attributes();
526 if (!attributes.has_value()) {
529 const std::optional<AttributeMetaData> meta_data = attributes->lookup_meta_data(name_);
530 if (!meta_data.has_value()) {
552 if (
auto attributes = context.attributes()) {
564 return TIP_(
"ID / Index");
570 static constexpr int8_t id = 0;
591 if (!context.grease_pencil()) {
595 auto layer_is_selected = [selection_name =
StringRef(layer_name_),
597 size =
mask.min_array_size()](
const int layer_i) {
598 if (layer_i < 0 || layer_i >=
grease_pencil.layers().size()) {
602 return layer.name() == selection_name;
606 const int layer_i = context.grease_pencil_layer_index();
607 const bool selected = layer_is_selected(layer_i);
617 hash.data.extend(
Span(layer_name_.data(), layer_name_.size()).cast<std::byte>());
631 index_field_(std::move(index_field)),
632 value_field_(std::move(value_field)),
633 value_field_domain_(value_field_domain)
640 const std::optional<AttributeAccessor> attributes = context.attributes();
646 fn::FieldEvaluator value_evaluator{value_context, attributes->domain_size(value_field_domain_)};
647 value_evaluator.
add(value_field_);
652 index_evaluator.
add(index_field_);
661 dst_array.type().value_initialize_indices(dst_array.data(), valid_mask.
complement(
mask, memory));
668 static constexpr int8_t id = 0;
671 hash.add(deep_hash_cache.
ensure(index_field_));
672 hash.add(deep_hash_cache.
ensure(value_field_));
673 hash.add(value_field_domain_);
700 return geometry.get_component(src_type);
710 : src_geometry_(std::move(
geometry)), src_field_(std::move(src_field)), domain_(domain)
712 src_geometry_.ensure_owns_direct_data();
714 mf::SignatureBuilder builder{
"Sample Index", signature_};
715 builder.single_input<
int>(
"Index");
716 builder.single_output(
"Value", src_field_.cpp_type());
717 this->set_signature(&signature_);
722 mutex_.ensure([&]() {
724 if (component ==
nullptr) {
729 evaluator_ = std::make_unique<fn::FieldEvaluator>(*geometry_context_, domain_num);
730 evaluator_->add(src_field_);
731 evaluator_->evaluate();
732 src_data_ = &evaluator_->get_evaluated(0);
740 const VArraySpan<int> indices = params.readonly_single_input<
int>(0,
"Index");
741 GMutableSpan dst = params.uninitialized_single_output(1,
"Value");
743 const CPPType &type = dst.type();
744 if (src_data_ ==
nullptr) {
753 dst.type().value_initialize_indices(dst.data(), valid_mask.
complement(
mask, memory));
758 static constexpr int8_t id = 0;
768 src_field_(std::move(field)),
776 const AttrDomain dst_domain = context.domain();
777 const int dst_domain_size = context.attributes()->domain_size(dst_domain);
786 const int layer_index = context.grease_pencil_layer_index();
790 value_evaluator.
add(src_field_);
818 static constexpr int8_t id = 0;
821 hash.add(src_domain_);
852 if (
const Mesh *
mesh = context.mesh()) {
854 *
mesh,
mask, context.domain(), legacy_corner_normals_, true_normals_);
864 return true_normals_ ?
TIP_(
"True Normal") :
TIP_(
"Normal");
870 static constexpr int8_t id = 0;
872 hash.add(legacy_corner_normals_);
873 hash.add(true_normals_);
878 switch (component.
type()) {
881 switch (
mesh->normals_domain()) {
910 return attribute_input->attribute_name();
935 const std::optional<AttributeMetaData> meta_data = attributes.
lookup_meta_data(*field_id);
963 return varray_info.
data == attribute_info.
data;
975 const int domain_size,
992 old_attribute.varray.materialize(buffer);
1006 const int domain_size = attributes.
domain_size(domain);
1007 if (domain_size == 0) {
1008 bool all_added =
true;
1022 struct StoreResult {
1024 int evaluator_index;
1038 std::variant<Single, Array> new_data;
1042 bool success =
true;
1044 for (
const int input_index : names.
index_range()) {
1045 const StringRef name = names[input_index];
1046 const CPPType &type = fields[input_index].cpp_type();
1050 if (
const std::optional<AttributeDomainAndType> meta_data =
1062 if (!validator && selection_is_full) {
1070 if (dst.domain == domain && dst.varray.type() == field.
cpp_type()) {
1071 const int evaluator_index = evaluator.
add(field);
1072 results_to_store.
append({input_index, evaluator_index});
1081 void *buffer =
data->data.data();
1082 if (!selection_is_full) {
1093 results_to_add.
append({input_index, AddResult::Single{value}});
1100 for (
const StoreResult &
result : results_to_store) {
1104 if (selection_is_full) {
1119 for (AddResult &
result : results_to_add) {
1122 const CPPType &type = fields[
result.input_index].cpp_type();
1124 if (
auto *
array = std::get_if<AddResult::Array>(&
result.new_data)) {
1133 const auto value = std::get<AddResult::Single>(
result.new_data);
1135 if (!attributes.
add(name, domain, data_type,
init)) {
1160 bool any_success =
false;
1162 for (const int layer_index : range) {
1163 if (greasepencil::Drawing *drawing = grease_pencil->get_eval_drawing(
1164 grease_pencil->layer(layer_index)))
1166 const GeometryFieldContext field_context{*grease_pencil, domain, layer_index};
1167 const bool success = try_capture_fields_on_geometry(
1168 drawing->strokes_for_write().attributes_for_write(),
1174 if (success & !any_success) {
1187 MutableAttributeAccessor attributes = *component.attributes_for_write();
1188 const GeometryFieldContext field_context{component, domain};
1190 attributes, field_context, names, domain, selection, fields);
1206 if (!field_inputs) {
1207 return std::nullopt;
1213 if (std::holds_alternative<NativeFieldDomain::None>(domain_info.
variant)) {
1214 return std::nullopt;
1216 if (
const auto *value = std::get_if<NativeFieldDomain::Domain>(&domain_info.
variant)) {
1217 domains.
add(value->domain);
1222 if (
const auto *input =
dynamic_cast<const MeshFieldInput *
>(&field_input)) {
1224 if (std::holds_alternative<NativeFieldDomain::None>(domain_info.
variant)) {
1225 return std::nullopt;
1227 if (
const auto *value = std::get_if<NativeFieldDomain::Domain>(&domain_info.
variant)) {
1228 domains.
add(value->domain);
1233 return std::nullopt;
1235 if (domains.
size() != 1) {
1237 return std::nullopt;
1256 if (!field_inputs) {
1257 return std::nullopt;
1259 std::optional<AttrDomain> output_domain;
1260 auto handle_domain = [&](
const std::optional<AttrDomain> domain) {
1261 if (!domain.has_value()) {
1264 if (output_domain.has_value()) {
1265 if (*output_domain != *domain) {
1270 output_domain = domain;
1276 if (
mesh ==
nullptr) {
1277 return std::nullopt;
1283 if (!handle_domain(geometry_field_input->preferred_domain(component))) {
1284 return std::nullopt;
1287 else if (
const auto *mesh_field_input =
dynamic_cast<const MeshFieldInput *
>(&field_input)) {
1288 if (!handle_domain(mesh_field_input->preferred_domain(*
mesh))) {
1289 return std::nullopt;
1293 return std::nullopt;
1301 return std::nullopt;
1307 if (!handle_domain(geometry_field_input->preferred_domain(component))) {
1308 return std::nullopt;
1311 else if (
const auto *curves_field_input =
dynamic_cast<const CurvesFieldInput *
>(
1314 if (!handle_domain(curves_field_input->preferred_domain(
curves->geometry.wrap()))) {
1315 return std::nullopt;
1319 return std::nullopt;
1323 return output_domain;
Low-level operations for curves.
Low-level operations for grease pencil.
#define BUFFER_FOR_CPP_TYPE_VALUE(type, variable_name)
#define BLI_SCOPED_DEFER(function_to_defer)
#define BLI_assert_unreachable()
void value_initialize_indices(void *ptr, const IndexMask &mask) const
void fill_construct_n(const void *value, void *dst, int64_t n) const
void destruct(void *ptr) const
const void * default_value() const
GMutableSpan as_mutable_span()
CommonVArrayInfo common_info() const
const CPPType & type() const
void get_to_uninitialized(int64_t index, void *r_value) const
IndexRange index_range() const
static GVArray from_single_default(const CPPType &type, int64_t size)
static GVArray from_garray(GArray<> array)
static GVArray from_single(const CPPType &type, int64_t size, const void *value)
friend class ImplicitSharingPtr
constexpr IndexRange()=default
void * allocate_owned(const CPPType &type)
constexpr int64_t size() const
constexpr IndexRange index_range() const
static VArray from_single(T value, const int64_t size)
static VArray from_func(const int64_t size, GetFunc get_func)
void append(const T &value)
AttributeValidator lookup_validator(const StringRef name) const
std::optional< AttributeDomainAndType > get_builtin_domain_and_type(const StringRef name) const
bool contains(StringRef name) const
GVArray adapt_domain(const GVArray &varray, const AttrDomain from_domain, const AttrDomain to_domain) const
std::optional< AttributeMetaData > lookup_meta_data(StringRef name) const
GAttributeReader lookup(const StringRef name) const
int domain_size(const AttrDomain domain) const
GPointer get_builtin_default(const StringRef name) const
bool is_builtin(const StringRef name) const
const Curves * get() const
const Curves * curves_id() const
CurvesFieldContext(const CurvesGeometry &curves, AttrDomain domain)
AttrDomain domain() const
AttributeAccessor attributes() const
std::optional< AttrDomain > preferred_domain(const GeometryComponent &) const override
NativeFieldDomain native_domain_info(const GeometryComponent &) const override
void hash_unique(UniqueHashBytes &hash, fn::FieldHashDeep &deep_hash_cache) const override
EvaluateOnDomainInput(fn::GField field, AttrDomain domain)
GVArray get_varray_for_context(const bke::GeometryFieldContext &context, const IndexMask &) const final
void foreach_recursive_field(FunctionRef< void(const fn::GField &)> fn) const override
int attribute_domain_size(AttrDomain domain) const
virtual std::optional< AttributeAccessor > attributes() const
const CurvesGeometry * curves() const
std::optional< AttributeAccessor > attributes() const
AttrDomain domain() const
const Mesh * mesh() const
int grease_pencil_layer_index() const
const Instances * instances() const
const PointCloud * pointcloud() const
GeometryFieldContext(const GeometryFieldContext &other, AttrDomain domain)
const greasepencil::Drawing * grease_pencil_layer_drawing() const
const void * geometry() const
const GreasePencil * grease_pencil() const
const CurvesGeometry * curves_or_strokes() const
GeometryComponent::Type type() const
const Curves * curves_id() const
AttrDomain domain() const
GVArray get_varray_for_input(const fn::FieldInput &field_input, const IndexMask &mask, ResourceScope &scope) const override
bke::AttributeAccessor attributes() const
const Mesh & mesh() const
AttrDomain domain() const
MeshFieldContext(const Mesh &mesh, AttrDomain domain)
bool add(const StringRef name, const AttrDomain domain, const AttrType data_type, const AttributeInit &initializer)
bool remove(const StringRef name)
bool assign_data(const StringRef name, const AttributeInit &initializer)
bool add_override(const StringRef name, const AttrDomain domain, const AttrType data_type, const AttributeInit &initializer)
GSpanAttributeWriter lookup_for_write_span(StringRef name)
SampleIndexFunction(GeometrySet geometry, fn::GField src_field, AttrDomain domain)
static const GeometryComponent * find_source_component(const GeometrySet &geometry, AttrDomain domain)
void prepare_for_execution() const override
void hash_unique(UniqueHashBytes &hash) const override
void call(const IndexMask &mask, mf::Params params, mf::Context) const override
const bke::CurvesGeometry & strokes() const
constexpr IndexRange index_range() const
A running instance of the engine.
void set_selection(Field< bool > selection)
int add(GField field, GVArray *varray_ptr)
IndexMask get_evaluated_selection_as_mask() const
int add_with_destination(GField field, GVMutableArray dst)
const GVArray & get_evaluated(const int field_index) const
static Field from_non_owning_ref(const Field &field)
bool depends_on_input() const
static Field from_input(Args &&...args)
bool depends_on_input() const
const FieldInputsPtr & field_inputs() const
const InputT * get_input_if() const
const CPPType & cpp_type() const
IndexMask complement(const IndexMask &universe, LinearAllocator<> &memory) const
IndexMask indices_in_range(const IndexMask &universe, Span< int > values, IndexRange range, LinearAllocator<> &memory)
void copy(const GVArray &src, GMutableSpan dst, exec_mode::Mode mode=exec_mode::parallel)
void gather(GSpan src, Span< int > map, GMutableSpan dst)
std::optional< AttrDomain > try_detect_native_field_domain(const GeometryComponent &component, const fn::GField &field)
static bool try_assign_single_value(MutableAttributeAccessor &attributes, const StringRef name, const GPointer value)
std::optional< AttrDomain > try_detect_field_domain(const GeometryComponent &component, const fn::GField &field)
bool try_capture_fields_on_geometry(MutableAttributeAccessor attributes, const fn::FieldContext &field_context, Span< StringRef > names, AttrDomain domain, const fn::Field< bool > &selection, Span< fn::GField > fields)
static std::optional< GeometryFieldContext > try_get_geometry_field_context(const fn::FieldContext &context)
VArray< float3 > curve_normals_varray(const CurvesGeometry &curves, AttrDomain domain)
static std::optional< StringRefNull > try_get_field_direct_attribute_id(const fn::GField &any_field)
VArray< float3 > mesh_normals_varray(const Mesh &mesh, const IndexMask &mask, AttrDomain domain, bool no_corner_normals=false, bool true_normals=false)
static bool attribute_data_matches_varray(const GAttributeReader &attribute, const CommonVArrayInfo &varray_info)
VArray< float3 > instance_position_varray(const Instances &instances)
static bool try_add_shared_field_attribute(MutableAttributeAccessor attributes, const StringRef id_to_create, const AttrDomain domain, const fn::GField &field)
static void initialize_new_data(MutableAttributeAccessor &attributes, const AttrDomain domain, const int domain_size, const StringRef name, const CPPType &type, const bke::AttrType data_type, void *buffer)
static bool component_is_available(const GeometrySet &geometry, const GeometryComponent::Type type, const AttrDomain domain)
static bool attribute_kind_matches(const AttributeMetaData meta_data, const AttrDomain domain, const bke::AttrType data_type)
static StringRef get_random_id_attribute_name(const AttrDomain domain)
AttrType cpp_type_to_attribute_type(const CPPType &type)
ImplicitSharingPtr< FieldInputs > FieldInputsPtr
void evaluate_constant_field(const GField &field, void *r_value)
BLI_INLINE Texture * wrap(MTLTexture *texture)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
BMesh const char void * data
AttributeInitValue(const T &value)
fn::GField validate_field_if_necessary(const fn::GField &field) const
NativeFieldDomain(const None &)
std::variant< None, Domain, Constant > variant
UniqueHash ensure(const GFieldRef &field)