Blender V5.3
instances_attributes.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BKE_instances.hh"
10
12
13namespace blender::bke {
14
16{
17 Instances &instances = *static_cast<Instances *>(owner);
19}
20
21static const auto &changed_tags()
22{
23 static Map<StringRef, AttrUpdateOnChange> attributes{
24 {".reference_index", tag_component_reference_index_changed},
25 };
26 return attributes;
27}
28
29static const auto &builtin_attributes()
30{
31 static auto attributes = []() {
33
35 instance_transform.deletable = false;
36 map.add_new("instance_transform", std::move(instance_transform));
37
40 reference_index.deletable = false;
41 map.add_new(".reference_index", std::move(reference_index));
42
43 return map;
44 }();
45 return attributes;
46}
47
48static const auto &array_storage_required()
49{
50 static Set<StringRef> attributes{"instance_transform", ".reference_index"};
51 return attributes;
52}
53
55{
57 fn.domain_supported = [](const void * /*owner*/, const AttrDomain domain) {
58 return domain == AttrDomain::Instance;
59 };
60 fn.domain_size = [](const void *owner, const AttrDomain domain) {
61 return domain == AttrDomain::Instance ?
62 static_cast<const Instances *>(owner)->instances_num() :
63 0;
64 };
65 fn.builtin_domain_and_type = [](const void * /*owner*/,
66 const StringRef name) -> std::optional<AttributeDomainAndType> {
67 const AttrBuiltinInfo *info = builtin_attributes().lookup_ptr(name);
68 if (!info) {
69 return std::nullopt;
70 }
71 return AttributeDomainAndType{info->domain, info->type};
72 };
73 fn.get_builtin_default = [](const void * /*owner*/, StringRef name) -> GPointer {
74 const AttrBuiltinInfo &info = builtin_attributes().lookup(name);
75 return info.default_value;
76 };
77 fn.lookup_meta_data = [](const void *owner, StringRef name) -> std::optional<AttributeMetaData> {
78 const Instances &instances = *static_cast<const Instances *>(owner);
79 const AttributeStorage &storage = instances.attribute_storage();
80 const Attribute *attr = storage.lookup(name);
81 if (!attr) {
82 return std::nullopt;
83 }
84 return AttributeMetaData{attr->domain(), attr->data_type()};
85 };
86 fn.lookup = [](const void *owner, const StringRef name) -> GAttributeReader {
87 const Instances &instances = *static_cast<const Instances *>(owner);
88 const AttributeStorage &storage = instances.attribute_storage();
89 const Attribute *attribute = storage.lookup(name);
90 if (!attribute) {
91 return {};
92 }
94 };
95 fn.adapt_domain = [](const void * /*owner*/,
96 const GVArray &varray,
97 const AttrDomain from_domain,
98 const AttrDomain to_domain) {
99 if (from_domain == to_domain && from_domain == AttrDomain::Instance) {
100 return varray;
101 }
102 return GVArray{};
103 };
104 fn.foreach_attribute = [](const void *owner,
105 const FunctionRef<void(const AttributeIter &)> fn,
106 const AttributeAccessor &accessor) {
107 const Instances &instances = *static_cast<const Instances *>(owner);
108 const AttributeStorage &storage = instances.attribute_storage();
109 for (const Attribute &attribute : storage) {
110 const auto get_fn = [&]() {
112 };
113 AttributeIter iter(attribute.name(), attribute.domain(), attribute.data_type(), get_fn);
114 iter.is_builtin = builtin_attributes().contains(attribute.name());
115 iter.storage_type = attribute.storage_type();
116 iter.accessor = &accessor;
117 fn(iter);
118 if (iter.is_stopped()) {
119 break;
120 }
121 }
122 };
123 fn.lookup_validator = [](const void * /*owner*/, const StringRef name) -> AttributeValidator {
124 const AttrBuiltinInfo *info = builtin_attributes().lookup_ptr(name);
125 if (!info) {
126 return {};
127 }
128 return info->validator;
129 };
130 fn.lookup_for_write = [](void *owner, const StringRef name) -> GAttributeWriter {
131 Instances &instances = *static_cast<Instances *>(owner);
133 Attribute *attribute = storage.lookup(name);
134 if (!attribute) {
135 return {};
136 }
137 return attribute_to_writer(&instances, changed_tags(), instances.instances_num(), *attribute);
138 };
139 fn.remove = [](void *owner, const StringRef name) -> bool {
140 Instances &instances = *static_cast<Instances *>(owner);
142 if (const AttrBuiltinInfo *info = builtin_attributes().lookup_ptr(name)) {
143 if (!info->deletable) {
144 return false;
145 }
146 }
147 const std::optional<AttrUpdateOnChange> fn = changed_tags().lookup_try(name);
148 const bool removed = storage.remove(name);
149 if (!removed) {
150 return false;
151 }
152 if (fn) {
153 (*fn)(owner);
154 }
155 return true;
156 };
157 fn.add = [](void *owner,
158 const StringRef name,
159 const AttrDomain domain,
160 const AttrType type,
161 const AttributeInit &initializer) {
162 Instances &instances = *static_cast<Instances *>(owner);
163 const int domain_size = instances.instances_num();
165 if (const AttrBuiltinInfo *info = builtin_attributes().lookup_ptr(name)) {
166 if (info->domain != domain || info->type != type) {
167 return false;
168 }
169 }
170 if (storage.lookup(name)) {
171 return false;
172 }
173 const bool array = array_storage_required().contains(name);
174 Attribute::DataVariant data = attribute_init_to_data(type, domain_size, initializer, array);
175 storage.add(name, domain, type, std::move(data));
176 if (initializer.type != AttributeInit::Type::Construct) {
177 if (const std::optional<AttrUpdateOnChange> fn = changed_tags().lookup_try(name)) {
178 (*fn)(owner);
179 }
180 }
181 return true;
182 };
183 fn.rename = [](void *owner,
184 const Map<StringRef, StringRef> &name_map,
185 bool overwrite) -> Set<StringRef> {
186 Instances &instances = *static_cast<Instances *>(owner);
187 return rename_attributes(
188 instances.attribute_storage(),
189 name_map,
190 overwrite,
193 [&](const bke::AttrDomain /*domain*/) { return instances.instances_num(); },
194 std::nullopt,
195 {});
196 };
197 fn.assign_data = [](void *owner, StringRef name, const AttributeInit &initializer) {
198 Instances &instances = *static_cast<Instances *>(owner);
200 Attribute *attr = storage.lookup(name);
201 if (!attr) {
202 return false;
203 }
205 instances.instances_num(),
206 initializer,
207 array_storage_required().contains(name));
208 attr->assign_data(std::move(data));
209 if (initializer.type != AttributeInit::Type::Construct) {
210 if (const std::optional<AttrUpdateOnChange> fn = changed_tags().lookup_try(name)) {
211 (*fn)(owner);
212 }
213 }
214 return true;
215 };
216
217 return fn;
218}
219
225
226} // namespace blender::bke
void add_new(const Key &key, const Value &value)
Definition BLI_map.hh:265
std::optional< AttrStorageType > storage_type
const AttributeAccessor * accessor
std::variant< ArrayData, SingleData > DataVariant
void assign_data(DataVariant &&data)
int instances_num() const
Definition instances.cc:408
bke::AttributeStorage & attribute_storage()
#define storage(slot, qualifiers)
#define attribute(slot)
GAttributeReader attribute_to_reader(const Attribute &attribute, const AttrDomain domain, const int64_t domain_size)
static const auto & array_storage_required()
Set< StringRef > rename_attributes(AttributeStorage &storage, const Map< StringRef, StringRef > &name_map, const bool overwrite, const Map< StringRef, AttrBuiltinInfo > &builtin_attributes, const Set< StringRef > &array_storage_required, const FunctionRef< int(AttrDomain)> domain_size_fn, std::optional< ListBaseT< bDeformGroup > * > vertex_groups, FunctionRef< MutableSpan< MDeformVert >()> get_mutable_dverts)
GAttributeWriter attribute_to_writer(void *owner, const Map< StringRef, AttrUpdateOnChange > &changed_tags, const int64_t domain_size, Attribute &attribute)
static const auto & builtin_attributes()
Attribute::DataVariant attribute_init_to_data(const bke::AttrType data_type, const int64_t domain_size, const AttributeInit &initializer, const bool require_array_data)
static void tag_component_reference_index_changed(void *owner)
static constexpr AttributeAccessorFunctions get_instances_accessor_functions()
const AttributeAccessorFunctions & instance_attribute_accessor_functions()
static const auto & changed_tags()
BMesh const char void * data