Blender V5.3
rna_node_socket.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BLT_translation.hh"
10
11#include "DNA_node_types.h"
12
13#include "RNA_define.hh"
14#include "RNA_enum_types.hh"
15#include "RNA_types.hh"
16
17#include "rna_internal.hh"
18
19#include "UI_interface_c.hh"
20
21#include "WM_api.hh"
22
23#include "CLG_log.h"
24
25namespace blender {
26
28 {SOCK_CUSTOM, "CUSTOM", 0, "Custom", ""},
29 {SOCK_FLOAT, "VALUE", ICON_NODE_SOCKET_FLOAT, "Value", ""},
30 {SOCK_INT, "INT", ICON_NODE_SOCKET_INT, "Integer", ""},
31 {SOCK_BOOLEAN, "BOOLEAN", ICON_NODE_SOCKET_BOOLEAN, "Boolean", ""},
32 {SOCK_VECTOR, "VECTOR", ICON_NODE_SOCKET_VECTOR, "Vector", ""},
33 {SOCK_ROTATION, "ROTATION", ICON_NODE_SOCKET_ROTATION, "Rotation", ""},
34 {SOCK_MATRIX, "MATRIX", ICON_NODE_SOCKET_MATRIX, "Matrix", ""},
35 {SOCK_STRING, "STRING", ICON_NODE_SOCKET_STRING, "String", ""},
36 {SOCK_RGBA, "RGBA", ICON_NODE_SOCKET_RGBA, "RGBA", ""},
37 {SOCK_SHADER, "SHADER", ICON_NODE_SOCKET_SHADER, "Shader", ""},
38 {SOCK_OBJECT, "OBJECT", ICON_NODE_SOCKET_OBJECT, "Object", ""},
39 {SOCK_IMAGE, "IMAGE", ICON_NODE_SOCKET_IMAGE, "Image", ""},
40 {SOCK_GEOMETRY, "GEOMETRY", ICON_NODE_SOCKET_GEOMETRY, "Geometry", ""},
41 {SOCK_COLLECTION, "COLLECTION", ICON_NODE_SOCKET_COLLECTION, "Collection", ""},
42 {SOCK_TEXTURE, "TEXTURE", ICON_NODE_SOCKET_TEXTURE, "Texture", ""},
43 {SOCK_MATERIAL, "MATERIAL", ICON_NODE_SOCKET_MATERIAL, "Material", ""},
44 {SOCK_MENU, "MENU", ICON_NODE_SOCKET_MENU, "Menu", ""},
45 {SOCK_BUNDLE, "BUNDLE", ICON_NODE_SOCKET_BUNDLE, "Bundle", ""},
46 {SOCK_CLOSURE, "CLOSURE", ICON_NODE_SOCKET_CLOSURE, "Closure", ""},
47 {SOCK_FONT, "FONT", ICON_NODE_SOCKET_FONT, "Font", ""},
48 {SOCK_SCENE, "SCENE", ICON_NODE_SOCKET_SCENE, "Scene", ""},
49 {SOCK_TEXT_ID, "TEXT", ICON_NODE_SOCKET_TEXT, "Text", ""},
50 {SOCK_MASK, "MASK", ICON_NODE_SOCKET_MASK, "Mask", ""},
51 {SOCK_SOUND, "SOUND", ICON_NODE_SOCKET_SOUND, "Sound", ""},
52 {SOCK_INT_VECTOR, "INT_VECTOR", ICON_NODE_SOCKET_INT_VECTOR, "Integer Vector", ""},
53 {0, nullptr, 0, nullptr, nullptr},
54};
55
56}
57
58#ifdef RNA_RUNTIME
59
60# include <fmt/format.h>
61
62# include "DNA_material_types.h"
63
64# include "BLI_listbase.hh"
65# include "BLI_math_vector_c.hh"
66# include "BLI_string.hh"
67# include "BLI_string_ref.hh"
68
69# include "BKE_context.hh"
70# include "BKE_main_invariants.hh"
71# include "BKE_node.hh"
72# include "BKE_node_enum.hh"
73# include "BKE_node_runtime.hh"
75
76# include "DEG_depsgraph_build.hh"
77
79
80# include "ED_node.hh"
81
82namespace blender {
83
84static CLG_LogRef LOG = {"rna.node"};
85
86extern FunctionRNA *rna_NodeSocket_draw_func;
87extern FunctionRNA *rna_NodeSocket_draw_color_func;
88extern FunctionRNA *rna_NodeSocket_draw_color_simple_func;
89
90/* ******** Node Socket ******** */
91
92static void rna_NodeSocket_draw(
93 bContext *C, ui::Layout *layout, PointerRNA *ptr, PointerRNA *node_ptr, const StringRef text)
94{
95 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
97 FunctionRNA *func;
98
99 func = rna_NodeSocket_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */
100
101 RNA_parameter_list_create(&list, ptr, func);
102 RNA_parameter_set_lookup(&list, "context", &C);
103 RNA_parameter_set_lookup(&list, "layout", &layout);
104 RNA_parameter_set_lookup(&list, "node", node_ptr);
105 const std::string text_str = text;
106 const char *text_c_str = text_str.c_str();
107 RNA_parameter_set_lookup(&list, "text", &text_c_str);
108 sock->typeinfo->ext_socket.call(C, ptr, func, &list);
109
111}
112
113static void rna_NodeSocket_draw_color(bContext *C,
114 PointerRNA *ptr,
115 PointerRNA *node_ptr,
116 float *r_color)
117{
118 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
120 FunctionRNA *func;
121 void *ret;
122
123 func = rna_NodeSocket_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */
124
125 RNA_parameter_list_create(&list, ptr, func);
126 RNA_parameter_set_lookup(&list, "context", &C);
127 RNA_parameter_set_lookup(&list, "node", node_ptr);
128 sock->typeinfo->ext_socket.call(C, ptr, func, &list);
129
130 RNA_parameter_get_lookup(&list, "color", &ret);
131 copy_v4_v4(r_color, static_cast<float *>(ret));
132
134}
135
136static void rna_NodeSocket_draw_color_simple(const bke::bNodeSocketType *socket_type,
137 float *r_color)
138{
140 FunctionRNA *func;
141 void *ret;
142
143 func = rna_NodeSocket_draw_color_simple_func; /* RNA_struct_find_function(&ptr,
144 * "draw_color_simple"); */
145
146 PointerRNA ptr = RNA_pointer_create_discrete(nullptr, socket_type->ext_socket.srna, nullptr);
147 RNA_parameter_list_create(&list, &ptr, func);
148 RNA_parameter_set_lookup(&list, "type", socket_type);
149 socket_type->ext_socket.call(nullptr, &ptr, func, &list);
150
151 RNA_parameter_get_lookup(&list, "color", &ret);
152 copy_v4_v4(r_color, static_cast<float *>(ret));
153
155}
156
157static bool rna_NodeSocket_unregister(Main *bmain, StructRNA *type)
158{
159 bke::bNodeSocketType *st = static_cast<bke::bNodeSocketType *>(
161 if (!st) {
162 return false;
163 }
165 ui::refresh_for_srna_unregister(bmain, st->ext_interface.srna);
166 ui::refresh_for_srna_unregister(bmain, st->ext_socket.srna);
167 RNA_struct_free_extension(type, &st->ext_socket);
169
171
172 /* update while blender is running */
175 return true;
176}
177
178static StructRNA *rna_NodeSocket_register(Main *bmain,
179 ReportList *reports,
180 void *data,
181 const char *identifier,
182 StructValidateFunc validate,
185{
187 bNodeSocket dummy_sock = {};
188 bool have_function[3];
189
190 /* setup dummy socket & socket type to store static properties in */
191 bke::bNodeSocketType dummy_st = {};
192 dummy_st.type = SOCK_CUSTOM;
193
194 dummy_sock.typeinfo = &dummy_st;
195 PointerRNA dummy_sock_ptr = RNA_pointer_create_discrete(nullptr, RNA_NodeSocket, &dummy_sock);
196
197 /* validate the python class */
198 if (validate(&dummy_sock_ptr, data, have_function) != 0) {
199 return nullptr;
200 }
201
202 if (strlen(identifier) >= sizeof(dummy_sock.idname)) {
203 BKE_reportf(reports,
204 RPT_ERROR,
205 "Registering node socket class: '%s' is too long, maximum length is %d",
206 identifier,
207 int(sizeof(dummy_sock.idname)));
208 return nullptr;
209 }
210
211 /* check if we have registered this socket type before */
212 st = bke::node_socket_type_find(dummy_st.idname.ref());
213 if (!st) {
214 /* create a new node socket type */
215 st = MEM_new<bke::bNodeSocketType>(__func__, dummy_st);
217 }
218
219 st->free_self = [](bke::bNodeSocketType *stype) { MEM_delete(stype); };
220
221 /* if RNA type is already registered, unregister first */
222 if (st->ext_socket.srna) {
223 StructRNA *srna = st->ext_socket.srna;
224 RNA_struct_free_extension(srna, &st->ext_socket);
226 }
227 st->ext_socket.srna = RNA_def_struct_ptr(
228 &RNA_blender_rna_get(), st->idname.c_str(), RNA_NodeSocket);
229 st->ext_socket.data = data;
230 st->ext_socket.call = call;
231 st->ext_socket.free = free;
232 RNA_struct_blender_type_set(st->ext_socket.srna, st);
233
234 /* XXX bad level call! needed to initialize the basic draw functions ... */
236
237 st->draw = (have_function[0]) ? rna_NodeSocket_draw : nullptr;
238 st->draw_color = (have_function[1]) ? rna_NodeSocket_draw_color : nullptr;
239 st->draw_color_simple = (have_function[2]) ? rna_NodeSocket_draw_color_simple : nullptr;
240
241 /* update while blender is running */
244 return st->ext_socket.srna;
245}
246
247static StructRNA *rna_NodeSocket_refine(PointerRNA *ptr)
248{
249 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
250
251 if (sock->typeinfo->ext_socket.srna) {
252 return sock->typeinfo->ext_socket.srna;
253 }
254 else {
255 return RNA_NodeSocket;
256 }
257}
258
259static std::optional<std::string> rna_NodeSocket_path(const PointerRNA *ptr)
260{
261 const bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
262 const bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
263
264 const bNode &node = bke::node_find_node(*ntree, *sock);
265 const ListBaseT<bNodeSocket> *sockets = (sock->in_out == SOCK_IN) ? &node.inputs : &node.outputs;
266 const int socketindex = BLI_findindex(sockets, sock);
267
268 char name_esc[sizeof(node.name) * 2];
269 BLI_str_escape(name_esc, node.name, sizeof(name_esc));
270
271 if (sock->in_out == SOCK_IN) {
272 return fmt::format("nodes[\"{}\"].inputs[{}]", name_esc, socketindex);
273 }
274 return fmt::format("nodes[\"{}\"].outputs[{}]", name_esc, socketindex);
275}
276
277static IDProperty **rna_NodeSocket_idprops(PointerRNA *ptr)
278{
279 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
280 return &sock->prop;
281}
282
283static PointerRNA rna_NodeSocket_node_get(PointerRNA *ptr)
284{
285 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
286 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
287 bNode &node = bke::node_find_node(*ntree, *sock);
288 return RNA_pointer_create_discrete(&ntree->id, RNA_Node, &node);
289}
290
291static void rna_NodeSocket_type_set(PointerRNA *ptr, int value)
292{
293 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
294 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
295 bNode &node = bke::node_find_node(*ntree, *sock);
296 if (node.type_legacy != NODE_CUSTOM) {
297 /* Can't change the socket type on built-in nodes like this. */
298 return;
299 }
300 bke::node_modify_socket_type_static(ntree, &node, sock, value, 0);
301}
302
303static int rna_NodeSocket_inferred_structure_type_get(PointerRNA *ptr)
304{
305 bNodeSocket *socket = ptr->data_as<bNodeSocket>();
306 return int(socket->runtime->inferred_structure_type);
307}
308
309static void rna_NodeSocket_bl_idname_get(PointerRNA *ptr, char *value)
310{
311 const bNodeSocket *node = static_cast<const bNodeSocket *>(ptr->data);
312 const bke::bNodeSocketType *ntype = node->typeinfo;
313 ntype->idname.ref().copy_unsafe(value);
314}
315
316static int rna_NodeSocket_bl_idname_length(PointerRNA *ptr)
317{
318 const bNodeSocket *node = static_cast<const bNodeSocket *>(ptr->data);
319 const bke::bNodeSocketType *ntype = node->typeinfo;
320 return ntype->idname.size();
321}
322
323static void rna_NodeSocket_bl_idname_set(PointerRNA *ptr, const char *value)
324{
325 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
326 bke::bNodeSocketType *ntype = sock->typeinfo;
327
328 if (ntype->type != SOCK_CUSTOM) {
330 &LOG, "Cannot modify 'bl_idname' of built-in socket type '%s'", ntype->idname.c_str());
331 return;
332 }
333
334 ntype->idname = UString(value);
335}
336
337static void rna_NodeSocket_bl_label_get(PointerRNA *ptr, char *value)
338{
339 const bNodeSocket *node = static_cast<const bNodeSocket *>(ptr->data);
340 const bke::bNodeSocketType *ntype = node->typeinfo;
341 StringRef(ntype->label).copy_unsafe(value);
342}
343
344static int rna_NodeSocket_bl_label_length(PointerRNA *ptr)
345{
346 const bNodeSocket *node = static_cast<const bNodeSocket *>(ptr->data);
347 const bke::bNodeSocketType *ntype = node->typeinfo;
348 return ntype->label.size();
349}
350
351static void rna_NodeSocket_bl_label_set(PointerRNA *ptr, const char *value)
352{
353 bNodeSocket *node = static_cast<bNodeSocket *>(ptr->data);
354 bke::bNodeSocketType *ntype = node->typeinfo;
355 ntype->label = value;
356}
357
358static void rna_NodeSocket_bl_subtype_label_get(PointerRNA *ptr, char *value)
359{
360 const bNodeSocket *node = static_cast<const bNodeSocket *>(ptr->data);
361 const bke::bNodeSocketType *ntype = node->typeinfo;
362 StringRef(ntype->subtype_label).copy_unsafe(value);
363}
364
365static int rna_NodeSocket_bl_subtype_label_length(PointerRNA *ptr)
366{
367 const bNodeSocket *node = static_cast<const bNodeSocket *>(ptr->data);
368 const bke::bNodeSocketType *ntype = node->typeinfo;
369 return ntype->subtype_label.size();
370}
371
372static void rna_NodeSocket_bl_subtype_label_set(PointerRNA *ptr, const char *value)
373{
374 bNodeSocket *node = static_cast<bNodeSocket *>(ptr->data);
375 bke::bNodeSocketType *ntype = node->typeinfo;
376 ntype->subtype_label = value;
377}
378
379static bool rna_NodeSocket_is_linked_get(PointerRNA *ptr)
380{
381 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
382 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
383 ntree->ensure_topology_cache();
384 return sock->is_directly_linked();
385}
386
387static bool rna_NodeSocket_is_inactive_get(PointerRNA *ptr)
388{
389 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
390 bNodeSocket *sock = ptr->data_as<bNodeSocket>();
391 ntree->ensure_topology_cache();
392 return sock->is_inactive();
393}
394
395static bool rna_NodeSocket_is_icon_visible_get(PointerRNA *ptr)
396{
397 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
398 bNodeSocket *sock = ptr->data_as<bNodeSocket>();
399 ntree->ensure_topology_cache();
400 return sock->is_icon_visible();
401}
402
403static void rna_NodeSocket_update(Main *bmain, Scene * /*scene*/, PointerRNA *ptr)
404{
405 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
406 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
407
409 BKE_main_ensure_invariants(*bmain, ntree->id);
410}
411
412static void rna_NodeSocket_enabled_update(Main *bmain, Scene * /*scene*/, PointerRNA *ptr)
413{
414 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
415 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
416
418 BKE_main_ensure_invariants(*bmain, ntree->id);
419}
420
421static void rna_NodeSocket_label_get(PointerRNA *ptr, char *value)
422{
423 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
424 strcpy(value, bke::node_socket_label(*sock).c_str());
425}
426
427static int rna_NodeSocket_label_length(PointerRNA *ptr)
428{
429 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
430 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
431 /* Socket label may require the owner_node pointer. */
432 ntree->ensure_topology_cache();
433 return bke::node_socket_label(*sock).size();
434}
435
436static bool rna_NodeSocket_is_output_get(PointerRNA *ptr)
437{
438 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
439 return sock->in_out == SOCK_OUT;
440}
441
442static bool rna_NodeSocket_select_get(PointerRNA *ptr)
443{
444 const bNodeSocket *socket = ptr->data_as<bNodeSocket>();
445
446 return (socket->flag & SELECT) != 0;
447}
448
449static int rna_NodeSocket_link_limit_get(PointerRNA *ptr)
450{
451 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
452 return bke::node_socket_link_limit(*sock);
453}
454
455static void rna_NodeSocket_link_limit_set(PointerRNA *ptr, int value)
456{
457 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
458 sock->limit = (value == 0 ? 0xFFF : value);
459}
460
461static void rna_NodeSocket_hide_set(PointerRNA *ptr, bool value)
462{
463 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
464
465 /* don't hide linked sockets */
466 if (sock->flag & SOCK_IS_LINKED) {
467 return;
468 }
469
470 bNodeTree *ntree = reinterpret_cast<bNodeTree *>(ptr->owner_id);
471 bNode &node = bke::node_find_node(*ntree, *sock);
472
473 /* The Reroute node is the socket itself, do not hide this. */
474 if (node.is_reroute()) {
475 return;
476 }
477
478 if (value) {
479 sock->flag |= SOCK_HIDDEN;
480 sock->flag &= ~SOCK_SELECT;
481 }
482 else {
483 sock->flag &= ~SOCK_HIDDEN;
484 }
485}
486
487/* ******** Standard Node Socket Base Types ******** */
488
489static void rna_NodeSocketStandard_draw(ID *id,
490 bNodeSocket *sock,
491 bContext *C,
492 ui::Layout *layout,
493 PointerRNA *nodeptr,
494 const char *text)
495{
496 PointerRNA ptr = RNA_pointer_create_discrete(id, RNA_NodeSocket, sock);
497 sock->typeinfo->draw(C, layout, &ptr, nodeptr, text);
498}
499
500static void rna_NodeSocketStandard_draw_color(
501 ID *id, bNodeSocket *sock, bContext *C, PointerRNA *nodeptr, float r_color[4])
502{
503 PointerRNA ptr = RNA_pointer_create_discrete(id, RNA_NodeSocket, sock);
504 sock->typeinfo->draw_color(C, &ptr, nodeptr, r_color);
505}
506
507static void rna_NodeSocketStandard_draw_color_simple(StructRNA *type, float r_color[4])
508{
509 const bke::bNodeSocketType *typeinfo = static_cast<const bke::bNodeSocketType *>(
511 typeinfo->draw_color_simple(typeinfo, r_color);
512}
513
514static const char *rna_NodeSocketStandard_name_func(const PointerRNA *ptr,
515 const PropertyRNA * /*prop*/,
516 const bool do_translate)
517{
518 const bNodeSocket *socket = ptr->data_as<bNodeSocket>();
519 if (do_translate) {
521 }
522 return socket->name;
523}
524
525static const char *rna_NodeSocketStandard_description_func(const PointerRNA *ptr,
526 const PropertyRNA * /*prop*/,
527 const bool do_translate)
528{
529 const bNodeSocket *socket = ptr->data_as<bNodeSocket>();
530 if (do_translate) {
532 }
533 return socket->description;
534}
535
536/* ******** Node Socket Subtypes ******** */
537
538void rna_NodeSocketStandard_float_range(
539 PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
540{
541 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
542 bNodeSocketValueFloat *dval = static_cast<bNodeSocketValueFloat *>(sock->default_value);
543 int subtype = sock->typeinfo->subtype;
544
545 if (dval->max < dval->min) {
546 dval->max = dval->min;
547 }
548
549 *min = (subtype == PROP_UNSIGNED ? 0.0f : -FLT_MAX);
550 *max = FLT_MAX;
551 *softmin = dval->min;
552 *softmax = dval->max;
553}
554
555void rna_NodeSocketStandard_int_range(
556 PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
557{
558 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
559 bNodeSocketValueInt *dval = static_cast<bNodeSocketValueInt *>(sock->default_value);
560 int subtype = sock->typeinfo->subtype;
561
562 if (dval->max < dval->min) {
563 dval->max = dval->min;
564 }
565
566 *min = (subtype == PROP_UNSIGNED ? 0 : INT_MIN);
567 *max = INT_MAX;
568 *softmin = dval->min;
569 *softmax = dval->max;
570}
571
572void rna_NodeSocketStandard_vector_range(
573 PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
574{
575 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
576 bNodeSocketValueVector *dval = static_cast<bNodeSocketValueVector *>(sock->default_value);
577
578 if (dval->max < dval->min) {
579 dval->max = dval->min;
580 }
581
582 *min = -FLT_MAX;
583 *max = FLT_MAX;
584 *softmin = dval->min;
585 *softmax = dval->max;
586}
587
588void rna_NodeSocketStandard_int_vector_range(
589 PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
590{
591 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
592 bNodeSocketValueIntVector *dval = static_cast<bNodeSocketValueIntVector *>(sock->default_value);
593 int subtype = sock->typeinfo->subtype;
594
595 if (dval->max < dval->min) {
596 dval->max = dval->min;
597 }
598
599 *min = (subtype == PROP_UNSIGNED ? 0 : INT_MIN);
600 *max = INT_MAX;
601 *softmin = dval->min;
602 *softmax = dval->max;
603}
604
605float rna_NodeSocketStandard_float_default(PointerRNA *ptr, PropertyRNA * /*prop*/)
606{
607 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
608 if (!sock->runtime->declaration) {
609 return 0.0f;
610 }
611 auto *decl = static_cast<const nodes::decl::Float *>(sock->runtime->declaration);
612 return decl->default_value;
613}
614
615int rna_NodeSocketStandard_int_default(PointerRNA *ptr, PropertyRNA * /*prop*/)
616{
617 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
618 if (!sock->runtime->declaration) {
619 return 0;
620 }
621 auto *decl = static_cast<const nodes::decl::Int *>(sock->runtime->declaration);
622 return decl->default_value;
623}
624
625bool rna_NodeSocketStandard_boolean_default(PointerRNA *ptr, PropertyRNA * /*prop*/)
626{
627 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
628 if (!sock->runtime->declaration) {
629 return false;
630 }
631 auto *decl = static_cast<const nodes::decl::Bool *>(sock->runtime->declaration);
632 return decl->default_value;
633}
634
635void rna_NodeSocketStandard_vector_default(PointerRNA *ptr,
636 PropertyRNA * /*prop*/,
637 float *r_values)
638{
639 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
640 if (!sock->runtime->declaration) {
641 const int dimensions = sock->default_value_typed<bNodeSocketValueVector>()->dimensions;
642 std::fill_n(r_values, dimensions, 0.0f);
643 return;
644 }
645 auto *decl = static_cast<const nodes::decl::Vector *>(sock->runtime->declaration);
646 std::copy_n(&decl->default_value[0], decl->dimensions, r_values);
647}
648
649void rna_NodeSocketStandard_int_vector_default(PointerRNA *ptr,
650 PropertyRNA * /*prop*/,
651 int *r_values)
652{
653 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
654 if (!sock->runtime->declaration) {
655 const int dimensions = sock->default_value_typed<bNodeSocketValueIntVector>()->dimensions;
656 std::fill_n(r_values, dimensions, 0);
657 return;
658 }
659 auto *decl = static_cast<const nodes::decl::IntVector *>(sock->runtime->declaration);
660 std::copy_n(&decl->default_value[0], decl->dimensions, r_values);
661}
662
663void rna_NodeSocketStandard_color_default(PointerRNA *ptr, PropertyRNA * /*prop*/, float *r_values)
664{
665 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
666 if (!sock->runtime->declaration) {
667 std::fill_n(r_values, 4, 0.0f);
668 return;
669 }
670 auto *decl = static_cast<const nodes::decl::Color *>(sock->runtime->declaration);
671
672# if defined(__GNUC__) && !defined(__clang__)
673# pragma GCC diagnostic push
674# pragma GCC diagnostic ignored "-Warray-bounds"
675# endif
676
677 std::copy_n(&decl->default_value[0], 4, r_values);
678
679# if defined(__GNUC__) && !defined(__clang__)
680# pragma GCC diagnostic pop
681# endif
682}
683
684std::string rna_NodeSocketStandard_string_default(PointerRNA *ptr, PropertyRNA * /*prop*/)
685{
686 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
687 if (!sock->runtime->declaration) {
688 return "";
689 }
690 auto *decl = static_cast<const nodes::decl::String *>(sock->runtime->declaration);
691 return decl->default_value;
692}
693
694int rna_NodeSocketStandard_menu_default(PointerRNA *ptr, PropertyRNA * /*prop*/)
695{
696 bNodeSocket *sock = static_cast<bNodeSocket *>(ptr->data);
697 if (!sock->runtime->declaration) {
698 return 0;
699 }
700 auto *decl = static_cast<const nodes::decl::Menu *>(sock->runtime->declaration);
701 return decl->default_value.value;
702}
703
704/* using a context update function here, to avoid searching the node if possible */
705static void rna_NodeSocketStandard_value_update(bContext *C, PointerRNA *ptr)
706{
707 /* default update */
708 rna_NodeSocket_update(CTX_data_main(C), CTX_data_scene(C), ptr);
709}
710
711static void rna_NodeSocketStandard_value_and_relation_update(bContext *C, PointerRNA *ptr)
712{
713 rna_NodeSocketStandard_value_update(C, ptr);
714 Main *bmain = CTX_data_main(C);
716}
717
719 bool *r_free)
720{
721 EnumPropertyItem tmp = {0};
722 EnumPropertyItem *result = nullptr;
723 int totitem = 0;
724
725 for (const bke::RuntimeNodeEnumItem &item : enum_items.items) {
726 tmp.value = item.identifier;
727 /* Item name is unique and used as the RNA identifier as well.
728 * The integer value is persistent and unique and should be used
729 * when storing the enum value. */
730 tmp.identifier = item.name.c_str();
731 tmp.icon = item.icon;
732 tmp.name = item.name.c_str();
733 tmp.description = item.description.c_str();
734
735 RNA_enum_item_add(&result, &totitem, &tmp);
736 }
737
738 if (totitem == 0) {
739 *r_free = false;
741 }
742
743 RNA_enum_item_end(&result, &totitem);
744 *r_free = true;
745
746 return result;
747}
748
749const EnumPropertyItem *RNA_node_socket_menu_itemf(bContext * /*C*/,
750 PointerRNA *ptr,
751 PropertyRNA *prop,
752 bool *r_free)
753{
754 const bNodeSocket *socket = static_cast<bNodeSocket *>(ptr->data);
755 if (!socket) {
756 *r_free = false;
758 }
759 const bNodeSocketValueMenu *data = static_cast<bNodeSocketValueMenu *>(socket->default_value);
760 if (!data->enum_items) {
761 *r_free = false;
763 }
764 const char *socket_translation_context = bke::node_socket_translation_context(*socket);
765 RNA_def_property_translation_context(prop, socket_translation_context);
766 return RNA_node_enum_definition_itemf(*data->enum_items, r_free);
767}
768
769std::optional<std::string> rna_NodeSocketString_filepath_filter(const bContext * /*C*/,
770 PointerRNA *ptr,
771 PropertyRNA * /*prop*/)
772{
773 bNodeSocket *socket = static_cast<bNodeSocket *>(ptr->data);
774 BLI_assert(socket->type == SOCK_STRING);
775 if (const auto *decl = dynamic_cast<const nodes::decl::String *>(socket->runtime->declaration)) {
776 return decl->path_filter;
777 }
778 return std::nullopt;
779}
780
781} // namespace blender
782
783#else
784
785namespace blender {
786
788{
789 StructRNA *srna;
790 PropertyRNA *prop;
791 PropertyRNA *parm;
792 FunctionRNA *func;
793
794 static const EnumPropertyItem rna_enum_node_socket_display_shape_items[] = {
795 {SOCK_DISPLAY_SHAPE_CIRCLE, "CIRCLE", 0, "Circle", ""},
796 {SOCK_DISPLAY_SHAPE_SQUARE, "SQUARE", 0, "Square", ""},
797 {SOCK_DISPLAY_SHAPE_DIAMOND, "DIAMOND", 0, "Diamond", ""},
798 {SOCK_DISPLAY_SHAPE_CIRCLE_DOT, "CIRCLE_DOT", 0, "Circle with inner dot", ""},
799 {SOCK_DISPLAY_SHAPE_SQUARE_DOT, "SQUARE_DOT", 0, "Square with inner dot", ""},
800 {SOCK_DISPLAY_SHAPE_DIAMOND_DOT, "DIAMOND_DOT", 0, "Diamond with inner dot", ""},
801 {SOCK_DISPLAY_SHAPE_LINE, "LINE", 0, "Line", ""},
802 {SOCK_DISPLAY_SHAPE_VOLUME_GRID, "VOLUME_GRID", 0, "Volume Grid", ""},
803 {SOCK_DISPLAY_SHAPE_LIST, "LIST", 0, "List", ""},
804 {0, nullptr, 0, nullptr, nullptr}};
805
806 static const float default_draw_color[] = {0.0f, 0.0f, 0.0f, 1.0f};
807
808 srna = RNA_def_struct(brna, "NodeSocket", nullptr);
809 RNA_def_struct_ui_text(srna, "Node Socket", "Input or output socket of a node");
810 RNA_def_struct_sdna(srna, "bNodeSocket");
811 RNA_def_struct_refine_func(srna, "rna_NodeSocket_refine");
812 RNA_def_struct_ui_icon(srna, ICON_NONE);
813 RNA_def_struct_path_func(srna, "rna_NodeSocket_path");
815 srna, "rna_NodeSocket_register", "rna_NodeSocket_unregister", nullptr);
816 RNA_def_struct_system_idprops_func(srna, "rna_NodeSocket_idprops");
817
818 prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
819 RNA_def_property_ui_text(prop, "Name", "Socket name");
821 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocket_update");
822
823 prop = RNA_def_property(srna, "label", PROP_STRING, PROP_NONE);
825 prop, "rna_NodeSocket_label_get", "rna_NodeSocket_label_length", nullptr);
828 "Label",
829 "Custom dynamic defined UI label for the socket. Can be translated if "
830 "translation is enabled in the preferences");
831
832 prop = RNA_def_property(srna, "identifier", PROP_STRING, PROP_NONE);
833 RNA_def_property_string_sdna(prop, nullptr, "identifier");
835 RNA_def_property_ui_text(prop, "Identifier", "Unique identifier for mapping sockets");
836
837 prop = RNA_def_property(srna, "description", PROP_STRING, PROP_NONE);
838 RNA_def_property_string_sdna(prop, nullptr, "description");
839 RNA_def_property_ui_text(prop, "Tooltip", "Socket tooltip");
840 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocket_update");
841
842 prop = RNA_def_property(srna, "is_output", PROP_BOOLEAN, PROP_NONE);
843 RNA_def_property_boolean_funcs(prop, "rna_NodeSocket_is_output_get", nullptr);
845 RNA_def_property_ui_text(prop, "Is Output", "True if the socket is an output, otherwise input");
846
847 prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
848 RNA_def_property_boolean_funcs(prop, "rna_NodeSocket_select_get", nullptr);
850 RNA_def_property_ui_text(prop, "Select", "True if the socket is selected");
851
852 prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
853 RNA_def_property_boolean_sdna(prop, nullptr, "flag", SOCK_HIDDEN);
854 RNA_def_property_boolean_funcs(prop, nullptr, "rna_NodeSocket_hide_set");
855 RNA_def_property_ui_text(prop, "Hide", "Hide the socket");
857
858 prop = RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
860 RNA_def_property_ui_text(prop, "Enabled", "Enable the socket");
861 RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, "rna_NodeSocket_enabled_update");
862
863 prop = RNA_def_property(srna, "link_limit", PROP_INT, PROP_NONE);
864 RNA_def_property_int_sdna(prop, nullptr, "limit");
866 prop, "rna_NodeSocket_link_limit_get", "rna_NodeSocket_link_limit_set", nullptr);
867 RNA_def_property_range(prop, 1, 0xFFF);
868 RNA_def_property_ui_text(prop, "Link Limit", "Max number of links allowed for this socket");
869 RNA_def_property_update(prop, NC_NODE | NA_EDITED, nullptr);
870
871 prop = RNA_def_property(srna, "is_linked", PROP_BOOLEAN, PROP_NONE);
872 RNA_def_property_boolean_funcs(prop, "rna_NodeSocket_is_linked_get", nullptr);
874 RNA_def_property_ui_text(prop, "Linked", "True if the socket is connected");
875
876 prop = RNA_def_property(srna, "is_unavailable", PROP_BOOLEAN, PROP_NONE);
877 RNA_def_property_boolean_sdna(prop, nullptr, "flag", SOCK_UNAVAIL);
879 RNA_def_property_ui_text(prop, "Unavailable", "True if the socket is unavailable");
880
881 prop = RNA_def_property(srna, "is_multi_input", PROP_BOOLEAN, PROP_NONE);
882 RNA_def_property_boolean_sdna(prop, nullptr, "flag", SOCK_MULTI_INPUT);
885 prop, "Multi Input", "True if the socket can accept multiple ordered input links");
886
887 prop = RNA_def_property(srna, "show_expanded", PROP_BOOLEAN, PROP_NONE);
890 RNA_def_property_ui_text(prop, "Expanded", "Socket links are expanded in the user interface");
891 RNA_def_property_update(prop, NC_NODE | NA_EDITED, nullptr);
892
893 prop = RNA_def_property(srna, "is_inactive", PROP_BOOLEAN, PROP_NONE);
895 RNA_def_property_boolean_funcs(prop, "rna_NodeSocket_is_inactive_get", nullptr);
897 prop,
898 "Inactive",
899 "Socket is grayed out because it has been detected to not have any effect on the output");
900
901 prop = RNA_def_property(srna, "is_icon_visible", PROP_BOOLEAN, PROP_NONE);
903 RNA_def_property_boolean_funcs(prop, "rna_NodeSocket_is_icon_visible_get", nullptr);
905 prop, "Icon Visible", "Socket is drawn as interactive icon in the node editor");
906
907 prop = RNA_def_property(srna, "hide_value", PROP_BOOLEAN, PROP_NONE);
908 RNA_def_property_boolean_sdna(prop, nullptr, "flag", SOCK_HIDE_VALUE);
909 RNA_def_property_ui_text(prop, "Hide Value", "Hide the socket input value");
911
912 prop = RNA_def_property(srna, "pin_gizmo", PROP_BOOLEAN, PROP_NONE);
913 RNA_def_property_boolean_sdna(prop, nullptr, "flag", SOCK_GIZMO_PIN);
916 prop, "Pin Gizmo", "Keep gizmo visible even when the node is not selected");
918
919 prop = RNA_def_property(srna, "node", PROP_POINTER, PROP_NONE);
920 RNA_def_property_pointer_funcs(prop, "rna_NodeSocket_node_get", nullptr, nullptr, nullptr);
921 RNA_def_property_struct_type(prop, "Node");
925 RNA_def_property_ui_text(prop, "Node", "Node owning this socket");
926
927 /* NOTE: The type property is used by standard sockets.
928 * Ideally should be defined only for the registered subclass,
929 * but to use the existing DNA is added in the base type here.
930 * Future socket types can ignore or override this if needed. */
931
932 prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
933 RNA_def_property_enum_sdna(prop, nullptr, "type");
936 RNA_def_property_enum_funcs(prop, nullptr, "rna_NodeSocket_type_set", nullptr);
937 RNA_def_property_ui_text(prop, "Type", "Data type");
938 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocket_update");
939
940 prop = RNA_def_property(srna, "display_shape", PROP_ENUM, PROP_NONE);
941 RNA_def_property_enum_sdna(prop, nullptr, "display_shape");
942 RNA_def_property_enum_items(prop, rna_enum_node_socket_display_shape_items);
944 RNA_def_property_ui_text(prop, "Shape", "Socket shape");
945 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocket_update");
946
947 prop = RNA_def_property(srna, "inferred_structure_type", PROP_ENUM, PROP_NONE);
951 prop, "rna_NodeSocket_inferred_structure_type_get", nullptr, nullptr);
953 "Inferred Structure Type",
954 "Best known structure type of the socket. This may not match the "
955 "socket shape, e.g. for unlinked input sockets");
956
957 /* registration */
958 prop = RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
960 "rna_NodeSocket_bl_idname_get",
961 "rna_NodeSocket_bl_idname_length",
962 "rna_NodeSocket_bl_idname_set");
964 RNA_def_property_ui_text(prop, "ID Name", "");
965
966 prop = RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
968 "rna_NodeSocket_bl_label_get",
969 "rna_NodeSocket_bl_label_length",
970 "rna_NodeSocket_bl_label_set");
972 RNA_def_property_ui_text(prop, "Type Label", "Label to display for the socket type in the UI");
973
974 prop = RNA_def_property(srna, "bl_subtype_label", PROP_STRING, PROP_NONE);
976 "rna_NodeSocket_bl_subtype_label_get",
977 "rna_NodeSocket_bl_subtype_label_length",
978 "rna_NodeSocket_bl_subtype_label_set");
981 prop, "Subtype Label", "Label to display for the socket subtype in the UI");
982
983 /* draw socket */
984 func = RNA_def_function(srna, "draw", nullptr);
985 RNA_def_function_ui_description(func, "Draw socket");
987 parm = RNA_def_pointer(func, "context", "Context", "", "");
989 parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE);
990 RNA_def_property_struct_type(parm, "UILayout");
991 RNA_def_property_ui_text(parm, "Layout", "Layout in the UI");
993 parm = RNA_def_property(func, "node", PROP_POINTER, PROP_NONE);
994 RNA_def_property_struct_type(parm, "Node");
995 RNA_def_property_ui_text(parm, "Node", "Node the socket belongs to");
997 parm = RNA_def_property(func, "text", PROP_STRING, PROP_NONE);
998 RNA_def_property_ui_text(parm, "Text", "Text label to draw alongside properties");
999 // RNA_def_property_string_default(parm, "");
1001
1002 func = RNA_def_function(srna, "draw_color", nullptr);
1003 RNA_def_function_ui_description(func, "Color of the socket icon");
1005 parm = RNA_def_pointer(func, "context", "Context", "", "");
1007 parm = RNA_def_property(func, "node", PROP_POINTER, PROP_NONE);
1008 RNA_def_property_struct_type(parm, "Node");
1009 RNA_def_property_ui_text(parm, "Node", "Node the socket belongs to");
1011 parm = RNA_def_float_array(
1012 func, "color", 4, default_draw_color, 0.0f, 1.0f, "Color", "", 0.0f, 1.0f);
1013 RNA_def_function_output(func, parm);
1014
1015 func = RNA_def_function(srna, "draw_color_simple", nullptr);
1017 func,
1018 "Color of the socket icon. Used to draw sockets in places where the socket does not belong "
1019 "to a node, like the node interface panel. Also used to draw node sockets if draw_color is "
1020 "not defined.");
1022 parm = RNA_def_float_array(
1023 func, "color", 4, default_draw_color, 0.0f, 1.0f, "Color", "", 0.0f, 1.0f);
1024 RNA_def_function_output(func, parm);
1025}
1026
1028{
1029 /* XXX Workaround: Registered functions are not exposed in python by bpy,
1030 * it expects them to be registered from python and use the native implementation.
1031 * However, the standard socket types below are not registering these functions from python,
1032 * so in order to call them in py scripts we need to overload and
1033 * replace them with plain C callbacks.
1034 * These types provide a usable basis for socket types defined in C.
1035 */
1036
1037 StructRNA *srna;
1038 PropertyRNA *parm;
1039 FunctionRNA *func;
1040
1041 static const float default_draw_color[] = {0.0f, 0.0f, 0.0f, 1.0f};
1042
1043 srna = RNA_def_struct(brna, "NodeSocketStandard", "NodeSocket");
1044 RNA_def_struct_sdna(srna, "bNodeSocket");
1045
1046 /* draw socket */
1047 func = RNA_def_function(srna, "draw", "rna_NodeSocketStandard_draw");
1049 RNA_def_function_ui_description(func, "Draw socket");
1050 parm = RNA_def_pointer(func, "context", "Context", "", "");
1052 parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE);
1053 RNA_def_property_struct_type(parm, "UILayout");
1054 RNA_def_property_ui_text(parm, "Layout", "Layout in the UI");
1056 parm = RNA_def_property(func, "node", PROP_POINTER, PROP_NONE);
1057 RNA_def_property_struct_type(parm, "Node");
1058 RNA_def_property_ui_text(parm, "Node", "Node the socket belongs to");
1060 parm = RNA_def_property(func, "text", PROP_STRING, PROP_NONE);
1061 RNA_def_property_ui_text(parm, "Text", "Text label to draw alongside properties");
1062 // RNA_def_property_string_default(parm, "");
1064
1065 func = RNA_def_function(srna, "draw_color", "rna_NodeSocketStandard_draw_color");
1067 RNA_def_function_ui_description(func, "Color of the socket icon");
1068 parm = RNA_def_pointer(func, "context", "Context", "", "");
1070 parm = RNA_def_property(func, "node", PROP_POINTER, PROP_NONE);
1071 RNA_def_property_struct_type(parm, "Node");
1072 RNA_def_property_ui_text(parm, "Node", "Node the socket belongs to");
1074 parm = RNA_def_float_array(
1075 func, "color", 4, default_draw_color, 0.0f, 1.0f, "Color", "", 0.0f, 1.0f);
1076 RNA_def_function_output(func, parm);
1077
1078 func = RNA_def_function(srna, "draw_color_simple", "rna_NodeSocketStandard_draw_color_simple");
1079 RNA_def_function_ui_description(func, "Color of the socket icon");
1081 parm = RNA_def_float_array(
1082 func, "color", 4, default_draw_color, 0.0f, 1.0f, "Color", "", 0.0f, 1.0f);
1083 RNA_def_function_output(func, parm);
1084}
1085
1086/* Common functions for all builtin socket interface types. */
1088{
1089 FunctionRNA *func;
1090 PropertyRNA *parm;
1091
1092 /* Override for functions, invoking the typeinfo callback directly
1093 * instead of expecting an existing RNA registered function implementation.
1094 */
1095
1096 func = RNA_def_function(srna, "draw", "rna_NodeTreeInterfaceSocket_draw_builtin");
1098 RNA_def_function_ui_description(func, "Draw interface socket settings");
1099 parm = RNA_def_pointer(func, "context", "Context", "", "");
1101 parm = RNA_def_property(func, "layout", PROP_POINTER, PROP_NONE);
1102 RNA_def_property_struct_type(parm, "UILayout");
1103 RNA_def_property_ui_text(parm, "Layout", "Layout in the UI");
1105
1106 func = RNA_def_function(srna, "init_socket", "rna_NodeTreeInterfaceSocket_init_socket_builtin");
1107 RNA_def_function_ui_description(func, "Initialize a node socket instance");
1109 parm = RNA_def_pointer(func, "node", "Node", "Node", "Node of the socket to initialize");
1111 parm = RNA_def_pointer(func, "socket", "NodeSocket", "Socket", "Socket to initialize");
1113 parm = RNA_def_string(
1114 func, "data_path", nullptr, 0, "Data Path", "Path to specialized socket data");
1116
1117 func = RNA_def_function(srna, "from_socket", "rna_NodeTreeInterfaceSocket_from_socket_builtin");
1118 RNA_def_function_ui_description(func, "Setup template parameters from an existing socket");
1120 parm = RNA_def_pointer(func, "node", "Node", "Node", "Node of the original socket");
1122 parm = RNA_def_pointer(func, "socket", "NodeSocket", "Socket", "Original socket");
1124}
1125
1127 const char *identifier,
1128 PropertySubType subtype)
1129{
1130 StructRNA *srna;
1131 PropertyRNA *prop;
1132
1133 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1134 RNA_def_struct_ui_text(srna, "Float Node Socket", "Floating-point number socket of a node");
1135 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_FLOAT);
1136 RNA_def_struct_sdna(srna, "bNodeSocket");
1137
1138 RNA_def_struct_sdna_from(srna, "bNodeSocketValueFloat", "default_value");
1139
1140 prop = RNA_def_property(srna, "default_value", PROP_FLOAT, subtype);
1141 RNA_def_property_float_sdna(prop, nullptr, "value");
1142 RNA_def_property_float_funcs(prop, nullptr, nullptr, "rna_NodeSocketStandard_float_range");
1143 RNA_def_property_float_default_func(prop, "rna_NodeSocketStandard_float_default");
1144 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
1145 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
1146 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update");
1148
1149 RNA_def_struct_sdna_from(srna, "bNodeSocket", nullptr);
1150}
1151
1153 const char *identifier,
1154 PropertySubType subtype)
1155{
1156 StructRNA *srna;
1157 PropertyRNA *prop;
1158 float value_default;
1159
1160 /* choose sensible common default based on subtype */
1161 switch (subtype) {
1162 case PROP_FACTOR:
1163 value_default = 1.0f;
1164 break;
1165 case PROP_PERCENTAGE:
1166 value_default = 100.0f;
1167 break;
1168 default:
1169 value_default = 0.0f;
1170 break;
1171 }
1172
1173 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
1175 srna, "Float Node Socket Interface", "Floating-point number socket of a node");
1176 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
1177
1178 RNA_def_struct_sdna_from(srna, "bNodeSocketValueFloat", "socket_data");
1179
1180 prop = RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
1182 RNA_def_property_enum_sdna(prop, nullptr, "subtype");
1184 prop, nullptr, nullptr, "rna_NodeTreeInterfaceSocketFloat_subtype_itemf");
1186 RNA_def_property_ui_text(prop, "Subtype", "Subtype of the default value");
1188 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_subtype_update");
1189
1190 prop = RNA_def_property(srna, "default_value", PROP_FLOAT, subtype);
1191 RNA_def_property_float_sdna(prop, nullptr, "value");
1192 RNA_def_property_float_default(prop, value_default);
1195 prop, nullptr, nullptr, "rna_NodeTreeInterfaceSocketFloat_default_value_range");
1196 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
1197 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1198
1199 prop = RNA_def_property(srna, "min_value", PROP_FLOAT, PROP_NONE);
1200 RNA_def_property_float_sdna(prop, nullptr, "min");
1202 RNA_def_property_ui_text(prop, "Minimum Value", "Minimum value");
1203 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1204
1205 prop = RNA_def_property(srna, "max_value", PROP_FLOAT, PROP_NONE);
1206 RNA_def_property_float_sdna(prop, nullptr, "max");
1208 RNA_def_property_ui_text(prop, "Maximum Value", "Maximum value");
1209 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1210
1211 RNA_def_struct_sdna_from(srna, "bNodeTreeInterfaceSocket", nullptr);
1212
1214}
1215
1217 const char *identifier,
1218 PropertySubType subtype)
1219{
1220 StructRNA *srna;
1221 PropertyRNA *prop;
1222 int value_default;
1223
1224 /* choose sensible common default based on subtype */
1225 switch (subtype) {
1226 case PROP_FACTOR:
1227 value_default = 1;
1228 break;
1229 case PROP_PERCENTAGE:
1230 value_default = 100;
1231 break;
1232 default:
1233 value_default = 0;
1234 break;
1235 }
1236
1237 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1238 RNA_def_struct_ui_text(srna, "Integer Node Socket", "Integer number socket of a node");
1239 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_INT);
1240 RNA_def_struct_sdna(srna, "bNodeSocket");
1241
1242 RNA_def_struct_sdna_from(srna, "bNodeSocketValueInt", "default_value");
1243
1244 prop = RNA_def_property(srna, "default_value", PROP_INT, subtype);
1245 RNA_def_property_int_sdna(prop, nullptr, "value");
1246 RNA_def_property_int_default(prop, value_default);
1247 RNA_def_property_int_funcs(prop, nullptr, nullptr, "rna_NodeSocketStandard_int_range");
1248 RNA_def_property_int_default_func(prop, "rna_NodeSocketStandard_int_default");
1249 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
1250 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
1251 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update");
1253
1254 RNA_def_struct_sdna_from(srna, "bNodeSocket", nullptr);
1255}
1256
1258 const char *identifier,
1259 PropertySubType subtype)
1260{
1261 StructRNA *srna;
1262 PropertyRNA *prop;
1263
1264 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
1265 RNA_def_struct_ui_text(srna, "Integer Node Socket Interface", "Integer number socket of a node");
1266 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
1267
1268 RNA_def_struct_sdna_from(srna, "bNodeSocketValueInt", "socket_data");
1269
1270 prop = RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
1272 RNA_def_property_enum_sdna(prop, nullptr, "subtype");
1274 prop, nullptr, nullptr, "rna_NodeTreeInterfaceSocketInt_subtype_itemf");
1276 RNA_def_property_ui_text(prop, "Subtype", "Subtype of the default value");
1278 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_subtype_update");
1279
1280 prop = RNA_def_property(srna, "default_value", PROP_INT, subtype);
1281 RNA_def_property_int_sdna(prop, nullptr, "value");
1284 prop, nullptr, nullptr, "rna_NodeTreeInterfaceSocketInt_default_value_range");
1285 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
1286 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1287
1288 prop = RNA_def_property(srna, "min_value", PROP_INT, PROP_NONE);
1289 RNA_def_property_int_sdna(prop, nullptr, "min");
1291 RNA_def_property_ui_text(prop, "Minimum Value", "Minimum value");
1292 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1293
1294 prop = RNA_def_property(srna, "max_value", PROP_INT, PROP_NONE);
1295 RNA_def_property_int_sdna(prop, nullptr, "max");
1297 RNA_def_property_ui_text(prop, "Maximum Value", "Maximum value");
1298 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1299
1300 RNA_def_struct_sdna_from(srna, "bNodeTreeInterfaceSocket", nullptr);
1301
1303}
1304
1305static void rna_def_node_socket_bool(BlenderRNA *brna, const char *identifier)
1306{
1307 StructRNA *srna;
1308 PropertyRNA *prop;
1309
1310 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1311 RNA_def_struct_ui_text(srna, "Boolean Node Socket", "Boolean value socket of a node");
1312 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_BOOLEAN);
1313 RNA_def_struct_sdna(srna, "bNodeSocket");
1314
1315 RNA_def_struct_sdna_from(srna, "bNodeSocketValueBoolean", "default_value");
1316
1317 prop = RNA_def_property(srna, "default_value", PROP_BOOLEAN, PROP_NONE);
1318 RNA_def_property_boolean_sdna(prop, nullptr, "value", 1);
1319 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
1320 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
1321 RNA_def_property_boolean_default_func(prop, "rna_NodeSocketStandard_boolean_default");
1322 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update");
1324
1325 RNA_def_struct_sdna_from(srna, "bNodeSocket", nullptr);
1326}
1327
1328static void rna_def_node_socket_interface_bool(BlenderRNA *brna, const char *identifier)
1329{
1330 StructRNA *srna;
1331 PropertyRNA *prop;
1332
1333 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
1334 RNA_def_struct_ui_text(srna, "Boolean Node Socket Interface", "Boolean value socket of a node");
1335 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
1336
1337 RNA_def_struct_sdna_from(srna, "bNodeSocketValueBoolean", "socket_data");
1338
1339 prop = RNA_def_property(srna, "default_value", PROP_BOOLEAN, PROP_NONE);
1340 RNA_def_property_boolean_sdna(prop, nullptr, "value", 1);
1342 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
1343 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1344
1345 RNA_def_struct_sdna_from(srna, "bNodeTreeInterfaceSocket", nullptr);
1346
1348}
1349
1350static void rna_def_node_socket_rotation(BlenderRNA *brna, const char *identifier)
1351{
1352 StructRNA *srna;
1353 PropertyRNA *prop;
1354
1355 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1356 RNA_def_struct_ui_text(srna, "Rotation Node Socket", "Rotation value socket of a node");
1357 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_ROTATION);
1358 RNA_def_struct_sdna(srna, "bNodeSocket");
1359
1360 RNA_def_struct_sdna_from(srna, "bNodeSocketValueRotation", "default_value");
1361
1362 prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_EULER);
1363 RNA_def_property_float_sdna(prop, nullptr, "value_euler");
1364 // RNA_def_property_array(prop, 3);
1365 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
1366 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
1367 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update");
1369
1370 RNA_def_struct_sdna_from(srna, "bNodeSocket", nullptr);
1371}
1372
1373static void rna_def_node_socket_interface_rotation(BlenderRNA *brna, const char *identifier)
1374{
1375 StructRNA *srna;
1376 PropertyRNA *prop;
1377
1378 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
1380 srna, "Rotation Node Socket Interface", "Rotation value socket of a node");
1381 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
1382
1383 RNA_def_struct_sdna_from(srna, "bNodeSocketValueRotation", "socket_data");
1384
1385 prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_EULER);
1386 RNA_def_property_float_sdna(prop, nullptr, "value_euler");
1388 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
1389 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1390
1391 RNA_def_struct_sdna_from(srna, "bNodeTreeInterfaceSocket", nullptr);
1392
1394}
1395
1396static void rna_def_node_socket_matrix(BlenderRNA *brna, const char *identifier)
1397{
1398 StructRNA *srna;
1399
1400 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1401 RNA_def_struct_ui_text(srna, "Matrix Node Socket", "Matrix value socket of a node");
1402 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_MATRIX);
1403 RNA_def_struct_sdna(srna, "bNodeSocket");
1404
1405 RNA_def_struct_sdna_from(srna, "bNodeSocket", nullptr);
1406}
1407
1408static void rna_def_node_socket_interface_matrix(BlenderRNA *brna, const char *identifier)
1409{
1410 StructRNA *srna;
1411
1412 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
1413 RNA_def_struct_ui_text(srna, "Matrix Node Socket Interface", "Matrix value socket of a node");
1414 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
1415
1416 RNA_def_struct_sdna_from(srna, "bNodeTreeInterfaceSocket", nullptr);
1417
1419}
1420
1422 const char *identifier,
1423 PropertySubType subtype,
1424 int dimensions)
1425{
1426 StructRNA *srna;
1427 PropertyRNA *prop;
1428
1429 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1430 RNA_def_struct_ui_text(srna, "Vector Node Socket", "3D vector socket of a node");
1431 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_VECTOR);
1432 RNA_def_struct_sdna(srna, "bNodeSocket");
1433
1434 RNA_def_struct_sdna_from(srna, "bNodeSocketValueVector", "default_value");
1435
1436 prop = RNA_def_property(srna, "default_value", PROP_FLOAT, subtype);
1437 RNA_def_property_float_sdna(prop, nullptr, "value");
1438 RNA_def_property_array(prop, dimensions);
1439 RNA_def_property_float_default_func(prop, "rna_NodeSocketStandard_vector_default");
1440 RNA_def_property_float_funcs(prop, nullptr, nullptr, "rna_NodeSocketStandard_vector_range");
1441 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
1442 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
1443 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update");
1445
1446 RNA_def_struct_sdna_from(srna, "bNodeSocket", nullptr);
1447}
1448
1450 const char *identifier,
1451 PropertySubType subtype,
1452 int dimensions)
1453{
1454 StructRNA *srna;
1455 PropertyRNA *prop;
1456
1457 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
1458 RNA_def_struct_ui_text(srna, "Vector Node Socket Interface", "3D vector socket of a node");
1459 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
1460
1461 RNA_def_struct_sdna_from(srna, "bNodeSocketValueVector", "socket_data");
1462
1463 prop = RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
1465 RNA_def_property_enum_sdna(prop, nullptr, "subtype");
1467 prop, nullptr, nullptr, "rna_NodeTreeInterfaceSocketVector_subtype_itemf");
1469 RNA_def_property_ui_text(prop, "Subtype", "Subtype of the default value");
1471 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_subtype_update");
1472
1473 prop = RNA_def_property(srna, "dimensions", PROP_INT, PROP_NONE);
1474 RNA_def_property_int_sdna(prop, nullptr, "dimensions");
1475 RNA_def_property_range(prop, 2, 4);
1477 RNA_def_property_ui_text(prop, "Dimensions", "Dimensions of the vector socket");
1478 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_subtype_update");
1479
1480 prop = RNA_def_property(srna, "default_value", PROP_FLOAT, subtype);
1481 RNA_def_property_float_sdna(prop, nullptr, "value");
1482 RNA_def_property_array(prop, dimensions);
1485 prop, nullptr, nullptr, "rna_NodeTreeInterfaceSocketVector_default_value_range");
1486 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
1487 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1488
1489 prop = RNA_def_property(srna, "min_value", PROP_FLOAT, PROP_NONE);
1490 RNA_def_property_float_sdna(prop, nullptr, "min");
1492 RNA_def_property_ui_text(prop, "Minimum Value", "Minimum value");
1493 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1494
1495 prop = RNA_def_property(srna, "max_value", PROP_FLOAT, PROP_NONE);
1496 RNA_def_property_float_sdna(prop, nullptr, "max");
1498 RNA_def_property_ui_text(prop, "Maximum Value", "Maximum value");
1499 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1500
1501 RNA_def_struct_sdna_from(srna, "bNodeTreeInterfaceSocket", nullptr);
1502
1504}
1505
1507 const char *identifier,
1508 PropertySubType subtype,
1509 int dimensions)
1510{
1511 StructRNA *srna;
1512 PropertyRNA *prop;
1513
1514 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1515 RNA_def_struct_ui_text(srna, "Integer Vector Node Socket", "Integer vector socket of a node");
1516 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_INT_VECTOR);
1517 RNA_def_struct_sdna(srna, "bNodeSocket");
1518
1519 RNA_def_struct_sdna_from(srna, "bNodeSocketValueIntVector", "default_value");
1520
1521 prop = RNA_def_property(srna, "default_value", PROP_INT, subtype);
1522 RNA_def_property_int_sdna(prop, nullptr, "value");
1523 RNA_def_property_array(prop, dimensions);
1524 RNA_def_property_int_default_func(prop, "rna_NodeSocketStandard_int_vector_default");
1525 RNA_def_property_int_funcs(prop, nullptr, nullptr, "rna_NodeSocketStandard_int_vector_range");
1526 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
1527 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
1528 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update");
1530
1531 RNA_def_struct_sdna_from(srna, "bNodeSocket", nullptr);
1532}
1533
1535 const char *identifier,
1536 PropertySubType subtype,
1537 int dimensions)
1538{
1539 StructRNA *srna;
1540 PropertyRNA *prop;
1541
1542 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
1544 srna, "Integer Vector Node Socket Interface", "Integer vector socket of a node");
1545 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
1546
1547 RNA_def_struct_sdna_from(srna, "bNodeSocketValueIntVector", "socket_data");
1548
1549 prop = RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
1551 RNA_def_property_enum_sdna(prop, nullptr, "subtype");
1553 prop, nullptr, nullptr, "rna_NodeTreeInterfaceSocketIntVector_subtype_itemf");
1555 RNA_def_property_ui_text(prop, "Subtype", "Subtype of the default value");
1557 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_subtype_update");
1558
1559 prop = RNA_def_property(srna, "dimensions", PROP_INT, PROP_NONE);
1560 RNA_def_property_int_sdna(prop, nullptr, "dimensions");
1561 RNA_def_property_range(prop, 2, 3);
1563 RNA_def_property_ui_text(prop, "Dimensions", "Dimensions of the integer vector socket");
1564 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_subtype_update");
1565
1566 prop = RNA_def_property(srna, "default_value", PROP_INT, subtype);
1567 RNA_def_property_int_sdna(prop, nullptr, "value");
1568 RNA_def_property_array(prop, dimensions);
1571 prop, nullptr, nullptr, "rna_NodeTreeInterfaceSocketIntVector_default_value_range");
1572 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
1573 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1574
1575 prop = RNA_def_property(srna, "min_value", PROP_INT, PROP_NONE);
1576 RNA_def_property_int_sdna(prop, nullptr, "min");
1578 RNA_def_property_ui_text(prop, "Minimum Value", "Minimum value");
1579 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1580
1581 prop = RNA_def_property(srna, "max_value", PROP_INT, PROP_NONE);
1582 RNA_def_property_int_sdna(prop, nullptr, "max");
1584 RNA_def_property_ui_text(prop, "Maximum Value", "Maximum value");
1585 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1586
1587 RNA_def_struct_sdna_from(srna, "bNodeTreeInterfaceSocket", nullptr);
1588
1590}
1591
1592static void rna_def_node_socket_color(BlenderRNA *brna, const char *identifier)
1593{
1594 StructRNA *srna;
1595 PropertyRNA *prop;
1596
1597 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1598 RNA_def_struct_ui_text(srna, "Color Node Socket", "RGBA color socket of a node");
1599 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_RGBA);
1600 RNA_def_struct_sdna(srna, "bNodeSocket");
1601
1602 RNA_def_struct_sdna_from(srna, "bNodeSocketValueRGBA", "default_value");
1603
1604 prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_COLOR);
1605 RNA_def_property_float_sdna(prop, nullptr, "value");
1606 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
1607 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
1608 RNA_def_property_float_default_func(prop, "rna_NodeSocketStandard_color_default");
1609 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update");
1611
1612 RNA_def_struct_sdna_from(srna, "bNodeSocket", nullptr);
1613}
1614
1615static void rna_def_node_socket_interface_color(BlenderRNA *brna, const char *identifier)
1616{
1617 StructRNA *srna;
1618 PropertyRNA *prop;
1619
1620 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
1621 RNA_def_struct_ui_text(srna, "Color Node Socket Interface", "RGBA color socket of a node");
1622 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
1623
1624 RNA_def_struct_sdna_from(srna, "bNodeSocketValueRGBA", "socket_data");
1625
1626 prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_COLOR);
1627 RNA_def_property_float_sdna(prop, nullptr, "value");
1629 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
1630 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1631
1632 RNA_def_struct_sdna_from(srna, "bNodeTreeInterfaceSocket", nullptr);
1633
1635}
1636
1638 const char *identifier,
1639 PropertySubType subtype)
1640{
1641 StructRNA *srna;
1642 PropertyRNA *prop;
1643
1644 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1645 RNA_def_struct_ui_text(srna, "String Node Socket", "String socket of a node");
1646 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_STRING);
1647 RNA_def_struct_sdna(srna, "bNodeSocket");
1648
1649 RNA_def_struct_sdna_from(srna, "bNodeSocketValueString", "default_value");
1650
1651 prop = RNA_def_property(srna, "default_value", PROP_STRING, subtype);
1652 RNA_def_property_string_sdna(prop, nullptr, "value");
1653 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
1654 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
1655 RNA_def_property_string_default_func(prop, "rna_NodeSocketStandard_string_default");
1656 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update");
1658
1659 if (subtype == PROP_FILEPATH) {
1661 RNA_def_property_string_filepath_filter_func(prop, "rna_NodeSocketString_filepath_filter");
1662 }
1663
1664 RNA_def_struct_sdna_from(srna, "bNodeSocket", nullptr);
1665}
1666
1668 const char *identifier,
1669 PropertySubType subtype)
1670{
1671 StructRNA *srna;
1672 PropertyRNA *prop;
1673
1674 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
1675 RNA_def_struct_ui_text(srna, "String Node Socket Interface", "String socket of a node");
1676 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
1677
1678 RNA_def_struct_sdna_from(srna, "bNodeSocketValueString", "socket_data");
1679
1680 prop = RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
1682 RNA_def_property_enum_sdna(prop, nullptr, "subtype");
1684 prop, nullptr, nullptr, "rna_NodeTreeInterfaceSocketString_subtype_itemf");
1686 RNA_def_property_ui_text(prop, "Subtype", "Subtype of the default value");
1688 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_subtype_update");
1689
1690 prop = RNA_def_property(srna, "default_value", PROP_STRING, subtype);
1691 RNA_def_property_string_sdna(prop, nullptr, "value");
1693 // TODO: Do I need to call RNA_def_property_string_funcs() ?
1694 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
1695 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1696
1697 if (subtype == PROP_FILEPATH) {
1699 }
1700
1701 RNA_def_struct_sdna_from(srna, "bNodeTreeInterfaceSocket", nullptr);
1702
1704}
1705
1706static void rna_def_node_socket_menu(BlenderRNA *brna, const char *identifier)
1707{
1708 StructRNA *srna;
1709 PropertyRNA *prop;
1710
1711 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1712 RNA_def_struct_ui_text(srna, "Menu Node Socket", "Menu socket of a node");
1713 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_MENU);
1714 RNA_def_struct_sdna(srna, "bNodeSocket");
1715
1716 RNA_def_struct_sdna_from(srna, "bNodeSocketValueMenu", "default_value");
1717
1718 prop = RNA_def_property(srna, "default_value", PROP_ENUM, PROP_NONE);
1719 RNA_def_property_enum_sdna(prop, nullptr, "value");
1721 RNA_def_property_enum_funcs(prop, nullptr, nullptr, "RNA_node_socket_menu_itemf");
1722 RNA_def_property_enum_default_func(prop, "rna_NodeSocketStandard_menu_default");
1723 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
1724 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
1725 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_update");
1728
1729 RNA_def_struct_sdna_from(srna, "bNodeSocket", nullptr);
1730}
1731
1732static void rna_def_node_socket_interface_menu(BlenderRNA *brna, const char *identifier)
1733{
1734 StructRNA *srna;
1735 PropertyRNA *prop;
1736
1737 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
1738 RNA_def_struct_ui_text(srna, "Menu Node Socket Interface", "Menu socket of a node");
1739 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
1740
1741 RNA_def_struct_sdna_from(srna, "bNodeSocketValueMenu", "socket_data");
1742
1743 prop = RNA_def_property(srna, "default_value", PROP_ENUM, PROP_NONE);
1744 RNA_def_property_enum_sdna(prop, nullptr, "value");
1746 RNA_def_property_enum_funcs(prop, nullptr, nullptr, "RNA_node_tree_interface_socket_menu_itemf");
1747 RNA_def_property_enum_default_func(prop, "RNA_node_tree_interface_socket_menu_default");
1749 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
1750 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1751
1752 RNA_def_struct_sdna_from(srna, "bNodeTreeInterfaceSocket", nullptr);
1753
1755}
1756
1757static void rna_def_node_socket_shader(BlenderRNA *brna, const char *identifier)
1758{
1759 StructRNA *srna;
1760
1761 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1762 RNA_def_struct_ui_text(srna, "Shader Node Socket", "Shader socket of a node");
1763 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_SHADER);
1764 RNA_def_struct_sdna(srna, "bNodeSocket");
1765}
1766
1767static void rna_def_node_socket_interface_shader(BlenderRNA *brna, const char *identifier)
1768{
1769 StructRNA *srna;
1770
1771 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
1772 RNA_def_struct_ui_text(srna, "Shader Node Socket Interface", "Shader socket of a node");
1773 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
1774
1776}
1777
1778static void rna_def_node_socket_object(BlenderRNA *brna, const char *identifier)
1779{
1780 StructRNA *srna;
1781 PropertyRNA *prop;
1782
1783 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1784 RNA_def_struct_ui_text(srna, "Object Node Socket", "Object socket of a node");
1785 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_OBJECT);
1786 RNA_def_struct_sdna(srna, "bNodeSocket");
1787
1788 RNA_def_struct_sdna_from(srna, "bNodeSocketValueObject", "default_value");
1789
1790 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
1791 RNA_def_property_pointer_sdna(prop, nullptr, "value");
1792 RNA_def_property_struct_type(prop, "Object");
1793 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
1794 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
1796 prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
1799}
1800
1801static void rna_def_node_socket_interface_object(BlenderRNA *brna, const char *identifier)
1802{
1803 StructRNA *srna;
1804 PropertyRNA *prop;
1805
1806 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
1807 RNA_def_struct_ui_text(srna, "Object Node Socket Interface", "Object socket of a node");
1808 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
1809
1810 RNA_def_struct_sdna_from(srna, "bNodeSocketValueObject", "socket_data");
1811
1812 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
1813 RNA_def_property_pointer_sdna(prop, nullptr, "value");
1814 RNA_def_property_struct_type(prop, "Object");
1815 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
1816 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1819
1821}
1822
1823static void rna_def_node_socket_image(BlenderRNA *brna, const char *identifier)
1824{
1825 StructRNA *srna;
1826 PropertyRNA *prop;
1827
1828 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1829 RNA_def_struct_ui_text(srna, "Image Node Socket", "Image socket of a node");
1830 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_IMAGE);
1831 RNA_def_struct_sdna(srna, "bNodeSocket");
1832
1833 RNA_def_struct_sdna_from(srna, "bNodeSocketValueImage", "default_value");
1834
1835 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
1836 RNA_def_property_pointer_sdna(prop, nullptr, "value");
1837 RNA_def_property_struct_type(prop, "Image");
1838 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
1839 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
1841 prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
1845 prop, nullptr, nullptr, nullptr, "rna_Image_no_renderresult_or_viewer_poll");
1846}
1847
1848static void rna_def_node_socket_interface_image(BlenderRNA *brna, const char *identifier)
1849{
1850 StructRNA *srna;
1851 PropertyRNA *prop;
1852
1853 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
1854 RNA_def_struct_ui_text(srna, "Image Node Socket Interface", "Image socket of a node");
1855 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
1856
1857 RNA_def_struct_sdna_from(srna, "bNodeSocketValueImage", "socket_data");
1858
1859 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
1860 RNA_def_property_pointer_sdna(prop, nullptr, "value");
1861 RNA_def_property_struct_type(prop, "Image");
1862 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
1863 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1867 prop, nullptr, nullptr, nullptr, "rna_Image_no_renderresult_or_viewer_poll");
1868
1870}
1871
1872static void rna_def_node_socket_geometry(BlenderRNA *brna, const char *identifier)
1873{
1874 StructRNA *srna;
1875
1876 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1877 RNA_def_struct_ui_text(srna, "Geometry Node Socket", "Geometry socket of a node");
1878 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_GEOMETRY);
1879 RNA_def_struct_sdna(srna, "bNodeSocket");
1880}
1881
1882static void rna_def_node_socket_interface_geometry(BlenderRNA *brna, const char *identifier)
1883{
1884 StructRNA *srna;
1885
1886 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
1887 RNA_def_struct_ui_text(srna, "Geometry Node Socket Interface", "Geometry socket of a node");
1888 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
1889
1891}
1892
1893static void rna_def_node_socket_bundle(BlenderRNA *brna, const char *identifier)
1894{
1895 StructRNA *srna;
1896
1897 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1898 RNA_def_struct_ui_text(srna, "Bundle Node Socket", "Bundle socket of a node");
1899 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_BUNDLE);
1900 RNA_def_struct_sdna(srna, "bNodeSocket");
1901}
1902
1903static void rna_def_node_socket_interface_bundle(BlenderRNA *brna, const char *identifier)
1904{
1905 StructRNA *srna;
1906
1907 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
1908 RNA_def_struct_ui_text(srna, "Bundle Node Socket Interface", "Bundle socket of a node");
1909 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
1910
1912}
1913
1914static void rna_def_node_socket_closure(BlenderRNA *brna, const char *identifier)
1915{
1916 StructRNA *srna;
1917
1918 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1919 RNA_def_struct_ui_text(srna, "Closure Node Socket", "Closure socket of a node");
1920 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_CLOSURE);
1921 RNA_def_struct_sdna(srna, "bNodeSocket");
1922}
1923
1924static void rna_def_node_socket_interface_closure(BlenderRNA *brna, const char *identifier)
1925{
1926 StructRNA *srna;
1927
1928 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
1929 RNA_def_struct_ui_text(srna, "Closure Node Socket Interface", "Closure socket of a node");
1930 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
1931
1933}
1934
1935static void rna_def_node_socket_collection(BlenderRNA *brna, const char *identifier)
1936{
1937 StructRNA *srna;
1938 PropertyRNA *prop;
1939
1940 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1941 RNA_def_struct_ui_text(srna, "Collection Node Socket", "Collection socket of a node");
1942 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_COLLECTION);
1943 RNA_def_struct_sdna(srna, "bNodeSocket");
1944
1945 RNA_def_struct_sdna_from(srna, "bNodeSocketValueCollection", "default_value");
1946
1947 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
1948 RNA_def_property_pointer_sdna(prop, nullptr, "value");
1949 RNA_def_property_struct_type(prop, "Collection");
1950 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
1951 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
1953 prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
1956}
1957
1958static void rna_def_node_socket_interface_collection(BlenderRNA *brna, const char *identifier)
1959{
1960 StructRNA *srna;
1961 PropertyRNA *prop;
1962
1963 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
1964 RNA_def_struct_ui_text(srna, "Collection Node Socket Interface", "Collection socket of a node");
1965 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
1966
1967 RNA_def_struct_sdna_from(srna, "bNodeSocketValueCollection", "socket_data");
1968
1969 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
1970 RNA_def_property_pointer_sdna(prop, nullptr, "value");
1971 RNA_def_property_struct_type(prop, "Collection");
1972 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
1973 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
1976
1978}
1979
1980static void rna_def_node_socket_texture(BlenderRNA *brna, const char *identifier)
1981{
1982 StructRNA *srna;
1983 PropertyRNA *prop;
1984
1985 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
1986 RNA_def_struct_ui_text(srna, "Texture Node Socket", "Texture socket of a node");
1987 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_TEXTURE);
1988 RNA_def_struct_sdna(srna, "bNodeSocket");
1989
1990 RNA_def_struct_sdna_from(srna, "bNodeSocketValueTexture", "default_value");
1991
1992 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
1993 RNA_def_property_pointer_sdna(prop, nullptr, "value");
1994 RNA_def_property_struct_type(prop, "Texture");
1995 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
1996 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
1998 prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
2001}
2002
2003static void rna_def_node_socket_interface_texture(BlenderRNA *brna, const char *identifier)
2004{
2005 StructRNA *srna;
2006 PropertyRNA *prop;
2007
2008 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
2009 RNA_def_struct_ui_text(srna, "Texture Node Socket Interface", "Texture socket of a node");
2010 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
2011
2012 RNA_def_struct_sdna_from(srna, "bNodeSocketValueTexture", "socket_data");
2013
2014 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
2015 RNA_def_property_pointer_sdna(prop, nullptr, "value");
2016 RNA_def_property_struct_type(prop, "Texture");
2017 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
2018 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
2021
2023}
2024
2025static void rna_def_node_socket_material(BlenderRNA *brna, const char *identifier)
2026{
2027 StructRNA *srna;
2028 PropertyRNA *prop;
2029
2030 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
2031 RNA_def_struct_ui_text(srna, "Material Node Socket", "Material socket of a node");
2032 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_MATERIAL);
2033 RNA_def_struct_sdna(srna, "bNodeSocket");
2034
2035 RNA_def_struct_sdna_from(srna, "bNodeSocketValueMaterial", "default_value");
2036
2037 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
2038 RNA_def_property_pointer_sdna(prop, nullptr, "value");
2039 RNA_def_property_struct_type(prop, "Material");
2040 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
2041 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
2043 prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
2046}
2047
2048static void rna_def_node_socket_interface_material(BlenderRNA *brna, const char *identifier)
2049{
2050 StructRNA *srna;
2051 PropertyRNA *prop;
2052
2053 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
2054 RNA_def_struct_ui_text(srna, "Material Node Socket Interface", "Material socket of a node");
2055 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
2056
2057 RNA_def_struct_sdna_from(srna, "bNodeSocketValueMaterial", "socket_data");
2058
2059 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
2060 RNA_def_property_pointer_sdna(prop, nullptr, "value");
2061 RNA_def_property_struct_type(prop, "Material");
2063 prop, nullptr, nullptr, nullptr, "rna_NodeTreeInterfaceSocketMaterial_default_value_poll");
2064 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
2065 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
2068
2070}
2071
2072static void rna_def_node_socket_font(BlenderRNA *brna, const char *identifier)
2073{
2074 StructRNA *srna;
2075 PropertyRNA *prop;
2076
2077 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
2078 RNA_def_struct_ui_text(srna, "Font Node Socket", "Font socket of a node");
2079 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_FONT);
2080 RNA_def_struct_sdna(srna, "bNodeSocket");
2081
2082 RNA_def_struct_sdna_from(srna, "bNodeSocketValueFont", "default_value");
2083
2084 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
2085 RNA_def_property_pointer_sdna(prop, nullptr, "value");
2086 RNA_def_property_struct_type(prop, "VectorFont");
2087 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
2088 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
2090 prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
2093}
2094
2095static void rna_def_node_socket_interface_font(BlenderRNA *brna, const char *identifier)
2096{
2097 StructRNA *srna;
2098 PropertyRNA *prop;
2099
2100 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
2101 RNA_def_struct_ui_text(srna, "Font Node Socket Interface", "Font socket of a node");
2102 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
2103
2104 RNA_def_struct_sdna_from(srna, "bNodeSocketValueFont", "socket_data");
2105
2106 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
2107 RNA_def_property_pointer_sdna(prop, nullptr, "value");
2108 RNA_def_property_struct_type(prop, "VectorFont");
2109 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
2110 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
2113}
2114
2115static void rna_def_node_socket_scene(BlenderRNA *brna, const char *identifier)
2116{
2117 StructRNA *srna;
2118 PropertyRNA *prop;
2119
2120 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
2121 RNA_def_struct_ui_text(srna, "Scene Node Socket", "Scene socket of a node");
2122 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_SCENE);
2123 RNA_def_struct_sdna(srna, "bNodeSocket");
2124
2125 RNA_def_struct_sdna_from(srna, "bNodeSocketValueScene", "default_value");
2126
2127 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
2128 RNA_def_property_pointer_sdna(prop, nullptr, "value");
2129 RNA_def_property_struct_type(prop, "Scene");
2130 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
2131 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
2133 prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
2136}
2137
2138static void rna_def_node_socket_interface_scene(BlenderRNA *brna, const char *identifier)
2139{
2140 StructRNA *srna;
2141 PropertyRNA *prop;
2142
2143 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
2144 RNA_def_struct_ui_text(srna, "Scene Node Socket Interface", "Scene socket of a node");
2145 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
2146
2147 RNA_def_struct_sdna_from(srna, "bNodeSocketValueScene", "socket_data");
2148
2149 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
2150 RNA_def_property_pointer_sdna(prop, nullptr, "value");
2151 RNA_def_property_struct_type(prop, "Scene");
2152 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
2153 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
2156}
2157
2158static void rna_def_node_socket_text(BlenderRNA *brna, const char *identifier)
2159{
2160 StructRNA *srna;
2161 PropertyRNA *prop;
2162
2163 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
2164 RNA_def_struct_ui_text(srna, "Text Node Socket", "Text socket of a node");
2165 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_TEXT);
2166 RNA_def_struct_sdna(srna, "bNodeSocket");
2167
2168 RNA_def_struct_sdna_from(srna, "bNodeSocketValueText", "default_value");
2169
2170 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
2171 RNA_def_property_pointer_sdna(prop, nullptr, "value");
2172 RNA_def_property_struct_type(prop, "Text");
2173 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
2174 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
2176 prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
2179}
2180
2181static void rna_def_node_socket_interface_text(BlenderRNA *brna, const char *identifier)
2182{
2183 StructRNA *srna;
2184 PropertyRNA *prop;
2185
2186 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
2187 RNA_def_struct_ui_text(srna, "Text Node Socket Interface", "Text socket of a node");
2188 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
2189
2190 RNA_def_struct_sdna_from(srna, "bNodeSocketValueText", "socket_data");
2191
2192 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
2193 RNA_def_property_pointer_sdna(prop, nullptr, "value");
2194 RNA_def_property_struct_type(prop, "Text");
2195 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
2196 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
2199}
2200
2201static void rna_def_node_socket_mask(BlenderRNA *brna, const char *identifier)
2202{
2203 StructRNA *srna;
2204 PropertyRNA *prop;
2205
2206 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
2207 RNA_def_struct_ui_text(srna, "Mask Node Socket", "Mask socket of a node");
2208 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_MASK);
2209 RNA_def_struct_sdna(srna, "bNodeSocket");
2210
2211 RNA_def_struct_sdna_from(srna, "bNodeSocketValueMask", "default_value");
2212
2213 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
2214 RNA_def_property_pointer_sdna(prop, nullptr, "value");
2215 RNA_def_property_struct_type(prop, "Mask");
2216 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
2217 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
2219 prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
2222}
2223
2224static void rna_def_node_socket_interface_mask(BlenderRNA *brna, const char *identifier)
2225{
2226 StructRNA *srna;
2227 PropertyRNA *prop;
2228
2229 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
2230 RNA_def_struct_ui_text(srna, "Mask Node Socket Interface", "Mask socket of a node");
2231 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
2232
2233 RNA_def_struct_sdna_from(srna, "bNodeSocketValueMask", "socket_data");
2234
2235 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
2236 RNA_def_property_pointer_sdna(prop, nullptr, "value");
2237 RNA_def_property_struct_type(prop, "Mask");
2238 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
2239 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
2242}
2243
2244static void rna_def_node_socket_sound(BlenderRNA *brna, const char *identifier)
2245{
2246 StructRNA *srna;
2247 PropertyRNA *prop;
2248
2249 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
2250 RNA_def_struct_ui_text(srna, "Sound Node Socket", "Sound socket of a node");
2251 RNA_def_struct_ui_icon(srna, ICON_NODE_SOCKET_SOUND);
2252 RNA_def_struct_sdna(srna, "bNodeSocket");
2253
2254 RNA_def_struct_sdna_from(srna, "bNodeSocketValueSound", "default_value");
2255
2256 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
2257 RNA_def_property_pointer_sdna(prop, nullptr, "value");
2258 RNA_def_property_struct_type(prop, "Sound");
2259 RNA_def_property_ui_name_func(prop, "rna_NodeSocketStandard_name_func");
2260 RNA_def_property_ui_description_func(prop, "rna_NodeSocketStandard_description_func");
2262 prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
2265}
2266
2267static void rna_def_node_socket_interface_sound(BlenderRNA *brna, const char *identifier)
2268{
2269 StructRNA *srna;
2270 PropertyRNA *prop;
2271
2272 srna = RNA_def_struct(brna, identifier, "NodeTreeInterfaceSocket");
2273 RNA_def_struct_ui_text(srna, "Sound Node Socket Interface", "Sound socket of a node");
2274 RNA_def_struct_sdna(srna, "bNodeTreeInterfaceSocket");
2275
2276 RNA_def_struct_sdna_from(srna, "bNodeSocketValueSound", "socket_data");
2277
2278 prop = RNA_def_property(srna, "default_value", PROP_POINTER, PROP_NONE);
2279 RNA_def_property_pointer_sdna(prop, nullptr, "value");
2280 RNA_def_property_struct_type(prop, "Sound");
2281 RNA_def_property_ui_text(prop, "Default Value", "Input value used for unconnected socket");
2282 RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeTreeInterfaceItem_update");
2285}
2286
2287static void rna_def_node_socket_virtual(BlenderRNA *brna, const char *identifier)
2288{
2289 StructRNA *srna;
2290
2291 srna = RNA_def_struct(brna, identifier, "NodeSocketStandard");
2292 RNA_def_struct_ui_text(srna, "Virtual Node Socket", "Virtual socket of a node");
2293 RNA_def_struct_sdna(srna, "bNodeSocket");
2294}
2295
2296/* Info for generating static subtypes. */
2304
2305/* NOTE: Socket and interface subtypes could be defined from a single central list,
2306 * but makesrna cannot have a dependency on BKE, so this list would have to live in RNA itself,
2307 * with BKE etc. accessing the RNA API to get the subtypes info. */
2309 {"NodeSocketFloat", "NodeTreeInterfaceSocketFloat", SOCK_FLOAT, PROP_NONE},
2310 {"NodeSocketFloatUnsigned", "NodeTreeInterfaceSocketFloatUnsigned", SOCK_FLOAT, PROP_UNSIGNED},
2311 {"NodeSocketFloatPercentage",
2312 "NodeTreeInterfaceSocketFloatPercentage",
2313 SOCK_FLOAT,
2315 {"NodeSocketFloatFactor", "NodeTreeInterfaceSocketFloatFactor", SOCK_FLOAT, PROP_FACTOR},
2316 {"NodeSocketFloatMass", "NodeTreeInterfaceSocketFloatMass", SOCK_FLOAT, PROP_MASS},
2317 {"NodeSocketFloatAngle", "NodeTreeInterfaceSocketFloatAngle", SOCK_FLOAT, PROP_ANGLE},
2318 {"NodeSocketFloatTime", "NodeTreeInterfaceSocketFloatTime", SOCK_FLOAT, PROP_TIME},
2319 {"NodeSocketFloatTimeAbsolute",
2320 "NodeTreeInterfaceSocketFloatTimeAbsolute",
2321 SOCK_FLOAT,
2323 {"NodeSocketFloatDistance", "NodeTreeInterfaceSocketFloatDistance", SOCK_FLOAT, PROP_DISTANCE},
2324 {"NodeSocketFloatWavelength",
2325 "NodeTreeInterfaceSocketFloatWavelength",
2326 SOCK_FLOAT,
2328 {"NodeSocketFloatColorTemperature",
2329 "NodeTreeInterfaceSocketFloatColorTemperature",
2330 SOCK_FLOAT,
2332 {"NodeSocketFloatFrequency",
2333 "NodeTreeInterfaceSocketFloatFrequency",
2334 SOCK_FLOAT,
2336 {"NodeSocketFloatPixel", "NodeTreeInterfaceSocketFloatPixel", SOCK_FLOAT, PROP_PIXEL},
2337
2338 {"NodeSocketInt", "NodeTreeInterfaceSocketInt", SOCK_INT, PROP_NONE},
2339 {"NodeSocketIntUnsigned", "NodeTreeInterfaceSocketIntUnsigned", SOCK_INT, PROP_UNSIGNED},
2340 {"NodeSocketIntPercentage", "NodeTreeInterfaceSocketIntPercentage", SOCK_INT, PROP_PERCENTAGE},
2341 {"NodeSocketIntFactor", "NodeTreeInterfaceSocketIntFactor", SOCK_INT, PROP_FACTOR},
2342 {"NodeSocketIntPixel", "NodeTreeInterfaceSocketIntPixel", SOCK_INT, PROP_PIXEL},
2343
2344 {"NodeSocketBool", "NodeTreeInterfaceSocketBool", SOCK_BOOLEAN, PROP_NONE},
2345
2346 {"NodeSocketVector", "NodeTreeInterfaceSocketVector", SOCK_VECTOR, PROP_NONE},
2347 {"NodeSocketVectorFactor", "NodeTreeInterfaceSocketVectorFactor", SOCK_VECTOR, PROP_FACTOR},
2348 {"NodeSocketVectorPercentage",
2349 "NodeTreeInterfaceSocketVectorPercentage",
2352 {"NodeSocketVectorTranslation",
2353 "NodeTreeInterfaceSocketVectorTranslation",
2356 {"NodeSocketVectorDirection",
2357 "NodeTreeInterfaceSocketVectorDirection",
2360 {"NodeSocketVectorVelocity",
2361 "NodeTreeInterfaceSocketVectorVelocity",
2364 {"NodeSocketVectorAcceleration",
2365 "NodeTreeInterfaceSocketVectorAcceleration",
2368 {"NodeSocketVectorEuler", "NodeTreeInterfaceSocketVectorEuler", SOCK_VECTOR, PROP_EULER},
2369 {"NodeSocketVectorXYZ", "NodeTreeInterfaceSocketVectorXYZ", SOCK_VECTOR, PROP_XYZ},
2370 {"NodeSocketVectorPixel", "NodeTreeInterfaceSocketVectorPixel", SOCK_VECTOR, PROP_PIXEL},
2371
2372 {"NodeSocketVector2D", "NodeTreeInterfaceSocketVector2D", SOCK_VECTOR, PROP_NONE},
2373 {"NodeSocketVectorFactor2D",
2374 "NodeTreeInterfaceSocketVectorFactor2D",
2376 PROP_FACTOR},
2377 {"NodeSocketVectorPercentage2D",
2378 "NodeTreeInterfaceSocketVectorPercentage2D",
2381 {"NodeSocketVectorTranslation2D",
2382 "NodeTreeInterfaceSocketVectorTranslation2D",
2385 {"NodeSocketVectorDirection2D",
2386 "NodeTreeInterfaceSocketVectorDirection2D",
2389 {"NodeSocketVectorVelocity2D",
2390 "NodeTreeInterfaceSocketVectorVelocity2D",
2393 {"NodeSocketVectorAcceleration2D",
2394 "NodeTreeInterfaceSocketVectorAcceleration2D",
2397 {"NodeSocketVectorEuler2D", "NodeTreeInterfaceSocketVectorEuler2D", SOCK_VECTOR, PROP_EULER},
2398 {"NodeSocketVectorXYZ2D", "NodeTreeInterfaceSocketVectorXYZ2D", SOCK_VECTOR, PROP_XYZ},
2399 {"NodeSocketVectorPixel2D", "NodeTreeInterfaceSocketVectorPixel2D", SOCK_VECTOR, PROP_PIXEL},
2400
2401 {"NodeSocketVector4D", "NodeTreeInterfaceSocketVector4D", SOCK_VECTOR, PROP_NONE},
2402 {"NodeSocketVectorFactor4D",
2403 "NodeTreeInterfaceSocketVectorFactor4D",
2405 PROP_FACTOR},
2406 {"NodeSocketVectorPercentage4D",
2407 "NodeTreeInterfaceSocketVectorPercentage4D",
2410 {"NodeSocketVectorTranslation4D",
2411 "NodeTreeInterfaceSocketVectorTranslation4D",
2414 {"NodeSocketVectorDirection4D",
2415 "NodeTreeInterfaceSocketVectorDirection4D",
2418 {"NodeSocketVectorVelocity4D",
2419 "NodeTreeInterfaceSocketVectorVelocity4D",
2422 {"NodeSocketVectorAcceleration4D",
2423 "NodeTreeInterfaceSocketVectorAcceleration4D",
2426 {"NodeSocketVectorEuler4D", "NodeTreeInterfaceSocketVectorEuler4D", SOCK_VECTOR, PROP_EULER},
2427 {"NodeSocketVectorXYZ4D", "NodeTreeInterfaceSocketVectorXYZ4D", SOCK_VECTOR, PROP_XYZ},
2428 {"NodeSocketVectorPixel4D", "NodeTreeInterfaceSocketVectorPixel4D", SOCK_VECTOR, PROP_PIXEL},
2429
2430 /* 2D Integer Vector types. */
2431 {"NodeSocketIntVector2D", "NodeTreeInterfaceSocketIntVector2D", SOCK_INT_VECTOR, PROP_NONE},
2432 {"NodeSocketIntVectorUnsigned2D",
2433 "NodeTreeInterfaceSocketIntVectorUnsigned2D",
2436 {"NodeSocketIntVectorPercentage2D",
2437 "NodeTreeInterfaceSocketIntVectorPercentage2D",
2440 {"NodeSocketIntVectorFactor2D",
2441 "NodeTreeInterfaceSocketIntVectorFactor2D",
2443 PROP_FACTOR},
2444 {"NodeSocketIntVectorPixel2D",
2445 "NodeTreeInterfaceSocketIntVectorPixel2D",
2447 PROP_PIXEL},
2448
2449 /* 3D Integer Vector types. */
2450 {"NodeSocketIntVector3D", "NodeTreeInterfaceSocketIntVector3D", SOCK_INT_VECTOR, PROP_NONE},
2451 {"NodeSocketIntVectorUnsigned3D",
2452 "NodeTreeInterfaceSocketIntVectorUnsigned3D",
2455 {"NodeSocketIntVectorPercentage3D",
2456 "NodeTreeInterfaceSocketIntVectorPercentage3D",
2459 {"NodeSocketIntVectorFactor3D",
2460 "NodeTreeInterfaceSocketIntVectorFactor3D",
2462 PROP_FACTOR},
2463 {"NodeSocketIntVectorPixel3D",
2464 "NodeTreeInterfaceSocketIntVectorPixel3D",
2466 PROP_PIXEL},
2467
2468 {"NodeSocketRotation", "NodeTreeInterfaceSocketRotation", SOCK_ROTATION, PROP_NONE},
2469 {"NodeSocketMatrix", "NodeTreeInterfaceSocketMatrix", SOCK_MATRIX, PROP_NONE},
2470
2471 {"NodeSocketColor", "NodeTreeInterfaceSocketColor", SOCK_RGBA, PROP_NONE},
2472 {"NodeSocketString", "NodeTreeInterfaceSocketString", SOCK_STRING, PROP_NONE},
2473 {"NodeSocketStringFilePath",
2474 "NodeTreeInterfaceSocketStringFilePath",
2477 {"NodeSocketShader", "NodeTreeInterfaceSocketShader", SOCK_SHADER, PROP_NONE},
2478 {"NodeSocketObject", "NodeTreeInterfaceSocketObject", SOCK_OBJECT, PROP_NONE},
2479 {"NodeSocketImage", "NodeTreeInterfaceSocketImage", SOCK_IMAGE, PROP_NONE},
2480 {"NodeSocketGeometry", "NodeTreeInterfaceSocketGeometry", SOCK_GEOMETRY, PROP_NONE},
2481 {"NodeSocketCollection", "NodeTreeInterfaceSocketCollection", SOCK_COLLECTION, PROP_NONE},
2482 {"NodeSocketTexture", "NodeTreeInterfaceSocketTexture", SOCK_TEXTURE, PROP_NONE},
2483 {"NodeSocketMaterial", "NodeTreeInterfaceSocketMaterial", SOCK_MATERIAL, PROP_NONE},
2484 {"NodeSocketMenu", "NodeTreeInterfaceSocketMenu", SOCK_MENU, PROP_NONE},
2485 {"NodeSocketBundle", "NodeTreeInterfaceSocketBundle", SOCK_BUNDLE, PROP_NONE},
2486 {"NodeSocketClosure", "NodeTreeInterfaceSocketClosure", SOCK_CLOSURE, PROP_NONE},
2487 {"NodeSocketFont", "NodeTreeInterfaceSocketFont", SOCK_FONT, PROP_NONE},
2488 {"NodeSocketScene", "NodeTreeInterfaceSocketScene", SOCK_SCENE, PROP_NONE},
2489 {"NodeSocketText", "NodeTreeInterfaceSocketText", SOCK_TEXT_ID, PROP_NONE},
2490 {"NodeSocketMask", "NodeTreeInterfaceSocketMask", SOCK_MASK, PROP_NONE},
2491 {"NodeSocketSound", "NodeTreeInterfaceSocketSound", SOCK_SOUND, PROP_NONE},
2492};
2493
2495{
2497 const char *identifier = info.socket_identifier;
2498
2499 switch (info.type) {
2500 case SOCK_FLOAT:
2501 rna_def_node_socket_float(brna, identifier, info.subtype);
2502 break;
2503 case SOCK_INT:
2504 rna_def_node_socket_int(brna, identifier, info.subtype);
2505 break;
2506 case SOCK_BOOLEAN:
2507 rna_def_node_socket_bool(brna, identifier);
2508 break;
2509 case SOCK_ROTATION:
2510 rna_def_node_socket_rotation(brna, identifier);
2511 break;
2512 case SOCK_MATRIX:
2513 rna_def_node_socket_matrix(brna, identifier);
2514 break;
2515 case SOCK_VECTOR:
2516 if (StringRef(identifier).endswith("2D")) {
2517 rna_def_node_socket_vector(brna, identifier, info.subtype, 2);
2518 }
2519 else if (StringRef(identifier).endswith("4D")) {
2520 rna_def_node_socket_vector(brna, identifier, info.subtype, 4);
2521 }
2522 else {
2523 rna_def_node_socket_vector(brna, identifier, info.subtype, 3);
2524 }
2525 break;
2526 case SOCK_INT_VECTOR:
2527 if (StringRef(identifier).endswith("2D")) {
2528 rna_def_node_socket_int_vector(brna, identifier, info.subtype, 2);
2529 }
2530 else {
2531 rna_def_node_socket_int_vector(brna, identifier, info.subtype, 3);
2532 }
2533 break;
2534 case SOCK_RGBA:
2535 rna_def_node_socket_color(brna, identifier);
2536 break;
2537 case SOCK_STRING:
2538 rna_def_node_socket_string(brna, identifier, info.subtype);
2539 break;
2540 case SOCK_SHADER:
2541 rna_def_node_socket_shader(brna, identifier);
2542 break;
2543 case SOCK_OBJECT:
2544 rna_def_node_socket_object(brna, identifier);
2545 break;
2546 case SOCK_IMAGE:
2547 rna_def_node_socket_image(brna, identifier);
2548 break;
2549 case SOCK_GEOMETRY:
2550 rna_def_node_socket_geometry(brna, identifier);
2551 break;
2552 case SOCK_COLLECTION:
2553 rna_def_node_socket_collection(brna, identifier);
2554 break;
2555 case SOCK_TEXTURE:
2556 rna_def_node_socket_texture(brna, identifier);
2557 break;
2558 case SOCK_MATERIAL:
2559 rna_def_node_socket_material(brna, identifier);
2560 break;
2561 case SOCK_MENU:
2562 rna_def_node_socket_menu(brna, identifier);
2563 break;
2564 case SOCK_BUNDLE:
2565 rna_def_node_socket_bundle(brna, identifier);
2566 break;
2567 case SOCK_CLOSURE:
2568 rna_def_node_socket_closure(brna, identifier);
2569 break;
2570 case SOCK_FONT:
2571 rna_def_node_socket_font(brna, identifier);
2572 break;
2573 case SOCK_SCENE:
2574 rna_def_node_socket_scene(brna, identifier);
2575 break;
2576 case SOCK_TEXT_ID:
2577 rna_def_node_socket_text(brna, identifier);
2578 break;
2579 case SOCK_MASK:
2580 rna_def_node_socket_mask(brna, identifier);
2581 break;
2582 case SOCK_SOUND:
2583 rna_def_node_socket_sound(brna, identifier);
2584 break;
2585
2586 case SOCK_CUSTOM:
2587 break;
2588 }
2589 }
2590
2591 rna_def_node_socket_virtual(brna, "NodeSocketVirtual");
2592}
2593
2595{
2596 /* NOTE: interface items are defined outside this file.
2597 * The subtypes must be defined after the base type, so this function
2598 * is called from the interface rna file to ensure correct order. */
2599
2601 const char *identifier = info.interface_identifier;
2602
2603 switch (info.type) {
2604 case SOCK_FLOAT:
2605 rna_def_node_socket_interface_float(brna, identifier, info.subtype);
2606 break;
2607 case SOCK_INT:
2608 rna_def_node_socket_interface_int(brna, identifier, info.subtype);
2609 break;
2610 case SOCK_BOOLEAN:
2611 rna_def_node_socket_interface_bool(brna, identifier);
2612 break;
2613 case SOCK_ROTATION:
2615 break;
2616 case SOCK_MATRIX:
2617 rna_def_node_socket_interface_matrix(brna, identifier);
2618 break;
2619 case SOCK_VECTOR:
2620 if (StringRef(identifier).endswith("2D")) {
2621 rna_def_node_socket_interface_vector(brna, identifier, info.subtype, 2);
2622 }
2623 else if (StringRef(identifier).endswith("4D")) {
2624 rna_def_node_socket_interface_vector(brna, identifier, info.subtype, 4);
2625 }
2626 else {
2627 rna_def_node_socket_interface_vector(brna, identifier, info.subtype, 3);
2628 }
2629 break;
2630 case SOCK_INT_VECTOR:
2631 if (StringRef(identifier).endswith("2D")) {
2632 rna_def_node_socket_interface_int_vector(brna, identifier, info.subtype, 2);
2633 }
2634 else {
2635 rna_def_node_socket_interface_int_vector(brna, identifier, info.subtype, 3);
2636 }
2637 break;
2638 case SOCK_RGBA:
2639 rna_def_node_socket_interface_color(brna, identifier);
2640 break;
2641 case SOCK_STRING:
2642 rna_def_node_socket_interface_string(brna, identifier, info.subtype);
2643 break;
2644 case SOCK_MENU:
2645 rna_def_node_socket_interface_menu(brna, identifier);
2646 break;
2647 case SOCK_SHADER:
2648 rna_def_node_socket_interface_shader(brna, identifier);
2649 break;
2650 case SOCK_OBJECT:
2651 rna_def_node_socket_interface_object(brna, identifier);
2652 break;
2653 case SOCK_IMAGE:
2654 rna_def_node_socket_interface_image(brna, identifier);
2655 break;
2656 case SOCK_GEOMETRY:
2658 break;
2659 case SOCK_COLLECTION:
2661 break;
2662 case SOCK_TEXTURE:
2663 rna_def_node_socket_interface_texture(brna, identifier);
2664 break;
2665 case SOCK_MATERIAL:
2667 break;
2668 case SOCK_BUNDLE:
2669 rna_def_node_socket_interface_bundle(brna, identifier);
2670 break;
2671 case SOCK_CLOSURE:
2672 rna_def_node_socket_interface_closure(brna, identifier);
2673 break;
2674 case SOCK_FONT:
2675 rna_def_node_socket_interface_font(brna, identifier);
2676 break;
2677 case SOCK_SCENE:
2678 rna_def_node_socket_interface_scene(brna, identifier);
2679 break;
2680 case SOCK_TEXT_ID:
2681 rna_def_node_socket_interface_text(brna, identifier);
2682 break;
2683 case SOCK_MASK:
2684 rna_def_node_socket_interface_mask(brna, identifier);
2685 break;
2686 case SOCK_SOUND:
2687 rna_def_node_socket_interface_sound(brna, identifier);
2688 break;
2689
2690 case SOCK_CUSTOM:
2691 break;
2692 }
2693 }
2694}
2695
2703
2704} // namespace blender
2705
2706#endif
#define SELECT
Definition BKE_mask.hh:19
#define NODE_CUSTOM
Definition BKE_node.hh:864
#define BLT_I18NCONTEXT_UNIT
#define CLOG_ERROR(clg_ref,...)
Definition CLG_log.h:188
#define C
Definition RandGen.cpp:29
#define NC_NODE
Definition WM_types.hh:407
#define ND_DISPLAY
Definition WM_types.hh:534
#define NA_EDITED
Definition WM_types.hh:634
#define ND_NODE_GIZMO
Definition WM_types.hh:559
btScalar max
constexpr StringRef()
int64_t size() const
StringRefNull ref() const
UString()=default
constexpr int64_t size() const
void copy_unsafe(char *dst) const
#define FLT_MAX
#define INT_MAX
#define LOG(level)
Definition log.h:97
void free(Subdiv *subdiv)
Definition subdiv.cc:192
void node_unregister_socket_type(bNodeSocketType &stype)
Definition node.cc:3007
void node_modify_socket_type_static(bNodeTree *ntree, bNode *node, bNodeSocket *sock, int type, int subtype)
Definition node.cc:3448
const char * node_socket_translation_context(const bNodeSocket &sock)
Definition node.cc:5770
void node_register_socket_type(bNodeSocketType &stype)
Definition node.cc:2998
bNode & node_find_node(bNodeTree &ntree, bNodeSocket &socket)
Definition node.cc:4053
bNodeSocketType * node_socket_type_find(StringRef idname)
Definition node.cc:2966
int node_socket_link_limit(const bNodeSocket &sock)
Definition node.cc:5513
StringRefNull node_socket_label(const bNodeSocket &sock)
Definition node.cc:5758
const char * node_socket_get_label(const bNodeSocket *socket, const char *panel_label=nullptr)
Definition node_draw.cc:398
const char * node_socket_get_description(const bNodeSocket *socket)
Definition node_draw.cc:427
void refresh_for_srna_unregister(Main *bmain, StructRNA *srna_to_unreg)
BMesh Iterators.
static void rna_def_node_socket_text(BlenderRNA *brna, const char *identifier)
static void rna_def_node_socket_interface_collection(BlenderRNA *brna, const char *identifier)
void WM_main_add_notifier(uint type, void *reference)
static void rna_def_node_socket_interface_mask(BlenderRNA *brna, const char *identifier)
static void rna_def_node_tree_interface_socket_builtin(StructRNA *srna)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void RNA_def_struct_ui_text(StructRNA *srna, const char *name, const char *description)
void RNA_enum_item_add(EnumPropertyItem **items, int *totitem, const EnumPropertyItem *item)
static void rna_def_node_socket_interface_float(BlenderRNA *brna, const char *identifier, PropertySubType subtype)
void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description)
void RNA_def_node_socket_subtypes(BlenderRNA *brna)
static void rna_def_node_socket_interface_image(BlenderRNA *brna, const char *identifier)
void RNA_def_struct_ui_icon(StructRNA *srna, int icon)
void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, const char *propname)
int(*)(PointerRNA *ptr, void *data, bool *have_function) StructValidateFunc
const EnumPropertyItem rna_enum_node_socket_type_items[]
PropertyRNA * RNA_def_string(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, const int maxlen, const char *ui_name, const char *ui_description)
void RNA_def_function_output(FunctionRNA *, PropertyRNA *ret)
static void rna_def_node_socket_subtypes(BlenderRNA *brna)
void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop, const char *structname, const char *propname, int64_t booleanbit)
void RNA_def_property_enum_default(PropertyRNA *prop, int value)
static void rna_def_node_socket_sound(BlenderRNA *brna, const char *identifier)
static void rna_def_node_socket_interface_menu(BlenderRNA *brna, const char *identifier)
void RNA_def_property_enum_default_func(PropertyRNA *prop, const char *get_default)
static void rna_def_node_socket_interface_string(BlenderRNA *brna, const char *identifier, PropertySubType subtype)
void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, const char *propname)
static void rna_def_node_socket_interface_text(BlenderRNA *brna, const char *identifier)
void RNA_def_property_ui_description_func(PropertyRNA *prop, const char *description_func)
void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *set, const char *type_fn, const char *poll)
void BKE_ntree_update_tag_socket_property(bNodeTree *ntree, bNodeSocket *socket)
PropertyRNA * RNA_def_float_array(StructOrFunctionRNA *cont_, const char *identifier, const int len, const float *default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
void RNA_def_struct_refine_func(StructRNA *srna, const char *refine)
@ SOCK_DISPLAY_SHAPE_VOLUME_GRID
@ SOCK_DISPLAY_SHAPE_CIRCLE_DOT
@ SOCK_DISPLAY_SHAPE_LINE
@ SOCK_DISPLAY_SHAPE_CIRCLE
@ SOCK_DISPLAY_SHAPE_SQUARE_DOT
@ SOCK_DISPLAY_SHAPE_DIAMOND_DOT
@ SOCK_DISPLAY_SHAPE_SQUARE
@ SOCK_DISPLAY_SHAPE_DIAMOND
@ SOCK_DISPLAY_SHAPE_LIST
static void rna_def_node_socket_texture(BlenderRNA *brna, const char *identifier)
void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set)
static void rna_def_node_socket_standard(BlenderRNA *brna)
void RNA_def_struct_system_idprops_func(StructRNA *srna, const char *system_idproperties)
static void rna_def_node_socket_interface_rotation(BlenderRNA *brna, const char *identifier)
void RNA_def_function_ui_description(FunctionRNA *func, const char *description)
static void rna_def_node_socket_color(BlenderRNA *brna, const char *identifier)
@ FUNC_USE_SELF_TYPE
@ FUNC_ALLOW_WRITE
@ FUNC_USE_SELF_ID
Definition RNA_types.hh:980
@ FUNC_NO_SELF
Definition RNA_types.hh:998
@ FUNC_REGISTER_OPTIONAL
@ FUNC_REGISTER
void * RNA_struct_blender_type_get(StructRNA *srna)
PropertyRNA * RNA_def_pointer(StructOrFunctionRNA *cont_, const char *identifier, const char *type, const char *ui_name, const char *ui_description)
static void rna_def_node_socket_interface_shader(BlenderRNA *brna, const char *identifier)
void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
static void rna_def_node_socket_interface_int_vector(BlenderRNA *brna, const char *identifier, PropertySubType subtype, int dimensions)
void ED_init_custom_node_socket_type(bke::bNodeSocketType *stype)
Definition drawnode.cc:1012
static void rna_def_node_socket_interface_sound(BlenderRNA *brna, const char *identifier)
void rna_def_node_socket_interface_subtypes(BlenderRNA *brna)
static void rna_def_node_socket_interface_closure(BlenderRNA *brna, const char *identifier)
void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, const char *propname)
@ PROPOVERRIDE_OVERRIDABLE_LIBRARY
Definition RNA_types.hh:588
@ PROPOVERRIDE_NO_COMPARISON
Definition RNA_types.hh:596
void RNA_def_property_float_default(PropertyRNA *prop, float value)
ParameterList * RNA_parameter_list_create(ParameterList *parms, PointerRNA *, FunctionRNA *func)
static void rna_def_node_socket_shader(BlenderRNA *brna, const char *identifier)
static void rna_def_node_socket_interface_font(BlenderRNA *brna, const char *identifier)
static void rna_def_node_socket_interface_scene(BlenderRNA *brna, const char *identifier)
const EnumPropertyItem * RNA_node_enum_definition_itemf(const bke::RuntimeNodeEnumItems &enum_items, bool *r_free)
PropertyRNA * RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier_c_str, int type, int subtype)
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:593
static void rna_def_node_socket_interface_color(BlenderRNA *brna, const char *identifier)
static void rna_def_node_socket_virtual(BlenderRNA *brna, const char *identifier)
void RNA_def_struct_sdna(StructRNA *srna, const char *structname)
void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item)
void RNA_struct_free(BlenderRNA *brna, StructRNA *srna)
@ PROP_BOOLEAN
Definition RNA_types.hh:210
@ PROP_POINTER
Definition RNA_types.hh:215
@ PROP_STRING
Definition RNA_types.hh:213
void RNA_def_parameter_flags(PropertyRNA *prop, PropertyFlag flag_property, ParameterFlag flag_parameter)
void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
BMesh const char void * data
void RNA_def_property_override_flag(PropertyRNA *prop, PropertyOverrideFlag flag)
static void rna_def_node_socket_rotation(BlenderRNA *brna, const char *identifier)
void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, const char *propname, int64_t booleanbit)
void RNA_def_property_range(PropertyRNA *prop, double min, double max)
char char size_t BLI_str_escape(char *__restrict dst, StringRef src, size_t dst_maxncpy) ATTR_NONNULL(1)
static void rna_def_node_socket_string(BlenderRNA *brna, const char *identifier, PropertySubType subtype)
static void rna_def_node_socket_object(BlenderRNA *brna, const char *identifier)
void BKE_main_ensure_invariants(Main &bmain, std::optional< Span< ID * > > modified_ids=std::nullopt)
static void rna_def_node_socket_interface_object(BlenderRNA *brna, const char *identifier)
void RNA_def_struct_path_func(StructRNA *srna, const char *path)
void RNA_def_property_string_filepath_filter_func(PropertyRNA *prop, const char *filter)
void RNA_def_property_float_default_func(PropertyRNA *prop, const char *get_default)
void RNA_def_property_ui_name_func(PropertyRNA *prop, const char *name_func)
static void rna_def_node_socket_int_vector(BlenderRNA *brna, const char *identifier, PropertySubType subtype, int dimensions)
static void rna_def_node_socket_interface_texture(BlenderRNA *brna, const char *identifier)
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
static void rna_def_node_socket(BlenderRNA *brna)
void RNA_enum_item_end(EnumPropertyItem **items, int *totitem)
const EnumPropertyItem rna_enum_dummy_DEFAULT_items[]
Definition rna_rna.cc:34
void RNA_def_property_enum_funcs(PropertyRNA *prop, const char *get, const char *set, const char *item)
static void rna_def_node_socket_image(BlenderRNA *brna, const char *identifier)
static void rna_def_node_socket_bool(BlenderRNA *brna, const char *identifier)
const EnumPropertyItem rna_enum_node_socket_structure_type_items[]
static void rna_def_node_socket_collection(BlenderRNA *brna, const char *identifier)
void RNA_def_struct_sdna_from(StructRNA *srna, const char *structname, const char *propname)
FunctionRNA * RNA_def_function(StructRNA *srna, const char *identifier_c_str, const char *call)
const EnumPropertyItem rna_enum_dummy_NULL_items[]
Definition rna_rna.cc:28
static const bNodeSocketStaticTypeInfo node_socket_subtypes[]
void(*)(void *data) StructFreeFunc
static void rna_def_node_socket_vector(BlenderRNA *brna, const char *identifier, PropertySubType subtype, int dimensions)
void RNA_def_struct_register_funcs(StructRNA *srna, const char *reg, const char *unreg, const char *instance)
void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const char *propname)
void RNA_parameter_get_lookup(ParameterList *parms, const char *identifier, void **r_value)
void RNA_def_property_translation_context(PropertyRNA *prop, const char *context)
void RNA_def_property_clear_flag(PropertyRNA *prop, PropertyFlag flag)
void RNA_def_function_flag(FunctionRNA *func, FunctionFlag flag)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
Definition report.cc:191
void RNA_def_property_boolean_default_func(PropertyRNA *prop, const char *get_default)
void RNA_struct_blender_type_set(StructRNA *srna, void *blender_type)
Main * CTX_data_main(const bContext *C)
static void rna_def_node_socket_matrix(BlenderRNA *brna, const char *identifier)
static void rna_def_node_socket_int(BlenderRNA *brna, const char *identifier, PropertySubType subtype)
static void rna_def_node_socket_interface_int(BlenderRNA *brna, const char *identifier, PropertySubType subtype)
static void rna_def_node_socket_scene(BlenderRNA *brna, const char *identifier)
static void rna_def_node_socket_float(BlenderRNA *brna, const char *identifier, PropertySubType subtype)
StructRNA * RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *from)
@ PROP_CONTEXT_UPDATE
Definition RNA_types.hh:477
@ PROP_EDITABLE
Definition RNA_types.hh:376
@ PROP_PTR_NO_OWNERSHIP
Definition RNA_types.hh:465
@ PROP_REGISTER_OPTIONAL
Definition RNA_types.hh:482
@ PROP_REGISTER
Definition RNA_types.hh:481
@ PROP_PATH_SUPPORTS_BLEND_RELATIVE
Definition RNA_types.hh:526
@ PROP_ID_REFCOUNT
Definition RNA_types.hh:434
@ PROP_NEVER_NULL
Definition RNA_types.hh:447
@ PROP_ANIMATABLE
Definition RNA_types.hh:389
@ PROP_NO_DEG_UPDATE
Definition RNA_types.hh:509
void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const char *propname)
static void rna_def_node_socket_closure(BlenderRNA *brna, const char *identifier)
static void rna_def_node_socket_font(BlenderRNA *brna, const char *identifier)
void RNA_parameter_set_lookup(ParameterList *parms, const char *identifier, const void *value)
static void rna_def_node_socket_mask(BlenderRNA *brna, const char *identifier)
void RNA_def_property_update(PropertyRNA *prop, int noteflag, const char *func)
void DEG_relations_tag_update(Main *bmain)
Scene * CTX_data_scene(const bContext *C)
static void rna_def_node_socket_interface_geometry(BlenderRNA *brna, const char *identifier)
void BKE_ntree_update_tag_socket_availability(bNodeTree *ntree, bNodeSocket *socket)
MINLINE void copy_v4_v4(float r[4], const float a[4])
void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const char *length, const char *set)
static void rna_def_node_socket_interface_matrix(BlenderRNA *brna, const char *identifier)
static void rna_def_node_socket_interface_bundle(BlenderRNA *brna, const char *identifier)
@ PROP_ACCELERATION
Definition RNA_types.hh:321
@ PROP_PERCENTAGE
Definition RNA_types.hh:307
@ PROP_TIME_ABSOLUTE
Definition RNA_types.hh:311
@ PROP_FACTOR
Definition RNA_types.hh:308
@ PROP_TRANSLATION
Definition RNA_types.hh:318
@ PROP_DISTANCE
Definition RNA_types.hh:313
@ PROP_VELOCITY
Definition RNA_types.hh:320
@ PROP_FILEPATH
Definition RNA_types.hh:284
@ PROP_FREQUENCY
Definition RNA_types.hh:349
@ PROP_COLOR_TEMPERATURE
Definition RNA_types.hh:347
@ PROP_WAVELENGTH
Definition RNA_types.hh:344
@ PROP_DIRECTION
Definition RNA_types.hh:319
@ PROP_UNSIGNED
Definition RNA_types.hh:306
static void rna_def_node_socket_material(BlenderRNA *brna, const char *identifier)
static void rna_def_node_socket_interface_material(BlenderRNA *brna, const char *identifier)
@ PARM_REQUIRED
Definition RNA_types.hh:631
@ PARM_RNAPTR
Definition RNA_types.hh:633
void RNA_def_property_int_default(PropertyRNA *prop, int value)
void RNA_struct_free_extension(StructRNA *srna, ExtensionRNA *rna_ext)
static void rna_def_node_socket_interface_vector(BlenderRNA *brna, const char *identifier, PropertySubType subtype, int dimensions)
void RNA_def_struct_name_property(StructRNA *srna, PropertyRNA *prop, const bool allow_replace)
static void rna_def_node_socket_bundle(BlenderRNA *brna, const char *identifier)
void RNA_def_property_int_default_func(PropertyRNA *prop, const char *get_default)
void RNA_def_property_array(PropertyRNA *prop, int length)
int(*)(bContext *C, PointerRNA *ptr, FunctionRNA *func, ParameterList *list) StructCallbackFunc
void RNA_parameter_list_free(ParameterList *parms)
static void rna_def_node_socket_menu(BlenderRNA *brna, const char *identifier)
void RNA_def_property_string_default_func(PropertyRNA *prop, const char *get_default)
BlenderRNA RNA_blender_rna_get()
static void rna_def_node_socket_geometry(BlenderRNA *brna, const char *identifier)
static void rna_def_node_socket_interface_bool(BlenderRNA *brna, const char *identifier)
StructRNA * RNA_def_struct_ptr(BlenderRNA *brna, const char *identifier, StructRNA *srnafrom)
#define min(a, b)
Definition sort.cc:38
eNodeSocketInOut in_out
Defines a socket type.
Definition BKE_node.hh:163
eNodeSocketDatatype type
Definition BKE_node.hh:198
void(*) draw_color_simple(const bNodeSocketType *socket_type, float *r_color)
Definition BKE_node.hh:177