Blender V5.3
node_socket_value.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2026 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
7
8#include "FN_field.hh"
10
11#include "BKE_volume_grid.hh"
12
14
18#include "NOD_menu_value.hh"
19
20#include "BLI_color_types.hh"
23#include "BLI_memory_counter.hh"
24
25struct Object;
26struct VFont;
27struct bSound;
28struct Text;
29struct Mask;
30
31namespace blender::bke {
32
33using fn::Field;
34using fn::GField;
37using nodes::GList;
38using nodes::GListPtr;
39using nodes::List;
40using nodes::ListPtr;
41using volume_grid::GVolumeGrid;
43
47#define SOCKET_VALUE_SINGLE_TYPES \
48 X(float) \
49 X(int) \
50 X(float2) \
51 X(float3) \
52 X(float4) \
53 X(int2) \
54 X(bool) \
55 X(int8_t) \
56 X(short2) \
57 X(ColorGeometry4f) \
58 X(ColorGeometry4b) \
59 X(math::Quaternion) \
60 X(float4x4) \
61 X(nodes::MenuValue) \
62 X(std::string) \
63 X(BundlePtr) \
64 X(ClosurePtr) \
65 X(GeometrySet) \
66 X(Object *) \
67 X(Material *) \
68 X(Image *) \
69 X(VFont *) \
70 X(Scene *) \
71 X(bSound *) \
72 X(Collection *) \
73 X(Tex *) \
74 X(Text *) \
75 X(Mask *)
76
80#define SOCKET_VALUE_FIELD_AND_LIST_TYPES \
81 X(float) \
82 X(int) \
83 X(float2) \
84 X(float3) \
85 X(float4) \
86 X(int2) \
87 X(bool) \
88 X(int8_t) \
89 X(short2) \
90 X(ColorGeometry4f) \
91 X(ColorGeometry4b) \
92 X(math::Quaternion) \
93 X(float4x4) \
94 X(nodes::MenuValue) \
95 X(std::string)
96
97namespace detail {
98
99template<typename CurrentT>
102{
103 if (CPPType::get<CurrentT>() == dst_type) {
104 return true;
105 }
106 static const DataTypeConversions &conversions = get_implicit_type_conversions();
107 if constexpr (std::is_same_v<CurrentT, GField>) {
108 const GField &src_field = value.get<GField>();
109 const CPPType &src_base_type = src_field.cpp_type();
110 if (dst_type.generic_type && dst_type.generic_type->is<GField>()) {
111 if (src_base_type == *dst_type.base_type) {
112 /* Nothing to do. */
113 return true;
114 }
115 const ConversionFunctions *fns = conversions.get_conversion_functions(src_base_type,
116 *dst_type.base_type);
117 if (!fns) {
118 return false;
119 }
120 if (const void *src_single_value = src_field.get_if_constant()) {
122 return false;
123 }
124 BUFFER_FOR_CPP_TYPE_VALUE(*dst_type.base_type, dst_single_value);
125 fns->convert_single_to_initialized(src_single_value, dst_single_value);
126 value.emplace<GField>(GField::from_constant(*dst_type.base_type, dst_single_value));
127 dst_type.base_type->destruct(dst_single_value);
128 return true;
129 }
130 if (!fns->multi_function) {
131 return false;
132 }
134 value.emplace<GField>(GField(std::move(op), 0));
135 return true;
136 }
137
138 if (src_base_type == dst_type) {
139 BUFFER_FOR_CPP_TYPE_VALUE(dst_type, tmp_buffer);
140 fn::evaluate_constant_field(src_field, tmp_buffer);
141 void *dst_value = SocketValueVariant::allocate(dst_type, value);
142 dst_type.move_construct(tmp_buffer, dst_value);
143 dst_type.destruct(tmp_buffer);
144 return true;
145 }
146 const ConversionFunctions *fns = conversions.get_conversion_functions(src_base_type, dst_type);
147 if (!fns || !fns->convert_single_to_initialized) {
148 return false;
149 }
150 BUFFER_FOR_CPP_TYPE_VALUE(src_base_type, src_single_value);
151 fn::evaluate_constant_field(src_field, src_single_value);
152 void *dst_value = SocketValueVariant::allocate(dst_type, value);
153 fns->convert_single_to_uninitialized(src_single_value, dst_value);
154 src_base_type.destruct(src_single_value);
155 return true;
156 }
157 else if constexpr (std::is_same_v<CurrentT, GListPtr>) {
158 GListPtr &src_list = value.get<GListPtr>();
159 if (dst_type.generic_type && dst_type.generic_type->is<GListPtr>()) {
160 if (!src_list) {
161 /* Nothing to do. */
162 return true;
163 }
164 const CPPType &src_base_type = src_list->cpp_type();
165 if (src_base_type == *dst_type.base_type) {
166 /* Nothing to do. */
167 return true;
168 }
169 const ConversionFunctions *fns = conversions.get_conversion_functions(src_base_type,
170 *dst_type.base_type);
171 if (!fns || !fns->multi_function || !fns->convert_single_to_uninitialized) {
172 return false;
173 }
174 const int64_t size = src_list->size();
175 const std::variant<GSpan, GPointer> src_values = src_list->values();
176 if (const auto *src_span = std::get_if<GSpan>(&src_values)) {
177 GArray<> dst_values(*dst_type.base_type, size, NoInitialization{});
178 IndexMask mask{size};
179 mf::ParamsBuilder params{*fns->multi_function, &mask};
180 params.add_readonly_single_input(*src_span);
181 params.add_uninitialized_single_output(dst_values);
182 mf::ContextBuilder context;
183 fns->multi_function->call_auto(mask, params, context);
184 src_list = GList::from_garray(std::move(dst_values));
185 return true;
186 }
187 if (const auto *src_single_value = std::get_if<GPointer>(&src_values)) {
188 BUFFER_FOR_CPP_TYPE_VALUE(*dst_type.base_type, dst_single_value);
189 fns->convert_single_to_uninitialized(src_single_value->get(), dst_single_value);
190 src_list = GList::from_single({*dst_type.base_type, dst_single_value}, size);
191 dst_type.base_type->destruct(dst_single_value);
192 return true;
193 }
194 }
195 return false;
196 }
197#ifdef WITH_OPENVDB
198 else if constexpr (std::is_same_v<CurrentT, GVolumeGrid>) {
199 GVolumeGrid &src_grid = value.get<GVolumeGrid>();
200 if (dst_type.generic_type && dst_type.generic_type->is<GVolumeGrid>()) {
201 if (!src_grid) {
202 /* Nothing to do. */
203 return true;
204 }
205 const CPPType *src_base_type = src_grid->cpp_type();
206 if (!src_base_type) {
207 /* Unknown type. */
208 return false;
209 }
210 if (src_base_type == dst_type.base_type) {
211 /* Nothing to do. */
212 return true;
213 }
214 const ConversionFunctions *fns = conversions.get_conversion_functions(*src_base_type,
215 *dst_type.base_type);
216 if (!fns || !fns->multi_function) {
217 return false;
218 }
219 VolumeTreeAccessToken tree_token;
220 const openvdb::GridBase &src_grid_base = src_grid->grid(tree_token);
221 using namespace volume_grid::multi_function_eval;
222 EvalResult conversion_result = evaluate_multi_function_on_grid(
223 *fns->multi_function, {&src_grid_base}, {true});
224 /* Release the tree token because the src_grid is reassigned below and may get destructed,
225 * while the tree_token still tries to access it on exiting the scope. */
226 tree_token.reset();
227
228 if (std::holds_alternative<EvalResult::Failure>(conversion_result.result)) {
229 return false;
230 }
231 src_grid = GVolumeGrid(
232 std::move(std::get<EvalResult::Success>(conversion_result.result).output_grids[0]));
233 return true;
234 }
235 return false;
236 }
237#endif
238 else {
239 /* The stored value is a single value. */
240
241 if (dst_type.is<GField>()) {
243 value.emplace<GField>(std::move(field));
244 return true;
245 }
246 if (dst_type.generic_type && dst_type.generic_type->is<GField>()) {
247 if (dst_type.base_type->is<CurrentT>()) {
249 value.emplace<GField>(std::move(field));
250 return true;
251 }
252 const ConversionFunctions *fns = conversions.get_conversion_functions(
253 CPPType::get<CurrentT>(), *dst_type.base_type);
254 if (!fns || !fns->convert_single_to_initialized) {
255 return false;
256 }
257 BUFFER_FOR_CPP_TYPE_VALUE(*dst_type.base_type, tmp_buffer);
258 fns->convert_single_to_initialized(value.get(), tmp_buffer);
259 value.emplace<GField>(GField::from_constant(*dst_type.base_type, tmp_buffer));
260 dst_type.base_type->destruct(tmp_buffer);
261 return true;
262 }
264 dst_type);
265 if (!fns || !fns->convert_single_to_uninitialized) {
266 return false;
267 }
268 BUFFER_FOR_CPP_TYPE_VALUE(dst_type, tmp_buffer);
269 fns->convert_single_to_uninitialized(value.get(), tmp_buffer);
270 void *dst_value = SocketValueVariant::allocate(dst_type, value);
271 dst_type.move_construct(tmp_buffer, dst_value);
272 dst_type.destruct(tmp_buffer);
273 return true;
274 }
275}
276
277template<typename CurrentT>
279 const SocketValueVariantAny &value)
280{
281 if constexpr (std::is_same_v<CurrentT, GField>) {
282 if (dst_type.is<GField>()) {
283 return true;
284 }
285 if (!dst_type.generic_type) {
286 return false;
287 }
288 if (dst_type.generic_type->is<GField>()) {
289 const GField &field = value.get<GField>();
290 const CPPType &base_type = field.cpp_type();
291 return base_type == *dst_type.base_type;
292 }
293 return false;
294 }
295 else if constexpr (std::is_same_v<CurrentT, GListPtr>) {
296 if (dst_type.is<GListPtr>()) {
297 return true;
298 }
299 if (!dst_type.generic_type) {
300 return false;
301 }
302 if (dst_type.generic_type->is<GListPtr>()) {
303 const GListPtr &list_ptr = value.get<GListPtr>();
304 if (!list_ptr) {
305 return true;
306 }
307 const CPPType &base_type = list_ptr->cpp_type();
308 return base_type == *dst_type.base_type;
309 }
310 return false;
311 }
312#ifdef WITH_OPENVDB
313 else if constexpr (std::is_same_v<CurrentT, GVolumeGrid>) {
314 if (dst_type.is<GVolumeGrid>()) {
315 return true;
316 }
317 if (!dst_type.generic_type) {
318 return false;
319 }
320 if (dst_type.generic_type->is<GVolumeGrid>()) {
321 const GVolumeGrid &grid = value.get<GVolumeGrid>();
322 if (!grid) {
323 return true;
324 }
325 const CPPType *grid_value_type = grid->cpp_type();
326 return grid_value_type == dst_type.base_type;
327 }
328 return false;
329 }
330#endif
331
332 else {
333 return CPPType::get<CurrentT>() == dst_type;
334 }
335}
336
337#define DEFINE_TYPE(TYPE) \
338 template bool SocketValueVariantTypeInfo::try_convert_fn<TYPE>(const CPPType &dst_type, \
339 SocketValueVariantAny &value); \
340 template bool SocketValueVariantTypeInfo::is_interpretable_as_fn<TYPE>( \
341 const CPPType &dst_type, const SocketValueVariantAny &value);
342
343#define X(TYPE) DEFINE_TYPE(TYPE)
345#undef X
346
353#define X(TYPE) \
354 DEFINE_TYPE(Field<TYPE>) \
355 DEFINE_TYPE(ListPtr<TYPE>)
357#undef X
358
361
362#ifdef WITH_OPENVDB
363DEFINE_TYPE(volume_grid::GVolumeGrid)
364DEFINE_TYPE(VolumeGrid<float>)
365DEFINE_TYPE(VolumeGrid<int>)
366DEFINE_TYPE(VolumeGrid<float3>)
367DEFINE_TYPE(VolumeGrid<bool>)
368#endif
369
370} // namespace detail
371
372template<typename T>
373inline T &SocketValueVariant::init_default(detail::SocketValueVariantAny &value)
374{
375 if constexpr (requires { typename T::generic_type; }) {
376 using GenericType = typename T::generic_type;
377 using BaseType = typename T::base_type;
378 if constexpr (std::is_same_v<GenericType, GField>) {
379 const CPPType &base_cpp_type = CPPType::get<BaseType>();
380 return value.emplace<GField>(base_cpp_type).typed<BaseType>();
381 }
382 else if constexpr (std::is_same_v<GenericType, GListPtr>) {
383 return value.emplace<GListPtr>().typed<BaseType>();
384 }
385#ifdef WITH_OPENVDB
386 else if constexpr (std::is_same_v<GenericType, GVolumeGrid>) {
387 return value.emplace<GVolumeGrid>().typed<BaseType>();
388 }
389#endif
390 }
391 else if constexpr (std::is_same_v<T, GField>) {
392 /* Some default fallback type. */
393 return value.emplace<GField>(CPPType::get<float>());
394 }
395#ifdef WITH_OPENVDB
396 else if constexpr (std::is_same_v<T, GVolumeGrid>) {
397 return value.emplace<GVolumeGrid>();
398 }
399#endif
400 else {
401 return value.emplace<T>();
402 }
403}
404
406#define DEFINE_INIT_DEFAULT(TYPE) \
407 template TYPE &SocketValueVariant::init_default<TYPE>(detail::SocketValueVariantAny & value);
408
409#define X(TYPE) DEFINE_INIT_DEFAULT(TYPE)
411#undef X
412
413#define X(TYPE) \
414 DEFINE_INIT_DEFAULT(Field<TYPE>) \
415 DEFINE_INIT_DEFAULT(ListPtr<TYPE>)
417#undef X
418
421#ifdef WITH_OPENVDB
422DEFINE_INIT_DEFAULT(GVolumeGrid)
423DEFINE_INIT_DEFAULT(VolumeGrid<float>)
424DEFINE_INIT_DEFAULT(VolumeGrid<int>)
425DEFINE_INIT_DEFAULT(VolumeGrid<float3>)
426DEFINE_INIT_DEFAULT(VolumeGrid<bool>)
427#endif
428
429#undef DEFINE_INIT_DEFAULT
430
431void *SocketValueVariant::init_default(const CPPType &type, detail::SocketValueVariantAny &value)
432{
433#define X(TYPE) \
434 if (type.is<TYPE>()) { \
435 return &SocketValueVariant::init_default<TYPE>(value); \
436 }
438#undef X
439
440#define X(TYPE) \
441 if (type.is<Field<TYPE>>()) { \
442 return &SocketValueVariant::init_default<Field<TYPE>>(value); \
443 } \
444 if (type.is<ListPtr<TYPE>>()) { \
445 return &SocketValueVariant::init_default<ListPtr<TYPE>>(value); \
446 }
448#undef X
449
450 if (type.is<GField>()) {
451 return &SocketValueVariant::init_default<GField>(value);
452 }
453 if (type.is<GListPtr>()) {
454 return &SocketValueVariant::init_default<GListPtr>(value);
455 }
456#ifdef WITH_OPENVDB
457 if (type.is<GVolumeGrid>()) {
458 return &SocketValueVariant::init_default<GVolumeGrid>(value);
459 }
460 if (type.is<VolumeGrid<float>>()) {
461 return &SocketValueVariant::init_default<VolumeGrid<float>>(value);
462 }
463 if (type.is<VolumeGrid<int>>()) {
464 return &SocketValueVariant::init_default<VolumeGrid<int>>(value);
465 }
466 if (type.is<VolumeGrid<float3>>()) {
467 return &SocketValueVariant::init_default<VolumeGrid<float3>>(value);
468 }
469 if (type.is<VolumeGrid<bool>>()) {
470 return &SocketValueVariant::init_default<VolumeGrid<bool>>(value);
471 }
472#endif
473 return nullptr;
474}
475
477{
478#define X(TYPE) \
479 if (type.is<TYPE>()) { \
480 return value.allocate<TYPE>(); \
481 }
483#undef X
484
485 if (type.is<GField>()) {
486 return value.allocate<GField>();
487 }
488 if (type.is<GListPtr>()) {
489 return value.allocate<GListPtr>();
490 }
491#ifdef WITH_OPENVDB
492 if (type.is<GVolumeGrid>()) {
493 return value.allocate<GVolumeGrid>();
494 }
495#endif
497 return nullptr;
498}
499
501{
502 return SocketValueVariant::allocate(type, value_);
503}
504
506{
507 const CPPType *type = this->get().type();
508 if (!type) {
509 return false;
510 }
511#define X(TYPE) \
512 if (type->is<TYPE>()) { \
513 return true; \
514 }
516#undef X
517 return false;
518}
519
521{
522 return this->get().type()->is<fn::GField>();
523}
524
526{
527 return this->get().type()->is<nodes::GListPtr>();
528}
530{
531#ifdef WITH_OPENVDB
532 return this->get().type()->is<bke::GVolumeGrid>();
533#else
534 return false;
535#endif
536}
537
539{
540 const fn::GField *field = this->get_if<fn::GField>();
541 if (!field) {
542 return false;
543 }
544 return field->depends_on_input();
545}
546
548{
549 if (this->owns_direct_data()) {
550 return;
551 }
552 if (this->get().is_type<nodes::BundlePtr>()) {
553 if (nodes::BundlePtr &bundle_ptr = value_.get<nodes::BundlePtr>()) {
554 bundle_ptr.ensure_mutable_inplace();
555 nodes::Bundle &bundle = const_cast<nodes::Bundle &>(*bundle_ptr);
557 }
558 }
559 if (this->is_list()) {
560 if (nodes::GListPtr &list_ptr = value_.get<nodes::GListPtr>()) {
561 auto &list = list_ptr.get_for_write();
562 list.ensure_owns_direct_data();
563 }
564 }
565 if (this->get().is_type<GeometrySet>()) {
566 GeometrySet &geometry = value_.get<GeometrySet>();
567 geometry.ensure_owns_direct_data();
568 }
570}
571
573{
574 if (this->get().is_type<nodes::BundlePtr>()) {
575 if (const nodes::BundlePtr &bundle_ptr = value_.get<nodes::BundlePtr>()) {
576 return bundle_ptr->owns_direct_data();
577 }
578 }
579 if (this->is_list()) {
580 if (const nodes::GListPtr &list_ptr = value_.get<nodes::GListPtr>()) {
581 return list_ptr->owns_direct_data();
582 }
583 }
584 if (this->get().is_type<GeometrySet>()) {
585 const GeometrySet &geometry = value_.get<GeometrySet>();
586 return geometry.owns_direct_data();
587 }
588 return true;
589}
590
592{
593 if (!value_.has_value()) {
594 return;
595 }
596 const GPointer value = this->get();
597 const CPPType &cpp_type = *value.type();
598 memory.add(cpp_type.size);
599 if (cpp_type.is<GeometrySet>()) {
600 value.get<GeometrySet>()->count_memory(memory);
601 }
602 else if (cpp_type.is<nodes::BundlePtr>()) {
603 if (const nodes::BundlePtr &bundle_ptr = *value.get<nodes::BundlePtr>()) {
604 bundle_ptr->count_memory(memory);
605 }
606 }
607 else if (cpp_type.is<nodes::GListPtr>()) {
608 if (const nodes::GListPtr &list = *value.get<nodes::GListPtr>()) {
609 list->count_memory(memory);
610 }
611 }
612#ifdef WITH_OPENVDB
613 else if (cpp_type.is<GVolumeGrid>()) {
614 if (const GVolumeGrid &grid = *value.get<GVolumeGrid>()) {
615 grid->count_memory(memory);
616 }
617 }
618#endif
619}
620
621} // namespace blender::bke
#define BUFFER_FOR_CPP_TYPE_VALUE(type, variable_name)
#define BLI_assert_unreachable()
void * get()
Definition BLI_any.hh:339
void * allocate()
Definition BLI_any.hh:306
std::decay_t< T > & emplace(Args &&...args)
Definition BLI_any.hh:275
static const CPPType & get()
const CPPType * generic_type
bool is() const
void destruct(void *ptr) const
const CPPType * base_type
void move_construct(void *src, void *dst) const
const CPPType * type() const
const void * get() const
const ConversionFunctions * get_conversion_functions(mf::DataType from, mf::DataType to) const
static GField from_constant(const CPPType &type, const void *value)
Definition field.cc:24
static GListPtr from_garray(GArray<> array)
static GListPtr from_single(GPointer value, int64_t size)
void * allocate_single(const CPPType &type)
void count_memory(MemoryCounter &memory) const
static void * allocate(const CPPType &type, detail::SocketValueVariantAny &value)
static FieldOperationPtr from(std::shared_ptr< const mf::MultiFunction > fn, Vector< GField > inputs)
Definition field.cc:252
bool depends_on_input() const
Definition FN_field.hh:614
const void * get_if_constant() const
Definition FN_field.hh:632
const CPPType & cpp_type() const
Definition FN_field.hh:518
const CPPType & cpp_type() const
std::variant< GSpan, GPointer > values() const
#define T
Any< SocketValueVariantTypeInfo, 32, 16 > SocketValueVariantAny
const DataTypeConversions & get_implicit_type_conversions()
ImplicitSharingPtr< FieldOperation > FieldOperationPtr
Definition FN_field.hh:44
void evaluate_constant_field(const GField &field, void *r_value)
ImplicitSharingPtr< Closure > ClosurePtr
ImplicitSharingPtr< Bundle > BundlePtr
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
__int64 int64_t
Definition BKE_text.h:90
#define DEFINE_TYPE(TYPE)
#define SOCKET_VALUE_SINGLE_TYPES
#define SOCKET_VALUE_FIELD_AND_LIST_TYPES
#define DEFINE_INIT_DEFAULT(TYPE)
const mf::MultiFunction * multi_function
void(*) convert_single_to_initialized(const void *src, void *dst)
void(*) convert_single_to_uninitialized(const void *src, void *dst)
static bool try_convert_fn(const CPPType &dst_type, SocketValueVariantAny &value)
static bool is_interpretable_as_fn(const CPPType &dst_type, const SocketValueVariantAny &value)