Cleanup: indentation, naming
[blender.git] / source / blender / makesrna / intern / rna_nodetree.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation (2008), Nathan Letwory, Robin Allen, Bob Holcomb
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_nodetree.c
24  *  \ingroup RNA
25  */
26
27 #include <stdlib.h>
28 #include <string.h>
29 #include <limits.h>
30
31 #include "BLI_listbase.h"
32 #include "BLI_math.h"
33 #include "BLI_utildefines.h"
34
35 #include "BLT_translation.h"
36
37 #include "DNA_material_types.h"
38 #include "DNA_mesh_types.h"
39 #include "DNA_node_types.h"
40 #include "DNA_object_types.h"
41 #include "DNA_particle_types.h"
42 #include "DNA_text_types.h"
43 #include "DNA_texture_types.h"
44
45 #include "BKE_animsys.h"
46 #include "BKE_node.h"
47 #include "BKE_image.h"
48 #include "BKE_texture.h"
49
50 #include "RNA_access.h"
51 #include "RNA_define.h"
52 #include "RNA_enum_types.h"
53
54 #include "rna_internal.h"
55 #include "rna_internal_types.h"
56
57 #include "IMB_imbuf.h"
58 #include "IMB_imbuf_types.h"
59
60 #include "WM_types.h"
61
62 #include "MEM_guardedalloc.h"
63
64 #include "RE_render_ext.h"
65
66 #include "NOD_composite.h"
67
68 #include "DEG_depsgraph.h"
69 #include "DEG_depsgraph_query.h"
70
71 const EnumPropertyItem rna_enum_node_socket_in_out_items[] = {
72         { SOCK_IN, "IN", 0, "Input", "" },
73         { SOCK_OUT, "OUT", 0, "Output", "" },
74         { 0, NULL, 0, NULL, NULL }
75 };
76
77 #ifndef RNA_RUNTIME
78 static const EnumPropertyItem rna_enum_node_socket_draw_shape_items[] = {
79         {SOCK_DRAW_SHAPE_CIRCLE, "CIRCLE", 0, "Circle", ""},
80         {SOCK_DRAW_SHAPE_SQUARE, "SQUARE", 0, "Square", ""},
81         {SOCK_DRAW_SHAPE_DIAMOND, "DIAMOND", 0, "Diamond", ""},
82         {0, NULL, 0, NULL, NULL }
83 };
84
85 static const EnumPropertyItem node_socket_type_items[] = {
86         {SOCK_CUSTOM,  "CUSTOM",    0,    "Custom",    ""},
87         {SOCK_FLOAT,   "VALUE",     0,    "Value",     ""},
88         {SOCK_INT,     "INT",       0,    "Int",       ""},
89         {SOCK_BOOLEAN, "BOOLEAN",   0,    "Boolean",   ""},
90         {SOCK_VECTOR,  "VECTOR",    0,    "Vector",    ""},
91         {SOCK_STRING,  "STRING",    0,    "String",    ""},
92         {SOCK_RGBA,    "RGBA",      0,    "RGBA",      ""},
93         {SOCK_SHADER,  "SHADER",    0,    "Shader",    ""},
94         {0, NULL, 0, NULL, NULL}
95 };
96
97 static const EnumPropertyItem node_quality_items[] = {
98         {NTREE_QUALITY_HIGH,   "HIGH",     0,    "High",     "High quality"},
99         {NTREE_QUALITY_MEDIUM, "MEDIUM",   0,    "Medium",   "Medium quality"},
100         {NTREE_QUALITY_LOW,    "LOW",      0,    "Low",      "Low quality"},
101         {0, NULL, 0, NULL, NULL}
102 };
103
104 static const EnumPropertyItem node_chunksize_items[] = {
105         {NTREE_CHUNCKSIZE_32,   "32",     0,    "32x32",     "Chunksize of 32x32"},
106         {NTREE_CHUNCKSIZE_64,   "64",     0,    "64x64",     "Chunksize of 64x64"},
107         {NTREE_CHUNCKSIZE_128,  "128",    0,    "128x128",   "Chunksize of 128x128"},
108         {NTREE_CHUNCKSIZE_256,  "256",    0,    "256x256",   "Chunksize of 256x256"},
109         {NTREE_CHUNCKSIZE_512,  "512",    0,    "512x512",   "Chunksize of 512x512"},
110         {NTREE_CHUNCKSIZE_1024, "1024",   0,    "1024x1024", "Chunksize of 1024x1024"},
111         {0, NULL, 0, NULL, NULL}
112 };
113 #endif
114
115 const EnumPropertyItem rna_enum_node_math_items[] = {
116         {NODE_MATH_ADD,     "ADD",          0, "Add",          ""},
117         {NODE_MATH_SUB,     "SUBTRACT",     0, "Subtract",     ""},
118         {NODE_MATH_MUL,     "MULTIPLY",     0, "Multiply",     ""},
119         {NODE_MATH_DIVIDE,  "DIVIDE",       0, "Divide",       ""},
120         {0, "", ICON_NONE, NULL, NULL},
121         {NODE_MATH_POW,     "POWER",        0, "Power",        ""},
122         {NODE_MATH_LOG,     "LOGARITHM",    0, "Logarithm",    ""},
123         {NODE_MATH_SQRT,    "SQRT",         0, "Square Root",  ""},
124         {NODE_MATH_ABS,     "ABSOLUTE",     0, "Absolute",     ""},
125         {0, "", ICON_NONE, NULL, NULL},
126         {NODE_MATH_MIN,     "MINIMUM",      0, "Minimum",      ""},
127         {NODE_MATH_MAX,     "MAXIMUM",      0, "Maximum",      ""},
128         {NODE_MATH_LESS,    "LESS_THAN",    0, "Less Than",    ""},
129         {NODE_MATH_GREATER, "GREATER_THAN", 0, "Greater Than", ""},
130         {0, "", ICON_NONE, NULL, NULL},
131         {NODE_MATH_ROUND,   "ROUND",        0, "Round",        ""},
132         {NODE_MATH_FLOOR,   "FLOOR",        0, "Floor",        ""},
133         {NODE_MATH_CEIL,    "CEIL",         0, "Ceil",         ""},
134         {NODE_MATH_FRACT,   "FRACT",        0, "Fract",        ""},
135         {NODE_MATH_MOD,     "MODULO",       0, "Modulo",       ""},
136         {0, "", ICON_NONE, NULL, NULL},
137         {NODE_MATH_SIN,     "SINE",         0, "Sine",         ""},
138         {NODE_MATH_COS,     "COSINE",       0, "Cosine",       ""},
139         {NODE_MATH_TAN,     "TANGENT",      0, "Tangent",      ""},
140         {NODE_MATH_ASIN,    "ARCSINE",      0, "Arcsine",      ""},
141         {NODE_MATH_ACOS,    "ARCCOSINE",    0, "Arccosine",    ""},
142         {NODE_MATH_ATAN,    "ARCTANGENT",   0, "Arctangent",   ""},
143         {NODE_MATH_ATAN2,   "ARCTAN2",      0, "Arctan2",      ""},
144         {0, NULL, 0, NULL, NULL}
145 };
146
147 const EnumPropertyItem rna_enum_node_vec_math_items[] = {
148         {0, "ADD",           0, "Add",           ""},
149         {1, "SUBTRACT",      0, "Subtract",      ""},
150         {2, "AVERAGE",       0, "Average",       ""},
151         {3, "DOT_PRODUCT",   0, "Dot Product",   ""},
152         {4, "CROSS_PRODUCT", 0, "Cross Product", ""},
153         {5, "NORMALIZE",     0, "Normalize",     ""},
154         {0, NULL, 0, NULL, NULL}
155 };
156
157 const EnumPropertyItem rna_enum_node_filter_items[] = {
158         {0, "SOFTEN",  0, "Soften",  ""},
159         {1, "SHARPEN", 0, "Sharpen", ""},
160         {2, "LAPLACE", 0, "Laplace", ""},
161         {3, "SOBEL",   0, "Sobel",   ""},
162         {4, "PREWITT", 0, "Prewitt", ""},
163         {5, "KIRSCH",  0, "Kirsch",  ""},
164         {6, "SHADOW",  0, "Shadow",  ""},
165         {0, NULL, 0, NULL, NULL}
166 };
167
168 #ifndef RNA_RUNTIME
169 static const EnumPropertyItem node_sampler_type_items[] = {
170         {0, "NEAREST",   0, "Nearest",   ""},
171         {1, "BILINEAR",   0, "Bilinear",   ""},
172         {2, "BICUBIC", 0, "Bicubic", ""},
173         {0, NULL, 0, NULL, NULL}
174 };
175
176
177 static const EnumPropertyItem prop_shader_output_target_items[] = {
178         {SHD_OUTPUT_ALL, "ALL", 0, "All", "Use shaders for all renderers and viewports, unless there exists a more specific output"},
179         {SHD_OUTPUT_EEVEE, "EEVEE", 0, "Eevee", "Use shaders for Eevee renderer"},
180         {SHD_OUTPUT_CYCLES, "CYCLES", 0, "Cycles", "Use shaders for Cycles renderer"},
181         {0, NULL, 0, NULL, NULL}
182 };
183 #endif
184
185 #ifdef RNA_RUNTIME
186
187 #include "BLI_linklist.h"
188 #include "BLI_string.h"
189
190 #include "BKE_context.h"
191 #include "BKE_idprop.h"
192
193 #include "BKE_global.h"
194
195 #include "ED_node.h"
196 #include "ED_render.h"
197
198 #include "GPU_material.h"
199
200 #include "NOD_common.h"
201 #include "NOD_socket.h"
202
203 #include "RE_engine.h"
204 #include "RE_pipeline.h"
205
206 #include "DNA_scene_types.h"
207 #include "WM_api.h"
208
209
210 int rna_node_tree_type_to_enum(bNodeTreeType *typeinfo)
211 {
212         int i = 0, result = -1;
213         NODE_TREE_TYPES_BEGIN (nt)
214         {
215                 if (nt == typeinfo) {
216                         result = i;
217                         break;
218                 }
219                 ++i;
220         }
221         NODE_TREE_TYPES_END;
222         return result;
223 }
224
225 int rna_node_tree_idname_to_enum(const char *idname)
226 {
227         int i = 0, result = -1;
228         NODE_TREE_TYPES_BEGIN (nt)
229         {
230                 if (STREQ(nt->idname, idname)) {
231                         result = i;
232                         break;
233                 }
234                 ++i;
235         }
236         NODE_TREE_TYPES_END;
237         return result;
238 }
239
240 bNodeTreeType *rna_node_tree_type_from_enum(int value)
241 {
242         int i = 0;
243         bNodeTreeType *result = NULL;
244         NODE_TREE_TYPES_BEGIN (nt)
245         {
246                 if (i == value) {
247                         result = nt;
248                         break;
249                 }
250                 ++i;
251         }
252         NODE_TREE_TYPES_END;
253         return result;
254 }
255
256 const EnumPropertyItem *rna_node_tree_type_itemf(void *data, bool (*poll)(void *data, bNodeTreeType *), bool *r_free)
257 {
258         EnumPropertyItem tmp = {0};
259         EnumPropertyItem *item = NULL;
260         int totitem = 0, i = 0;
261
262         NODE_TREE_TYPES_BEGIN (nt)
263         {
264                 if (poll && !poll(data, nt)) {
265                         ++i;
266                         continue;
267                 }
268
269                 tmp.value = i;
270                 tmp.identifier = nt->idname;
271                 tmp.icon = nt->ui_icon;
272                 tmp.name = nt->ui_name;
273                 tmp.description = nt->ui_description;
274
275                 RNA_enum_item_add(&item, &totitem, &tmp);
276
277                 ++i;
278         }
279         NODE_TREE_TYPES_END;
280
281         if (totitem == 0) {
282                 *r_free = false;
283                 return DummyRNA_NULL_items;
284         }
285
286         RNA_enum_item_end(&item, &totitem);
287         *r_free = true;
288
289         return item;
290 }
291
292 int rna_node_type_to_enum(bNodeType *typeinfo)
293 {
294         int i = 0, result = -1;
295         NODE_TYPES_BEGIN(ntype) {
296                 if (ntype == typeinfo) {
297                         result = i;
298                         break;
299                 }
300                 ++i;
301         } NODE_TYPES_END;
302         return result;
303 }
304
305 int rna_node_idname_to_enum(const char *idname)
306 {
307         int i = 0, result = -1;
308         NODE_TYPES_BEGIN(ntype) {
309                 if (STREQ(ntype->idname, idname)) {
310                         result = i;
311                         break;
312                 }
313                 ++i;
314         } NODE_TYPES_END;
315         return result;
316 }
317
318 bNodeType *rna_node_type_from_enum(int value)
319 {
320         int i = 0;
321         bNodeType *result = NULL;
322         NODE_TYPES_BEGIN(ntype) {
323                 if (i == value) {
324                         result = ntype;
325                         break;
326                 }
327                 ++i;
328         } NODE_TYPES_END;
329         return result;
330 }
331
332 const EnumPropertyItem *rna_node_type_itemf(void *data, bool (*poll)(void *data, bNodeType *), bool *r_free)
333 {
334         EnumPropertyItem *item = NULL;
335         EnumPropertyItem tmp = {0};
336         int totitem = 0, i = 0;
337
338         NODE_TYPES_BEGIN(ntype) {
339                 if (poll && !poll(data, ntype)) {
340                         ++i;
341                         continue;
342                 }
343
344                 tmp.value = i;
345                 tmp.identifier = ntype->idname;
346                 tmp.icon = ntype->ui_icon;
347                 tmp.name = ntype->ui_name;
348                 tmp.description = ntype->ui_description;
349
350                 RNA_enum_item_add(&item, &totitem, &tmp);
351
352                 ++i;
353         } NODE_TYPES_END;
354
355         if (totitem == 0) {
356                 *r_free = false;
357                 return DummyRNA_NULL_items;
358         }
359
360         RNA_enum_item_end(&item, &totitem);
361         *r_free = true;
362
363         return item;
364 }
365
366 int rna_node_socket_type_to_enum(bNodeSocketType *typeinfo)
367 {
368         int i = 0, result = -1;
369         NODE_SOCKET_TYPES_BEGIN(stype) {
370                 if (stype == typeinfo) {
371                         result = i;
372                         break;
373                 }
374                 ++i;
375         } NODE_SOCKET_TYPES_END;
376         return result;
377 }
378
379 int rna_node_socket_idname_to_enum(const char *idname)
380 {
381         int i = 0, result = -1;
382         NODE_SOCKET_TYPES_BEGIN(stype) {
383                 if (STREQ(stype->idname, idname)) {
384                         result = i;
385                         break;
386                 }
387                 ++i;
388         } NODE_SOCKET_TYPES_END;
389         return result;
390 }
391
392 bNodeSocketType *rna_node_socket_type_from_enum(int value)
393 {
394         int i = 0;
395         bNodeSocketType *result = NULL;
396         NODE_SOCKET_TYPES_BEGIN(stype) {
397                 if (i == value) {
398                         result = stype;
399                         break;
400                 }
401                 ++i;
402         } NODE_SOCKET_TYPES_END;
403         return result;
404 }
405
406 const EnumPropertyItem *rna_node_socket_type_itemf(
407         void *data, bool (*poll)(void *data, bNodeSocketType *), bool *r_free)
408 {
409         EnumPropertyItem *item = NULL;
410         EnumPropertyItem tmp = {0};
411         int totitem = 0, i = 0;
412         StructRNA *srna;
413
414         NODE_SOCKET_TYPES_BEGIN(stype) {
415                 if (poll && !poll(data, stype)) {
416                         ++i;
417                         continue;
418                 }
419
420                 srna = stype->ext_socket.srna;
421                 tmp.value = i;
422                 tmp.identifier = stype->idname;
423                 tmp.icon = RNA_struct_ui_icon(srna);
424                 tmp.name = RNA_struct_ui_name(srna);
425                 tmp.description = RNA_struct_ui_description(srna);
426
427                 RNA_enum_item_add(&item, &totitem, &tmp);
428
429                 ++i;
430         }
431         NODE_SOCKET_TYPES_END;
432
433         if (totitem == 0) {
434                 *r_free = false;
435                 return DummyRNA_NULL_items;
436         }
437
438         RNA_enum_item_end(&item, &totitem);
439         *r_free = true;
440
441         return item;
442 }
443
444 static const EnumPropertyItem *rna_node_static_type_itemf(bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop), bool *r_free)
445 {
446         EnumPropertyItem *item = NULL;
447         EnumPropertyItem tmp;
448         int totitem = 0;
449
450         /* hack, don't want to add include path to RNA just for this, since in the future RNA types
451          * for nodes should be defined locally at runtime anyway ...
452          */
453
454         tmp.value = NODE_CUSTOM;
455         tmp.identifier = "CUSTOM";
456         tmp.name = "Custom";
457         tmp.description = "Custom Node";
458         tmp.icon = ICON_NONE;
459         RNA_enum_item_add(&item, &totitem, &tmp);
460
461         tmp.value = NODE_UNDEFINED;
462         tmp.identifier = "UNDEFINED";
463         tmp.name = "UNDEFINED";
464         tmp.description = "";
465         tmp.icon = ICON_NONE;
466         RNA_enum_item_add(&item, &totitem, &tmp);
467
468 #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
469         if (STREQ(#Category, "Node")) { \
470                 tmp.value = ID; \
471                 tmp.identifier = EnumName; \
472                 tmp.name = UIName; \
473                 tmp.description = UIDesc; \
474                 tmp.icon = ICON_NONE; \
475                 RNA_enum_item_add(&item, &totitem, &tmp); \
476         }
477 #include "../../nodes/NOD_static_types.h"
478 #undef DefNode
479
480         if (RNA_struct_is_a(ptr->type, &RNA_ShaderNode)) {
481 #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
482                 if (STREQ(#Category, "ShaderNode")) { \
483                         tmp.value = ID; \
484                         tmp.identifier = EnumName; \
485                         tmp.name = UIName; \
486                         tmp.description = UIDesc; \
487                         tmp.icon = ICON_NONE; \
488                         RNA_enum_item_add(&item, &totitem, &tmp); \
489                 }
490 #include "../../nodes/NOD_static_types.h"
491 #undef DefNode
492         }
493
494         if (RNA_struct_is_a(ptr->type, &RNA_CompositorNode)) {
495 #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
496                 if (STREQ(#Category, "CompositorNode")) { \
497                         tmp.value = ID; \
498                         tmp.identifier = EnumName; \
499                         tmp.name = UIName; \
500                         tmp.description = UIDesc; \
501                         tmp.icon = ICON_NONE; \
502                         RNA_enum_item_add(&item, &totitem, &tmp); \
503                 }
504 #include "../../nodes/NOD_static_types.h"
505 #undef DefNode
506         }
507
508         if (RNA_struct_is_a(ptr->type, &RNA_TextureNode)) {
509 #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
510                 if (STREQ(#Category, "TextureNode")) { \
511                         tmp.value = ID; \
512                         tmp.identifier = EnumName; \
513                         tmp.name = UIName; \
514                         tmp.description = UIDesc; \
515                         tmp.icon = ICON_NONE; \
516                         RNA_enum_item_add(&item, &totitem, &tmp); \
517                 }
518 #include "../../nodes/NOD_static_types.h"
519 #undef DefNode
520         }
521
522         RNA_enum_item_end(&item, &totitem);
523         *r_free = true;
524
525         return item;
526 }
527
528 /* ******** Node Tree ******** */
529
530 static StructRNA *rna_NodeTree_refine(struct PointerRNA *ptr)
531 {
532         bNodeTree *ntree = (bNodeTree *)ptr->data;
533
534         if (ntree->typeinfo->ext.srna)
535                 return ntree->typeinfo->ext.srna;
536         else
537                 return &RNA_NodeTree;
538 }
539
540 static bool rna_NodeTree_poll(const bContext *C, bNodeTreeType *ntreetype)
541 {
542         extern FunctionRNA rna_NodeTree_poll_func;
543
544         PointerRNA ptr;
545         ParameterList list;
546         FunctionRNA *func;
547         void *ret;
548         bool visible;
549
550         RNA_pointer_create(NULL, ntreetype->ext.srna, NULL, &ptr); /* dummy */
551         func = &rna_NodeTree_poll_func; /* RNA_struct_find_function(&ptr, "poll"); */
552
553         RNA_parameter_list_create(&list, &ptr, func);
554         RNA_parameter_set_lookup(&list, "context", &C);
555         ntreetype->ext.call((bContext *)C, &ptr, func, &list);
556
557         RNA_parameter_get_lookup(&list, "visible", &ret);
558         visible = *(bool *)ret;
559
560         RNA_parameter_list_free(&list);
561
562         return visible;
563 }
564
565 static void rna_NodeTree_update_reg(bNodeTree *ntree)
566 {
567         extern FunctionRNA rna_NodeTree_update_func;
568
569         PointerRNA ptr;
570         ParameterList list;
571         FunctionRNA *func;
572
573         RNA_id_pointer_create(&ntree->id, &ptr);
574         func = &rna_NodeTree_update_func; /* RNA_struct_find_function(&ptr, "update"); */
575
576         RNA_parameter_list_create(&list, &ptr, func);
577         ntree->typeinfo->ext.call(NULL, &ptr, func, &list);
578
579         RNA_parameter_list_free(&list);
580 }
581
582 static void rna_NodeTree_get_from_context(const bContext *C, bNodeTreeType *ntreetype,
583                                           bNodeTree **r_ntree, ID **r_id, ID **r_from)
584 {
585         extern FunctionRNA rna_NodeTree_get_from_context_func;
586
587         PointerRNA ptr;
588         ParameterList list;
589         FunctionRNA *func;
590         void *ret1, *ret2, *ret3;
591
592         RNA_pointer_create(NULL, ntreetype->ext.srna, NULL, &ptr); /* dummy */
593         func = &rna_NodeTree_get_from_context_func; /* RNA_struct_find_function(&ptr, "get_from_context"); */
594
595         RNA_parameter_list_create(&list, &ptr, func);
596         RNA_parameter_set_lookup(&list, "context", &C);
597         ntreetype->ext.call((bContext *)C, &ptr, func, &list);
598
599         RNA_parameter_get_lookup(&list, "result_1", &ret1);
600         RNA_parameter_get_lookup(&list, "result_2", &ret2);
601         RNA_parameter_get_lookup(&list, "result_3", &ret3);
602         *r_ntree = *(bNodeTree **)ret1;
603         *r_id = *(ID **)ret2;
604         *r_from = *(ID **)ret3;
605
606         RNA_parameter_list_free(&list);
607 }
608
609 static void rna_NodeTree_unregister(Main *UNUSED(bmain), StructRNA *type)
610 {
611         bNodeTreeType *nt = RNA_struct_blender_type_get(type);
612
613         if (!nt)
614                 return;
615
616         RNA_struct_free_extension(type, &nt->ext);
617         RNA_struct_free(&BLENDER_RNA, type);
618
619         ntreeTypeFreeLink(nt);
620
621         /* update while blender is running */
622         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
623 }
624
625 static StructRNA *rna_NodeTree_register(
626         Main *bmain, ReportList *reports, void *data, const char *identifier,
627         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
628 {
629         bNodeTreeType *nt, dummynt;
630         bNodeTree dummyntree;
631         PointerRNA dummyptr;
632         int have_function[3];
633
634         /* setup dummy tree & tree type to store static properties in */
635         memset(&dummynt, 0, sizeof(bNodeTreeType));
636         memset(&dummyntree, 0, sizeof(bNodeTree));
637         dummyntree.typeinfo = &dummynt;
638         RNA_pointer_create(NULL, &RNA_NodeTree, &dummyntree, &dummyptr);
639
640         /* validate the python class */
641         if (validate(&dummyptr, data, have_function) != 0)
642                 return NULL;
643
644         if (strlen(identifier) >= sizeof(dummynt.idname)) {
645                 BKE_reportf(reports, RPT_ERROR, "Registering node tree class: '%s' is too long, maximum length is %d",
646                             identifier, (int)sizeof(dummynt.idname));
647                 return NULL;
648         }
649
650         /* check if we have registered this tree type before, and remove it */
651         nt = ntreeTypeFind(dummynt.idname);
652         if (nt) {
653                 rna_NodeTree_unregister(bmain, nt->ext.srna);
654         }
655
656         /* create a new node tree type */
657         nt = MEM_callocN(sizeof(bNodeTreeType), "node tree type");
658         memcpy(nt, &dummynt, sizeof(dummynt));
659
660         nt->type = NTREE_CUSTOM;
661
662         nt->ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, nt->idname, &RNA_NodeTree);
663         nt->ext.data = data;
664         nt->ext.call = call;
665         nt->ext.free = free;
666         RNA_struct_blender_type_set(nt->ext.srna, nt);
667
668         RNA_def_struct_ui_text(nt->ext.srna, nt->ui_name, nt->ui_description);
669         RNA_def_struct_ui_icon(nt->ext.srna, nt->ui_icon);
670
671         nt->poll = (have_function[0]) ? rna_NodeTree_poll : NULL;
672         nt->update = (have_function[1]) ? rna_NodeTree_update_reg : NULL;
673         nt->get_from_context = (have_function[2]) ? rna_NodeTree_get_from_context : NULL;
674
675         ntreeTypeAdd(nt);
676
677         /* update while blender is running */
678         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
679
680         return nt->ext.srna;
681 }
682
683 static bool rna_NodeTree_check(bNodeTree *ntree, ReportList *reports)
684 {
685         if (!ntreeIsRegistered(ntree)) {
686                 if (reports)
687                         BKE_reportf(reports, RPT_ERROR, "Node tree '%s' has undefined type %s", ntree->id.name + 2, ntree->idname);
688
689                 return false;
690         }
691         else
692                 return true;
693 }
694
695 static void rna_NodeTree_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
696 {
697         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
698         bNode *node = (bNode *)ptr->data;
699
700         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
701         WM_main_add_notifier(NC_SCENE | ND_NODES, &ntree->id);
702
703         ED_node_tag_update_nodetree(bmain, ntree, node);
704 }
705
706 static bNode *rna_NodeTree_node_new(bNodeTree *ntree, bContext *C, ReportList *reports, const char *type)
707 {
708         bNodeType *ntype;
709         bNode *node;
710
711         if (!rna_NodeTree_check(ntree, reports))
712                 return NULL;
713
714         ntype = nodeTypeFind(type);
715         if (!ntype) {
716                 BKE_reportf(reports, RPT_ERROR, "Node type %s undefined", type);
717                 return NULL;
718         }
719
720         if (ntype->poll && !ntype->poll(ntype, ntree)) {
721                 BKE_reportf(reports, RPT_ERROR, "Cannot add node of type %s to node tree '%s'", type, ntree->id.name + 2);
722                 return NULL;
723         }
724
725         node = nodeAddNode(C, ntree, type);
726         BLI_assert(node && node->typeinfo);
727
728         if (ntree->type == NTREE_TEXTURE) {
729                 ntreeTexCheckCyclics(ntree);
730         }
731
732         ntreeUpdateTree(CTX_data_main(C), ntree);
733         nodeUpdate(ntree, node);
734         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
735
736         return node;
737 }
738
739 static void rna_NodeTree_node_remove(bNodeTree *ntree, Main *bmain, ReportList *reports, PointerRNA *node_ptr)
740 {
741         bNode *node = node_ptr->data;
742
743         if (!rna_NodeTree_check(ntree, reports))
744                 return;
745
746         if (BLI_findindex(&ntree->nodes, node) == -1) {
747                 BKE_reportf(reports, RPT_ERROR, "Unable to locate node '%s' in node tree", node->name);
748                 return;
749         }
750
751         id_us_min(node->id);
752         nodeDeleteNode(bmain, ntree, node);
753         RNA_POINTER_INVALIDATE(node_ptr);
754
755         ntreeUpdateTree(bmain, ntree); /* update group node socket links */
756         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
757 }
758
759 static void rna_NodeTree_node_clear(bNodeTree *ntree, Main *bmain, ReportList *reports)
760 {
761         bNode *node = ntree->nodes.first;
762
763         if (!rna_NodeTree_check(ntree, reports))
764                 return;
765
766         while (node) {
767                 bNode *next_node = node->next;
768
769                 if (node->id)
770                         id_us_min(node->id);
771
772                 nodeDeleteNode(bmain, ntree, node);
773
774                 node = next_node;
775         }
776
777         ntreeUpdateTree(bmain, ntree);
778
779         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
780 }
781
782 static PointerRNA rna_NodeTree_active_node_get(PointerRNA *ptr)
783 {
784         bNodeTree *ntree = (bNodeTree *)ptr->data;
785         bNode *node = nodeGetActive(ntree);
786         return rna_pointer_inherit_refine(ptr, &RNA_Node, node);
787 }
788
789 static void rna_NodeTree_active_node_set(PointerRNA *ptr, const PointerRNA value)
790 {
791         bNodeTree *ntree = (bNodeTree *)ptr->data;
792         bNode *node = (bNode *)value.data;
793
794         if (node && BLI_findindex(&ntree->nodes, node) != -1)
795                 nodeSetActive(ntree, node);
796         else
797                 nodeClearActive(ntree);
798 }
799
800 static bNodeLink *rna_NodeTree_link_new(bNodeTree *ntree, Main *bmain, ReportList *reports,
801                                         bNodeSocket *fromsock, bNodeSocket *tosock,
802                                         bool verify_limits)
803 {
804         bNodeLink *ret;
805         bNode *fromnode = NULL, *tonode = NULL;
806
807         if (!rna_NodeTree_check(ntree, reports))
808                 return NULL;
809
810         nodeFindNode(ntree, fromsock, &fromnode, NULL);
811         nodeFindNode(ntree, tosock, &tonode, NULL);
812         /* check validity of the sockets:
813          * if sockets from different trees are passed in this will fail!
814          */
815         if (!fromnode || !tonode)
816                 return NULL;
817
818         if (&fromsock->in_out == &tosock->in_out) {
819                 BKE_report(reports, RPT_ERROR, "Same input/output direction of sockets");
820                 return NULL;
821         }
822
823         if (verify_limits) {
824                 /* remove other socket links if limit is exceeded */
825                 if (nodeCountSocketLinks(ntree, fromsock) + 1 > fromsock->limit)
826                         nodeRemSocketLinks(ntree, fromsock);
827                 if (nodeCountSocketLinks(ntree, tosock) + 1 > tosock->limit)
828                         nodeRemSocketLinks(ntree, tosock);
829         }
830
831         ret = nodeAddLink(ntree, fromnode, fromsock, tonode, tosock);
832
833         if (ret) {
834
835                 /* not an issue from the UI, clear hidden from API to keep valid state. */
836                 fromsock->flag &= ~SOCK_HIDDEN;
837                 tosock->flag   &= ~SOCK_HIDDEN;
838
839                 if (tonode)
840                         nodeUpdate(ntree, tonode);
841
842                 ntreeUpdateTree(bmain, ntree);
843
844                 ED_node_tag_update_nodetree(bmain, ntree, ret->tonode);
845                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
846         }
847         return ret;
848 }
849
850 static void rna_NodeTree_link_remove(bNodeTree *ntree, Main *bmain, ReportList *reports, PointerRNA *link_ptr)
851 {
852         bNodeLink *link = link_ptr->data;
853
854         if (!rna_NodeTree_check(ntree, reports))
855                 return;
856
857         if (BLI_findindex(&ntree->links, link) == -1) {
858                 BKE_report(reports, RPT_ERROR, "Unable to locate link in node tree");
859                 return;
860         }
861
862         nodeRemLink(ntree, link);
863         RNA_POINTER_INVALIDATE(link_ptr);
864
865         ntreeUpdateTree(bmain, ntree);
866         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
867 }
868
869 static void rna_NodeTree_link_clear(bNodeTree *ntree, Main *bmain, ReportList *reports)
870 {
871         bNodeLink *link = ntree->links.first;
872
873         if (!rna_NodeTree_check(ntree, reports))
874                 return;
875
876         while (link) {
877                 bNodeLink *next_link = link->next;
878
879                 nodeRemLink(ntree, link);
880
881                 link = next_link;
882         }
883         ntreeUpdateTree(bmain, ntree);
884
885         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
886 }
887
888 static int rna_NodeTree_active_input_get(PointerRNA *ptr)
889 {
890         bNodeTree *ntree = (bNodeTree *)ptr->data;
891         bNodeSocket *gsock;
892         int index;
893
894         for (gsock = ntree->inputs.first, index = 0; gsock; gsock = gsock->next, ++index)
895                 if (gsock->flag & SELECT)
896                         return index;
897         return -1;
898 }
899
900 static void rna_NodeTree_active_input_set(PointerRNA *ptr, int value)
901 {
902         bNodeTree *ntree = (bNodeTree *)ptr->data;
903         bNodeSocket *gsock;
904         int index;
905
906         for (gsock = ntree->inputs.first, index = 0; gsock; gsock = gsock->next, ++index) {
907                 if (index == value)
908                         gsock->flag |= SELECT;
909                 else
910                         gsock->flag &= ~SELECT;
911         }
912         for (gsock = ntree->outputs.first; gsock; gsock = gsock->next) {
913                 gsock->flag &= ~SELECT;
914         }
915 }
916
917 static int rna_NodeTree_active_output_get(PointerRNA *ptr)
918 {
919         bNodeTree *ntree = (bNodeTree *)ptr->data;
920         bNodeSocket *gsock;
921         int index;
922
923         for (gsock = ntree->outputs.first, index = 0; gsock; gsock = gsock->next, ++index)
924                 if (gsock->flag & SELECT)
925                         return index;
926         return -1;
927 }
928
929 static void rna_NodeTree_active_output_set(PointerRNA *ptr, int value)
930 {
931         bNodeTree *ntree = (bNodeTree *)ptr->data;
932         bNodeSocket *gsock;
933         int index;
934
935         for (gsock = ntree->inputs.first; gsock; gsock = gsock->next) {
936                 gsock->flag &= ~SELECT;
937         }
938         for (gsock = ntree->outputs.first, index = 0; gsock; gsock = gsock->next, ++index) {
939                 if (index == value)
940                         gsock->flag |= SELECT;
941                 else
942                         gsock->flag &= ~SELECT;
943         }
944 }
945
946 static bNodeSocket *rna_NodeTree_inputs_new(bNodeTree *ntree, Main *bmain, ReportList *reports, const char *type, const char *name)
947 {
948         bNodeSocket *sock;
949
950         if (!rna_NodeTree_check(ntree, reports))
951                 return NULL;
952
953         sock = ntreeAddSocketInterface(ntree, SOCK_IN, type, name);
954
955         ntreeUpdateTree(bmain, ntree);
956         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
957
958         return sock;
959 }
960
961 static bNodeSocket *rna_NodeTree_outputs_new(bNodeTree *ntree, Main *bmain, ReportList *reports, const char *type, const char *name)
962 {
963         bNodeSocket *sock;
964
965         if (!rna_NodeTree_check(ntree, reports))
966                 return NULL;
967
968         sock = ntreeAddSocketInterface(ntree, SOCK_OUT, type, name);
969
970         ntreeUpdateTree(bmain, ntree);
971         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
972
973         return sock;
974 }
975
976 static void rna_NodeTree_socket_remove(bNodeTree *ntree, Main *bmain, ReportList *reports, bNodeSocket *sock)
977 {
978         if (!rna_NodeTree_check(ntree, reports))
979                 return;
980
981         if (BLI_findindex(&ntree->inputs, sock) == -1 && BLI_findindex(&ntree->outputs, sock) == -1) {
982                 BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier);
983         }
984         else {
985                 ntreeRemoveSocketInterface(ntree, sock);
986
987                 ntreeUpdateTree(bmain, ntree);
988                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
989         }
990 }
991
992 static void rna_NodeTree_inputs_clear(bNodeTree *ntree, Main *bmain, ReportList *reports)
993 {
994         bNodeSocket *sock, *nextsock;
995
996         if (!rna_NodeTree_check(ntree, reports))
997                 return;
998
999         for (sock = ntree->inputs.first; sock; sock = nextsock) {
1000                 nextsock = sock->next;
1001                 ntreeRemoveSocketInterface(ntree, sock);
1002         }
1003
1004         ntreeUpdateTree(bmain, ntree);
1005         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1006 }
1007
1008 static void rna_NodeTree_outputs_clear(bNodeTree *ntree, Main *bmain, ReportList *reports)
1009 {
1010         bNodeSocket *sock, *nextsock;
1011
1012         if (!rna_NodeTree_check(ntree, reports))
1013                 return;
1014
1015         for (sock = ntree->outputs.first; sock; sock = nextsock) {
1016                 nextsock = sock->next;
1017                 ntreeRemoveSocketInterface(ntree, sock);
1018         }
1019
1020         ntreeUpdateTree(bmain, ntree);
1021         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1022 }
1023
1024 static void rna_NodeTree_inputs_move(bNodeTree *ntree, Main *bmain, int from_index, int to_index)
1025 {
1026         bNodeSocket *sock;
1027
1028         if (from_index == to_index)
1029                 return;
1030         if (from_index < 0 || to_index < 0)
1031                 return;
1032
1033         sock = BLI_findlink(&ntree->inputs, from_index);
1034         if (to_index < from_index) {
1035                 bNodeSocket *nextsock = BLI_findlink(&ntree->inputs, to_index);
1036                 if (nextsock) {
1037                         BLI_remlink(&ntree->inputs, sock);
1038                         BLI_insertlinkbefore(&ntree->inputs, nextsock, sock);
1039                 }
1040         }
1041         else {
1042                 bNodeSocket *prevsock = BLI_findlink(&ntree->inputs, to_index);
1043                 if (prevsock) {
1044                         BLI_remlink(&ntree->inputs, sock);
1045                         BLI_insertlinkafter(&ntree->inputs, prevsock, sock);
1046                 }
1047         }
1048
1049         ntree->update |= NTREE_UPDATE_GROUP_IN;
1050
1051         ntreeUpdateTree(bmain, ntree);
1052         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1053 }
1054
1055 static void rna_NodeTree_outputs_move(bNodeTree *ntree, Main *bmain, int from_index, int to_index)
1056 {
1057         bNodeSocket *sock;
1058
1059         if (from_index == to_index)
1060                 return;
1061         if (from_index < 0 || to_index < 0)
1062                 return;
1063
1064         sock = BLI_findlink(&ntree->outputs, from_index);
1065         if (to_index < from_index) {
1066                 bNodeSocket *nextsock = BLI_findlink(&ntree->outputs, to_index);
1067                 if (nextsock) {
1068                         BLI_remlink(&ntree->outputs, sock);
1069                         BLI_insertlinkbefore(&ntree->outputs, nextsock, sock);
1070                 }
1071         }
1072         else {
1073                 bNodeSocket *prevsock = BLI_findlink(&ntree->outputs, to_index);
1074                 if (prevsock) {
1075                         BLI_remlink(&ntree->outputs, sock);
1076                         BLI_insertlinkafter(&ntree->outputs, prevsock, sock);
1077                 }
1078         }
1079
1080         ntree->update |= NTREE_UPDATE_GROUP_OUT;
1081
1082         ntreeUpdateTree(bmain, ntree);
1083         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1084 }
1085
1086 static void rna_NodeTree_interface_update(bNodeTree *ntree, bContext *C)
1087 {
1088         Main *bmain = CTX_data_main(C);
1089
1090         ntree->update |= NTREE_UPDATE_GROUP;
1091         ntreeUpdateTree(bmain, ntree);
1092
1093         ED_node_tag_update_nodetree(bmain, ntree, NULL);
1094 }
1095
1096
1097 /* ******** NodeLink ******** */
1098
1099 static bool rna_NodeLink_is_hidden_get(PointerRNA *ptr)
1100 {
1101         bNodeLink *link = ptr->data;
1102         return nodeLinkIsHidden(link);
1103 }
1104
1105
1106 /* ******** Node ******** */
1107
1108 static StructRNA *rna_Node_refine(struct PointerRNA *ptr)
1109 {
1110         bNode *node = (bNode *)ptr->data;
1111
1112         if (node->typeinfo->ext.srna)
1113                 return node->typeinfo->ext.srna;
1114         else
1115                 return ptr->type;
1116 }
1117
1118 static char *rna_Node_path(PointerRNA *ptr)
1119 {
1120         bNode *node = (bNode *)ptr->data;
1121         char name_esc[sizeof(node->name) * 2];
1122
1123         BLI_strescape(name_esc, node->name, sizeof(name_esc));
1124         return BLI_sprintfN("nodes[\"%s\"]", name_esc);
1125 }
1126
1127 char *rna_Node_ImageUser_path(PointerRNA *ptr)
1128 {
1129         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1130         bNode *node;
1131         char name_esc[sizeof(node->name) * 2];
1132
1133         for (node = ntree->nodes.first; node; node = node->next) {
1134                 if (node->type == SH_NODE_TEX_ENVIRONMENT) {
1135                         NodeTexEnvironment *data = node->storage;
1136                         if (&data->iuser != ptr->data)
1137                                 continue;
1138                 }
1139                 else if (node->type == SH_NODE_TEX_IMAGE) {
1140                         NodeTexImage *data = node->storage;
1141                         if (&data->iuser != ptr->data)
1142                                 continue;
1143                 }
1144                 else
1145                         continue;
1146
1147                 BLI_strescape(name_esc, node->name, sizeof(name_esc));
1148                 return BLI_sprintfN("nodes[\"%s\"].image_user", name_esc);
1149         }
1150
1151         return NULL;
1152 }
1153
1154 static bool rna_Node_poll(bNodeType *ntype, bNodeTree *ntree)
1155 {
1156         extern FunctionRNA rna_Node_poll_func;
1157
1158         PointerRNA ptr;
1159         ParameterList list;
1160         FunctionRNA *func;
1161         void *ret;
1162         bool visible;
1163
1164         RNA_pointer_create(NULL, ntype->ext.srna, NULL, &ptr); /* dummy */
1165         func = &rna_Node_poll_func; /* RNA_struct_find_function(&ptr, "poll"); */
1166
1167         RNA_parameter_list_create(&list, &ptr, func);
1168         RNA_parameter_set_lookup(&list, "node_tree", &ntree);
1169         ntype->ext.call(NULL, &ptr, func, &list);
1170
1171         RNA_parameter_get_lookup(&list, "visible", &ret);
1172         visible = *(bool *)ret;
1173
1174         RNA_parameter_list_free(&list);
1175
1176         return visible;
1177 }
1178
1179 static bool rna_Node_poll_instance(bNode *node, bNodeTree *ntree)
1180 {
1181         extern FunctionRNA rna_Node_poll_instance_func;
1182
1183         PointerRNA ptr;
1184         ParameterList list;
1185         FunctionRNA *func;
1186         void *ret;
1187         bool visible;
1188
1189         RNA_pointer_create(NULL, node->typeinfo->ext.srna, node, &ptr); /* dummy */
1190         func = &rna_Node_poll_instance_func; /* RNA_struct_find_function(&ptr, "poll_instance"); */
1191
1192         RNA_parameter_list_create(&list, &ptr, func);
1193         RNA_parameter_set_lookup(&list, "node_tree", &ntree);
1194         node->typeinfo->ext.call(NULL, &ptr, func, &list);
1195
1196         RNA_parameter_get_lookup(&list, "visible", &ret);
1197         visible = *(bool *)ret;
1198
1199         RNA_parameter_list_free(&list);
1200
1201         return visible;
1202 }
1203
1204 static bool rna_Node_poll_instance_default(bNode *node, bNodeTree *ntree)
1205 {
1206         /* use the basic poll function */
1207         return rna_Node_poll(node->typeinfo, ntree);
1208 }
1209
1210 static void rna_Node_update_reg(bNodeTree *ntree, bNode *node)
1211 {
1212         extern FunctionRNA rna_Node_update_func;
1213
1214         PointerRNA ptr;
1215         ParameterList list;
1216         FunctionRNA *func;
1217
1218         RNA_pointer_create((ID *)ntree, node->typeinfo->ext.srna, node, &ptr);
1219         func = &rna_Node_update_func; /* RNA_struct_find_function(&ptr, "update"); */
1220
1221         RNA_parameter_list_create(&list, &ptr, func);
1222         node->typeinfo->ext.call(NULL, &ptr, func, &list);
1223
1224         RNA_parameter_list_free(&list);
1225 }
1226
1227 static void rna_Node_insert_link(bNodeTree *ntree, bNode *node, bNodeLink *link)
1228 {
1229         extern FunctionRNA rna_Node_insert_link_func;
1230
1231         PointerRNA ptr;
1232         ParameterList list;
1233         FunctionRNA *func;
1234
1235         RNA_pointer_create((ID *)ntree, node->typeinfo->ext.srna, node, &ptr);
1236         func = &rna_Node_insert_link_func;
1237
1238         RNA_parameter_list_create(&list, &ptr, func);
1239         RNA_parameter_set_lookup(&list, "link", &link);
1240         node->typeinfo->ext.call(NULL, &ptr, func, &list);
1241
1242         RNA_parameter_list_free(&list);
1243 }
1244
1245 static void rna_Node_init(const bContext *C, PointerRNA *ptr)
1246 {
1247         extern FunctionRNA rna_Node_init_func;
1248
1249         bNode *node = (bNode *)ptr->data;
1250         ParameterList list;
1251         FunctionRNA *func;
1252
1253         func = &rna_Node_init_func; /* RNA_struct_find_function(&ptr, "init"); */
1254
1255         RNA_parameter_list_create(&list, ptr, func);
1256         node->typeinfo->ext.call((bContext *)C, ptr, func, &list);
1257
1258         RNA_parameter_list_free(&list);
1259 }
1260
1261 static void rna_Node_copy(PointerRNA *ptr, struct bNode *copynode)
1262 {
1263         extern FunctionRNA rna_Node_copy_func;
1264
1265         bNode *node = (bNode *)ptr->data;
1266         ParameterList list;
1267         FunctionRNA *func;
1268
1269         func = &rna_Node_copy_func; /* RNA_struct_find_function(&ptr, "copy"); */
1270
1271         RNA_parameter_list_create(&list, ptr, func);
1272         RNA_parameter_set_lookup(&list, "node", &copynode);
1273         node->typeinfo->ext.call(NULL, ptr, func, &list);
1274
1275         RNA_parameter_list_free(&list);
1276 }
1277
1278 static void rna_Node_free(PointerRNA *ptr)
1279 {
1280         extern FunctionRNA rna_Node_free_func;
1281
1282         bNode *node = (bNode *)ptr->data;
1283         ParameterList list;
1284         FunctionRNA *func;
1285
1286         func = &rna_Node_free_func; /* RNA_struct_find_function(&ptr, "free"); */
1287
1288         RNA_parameter_list_create(&list, ptr, func);
1289         node->typeinfo->ext.call(NULL, ptr, func, &list);
1290
1291         RNA_parameter_list_free(&list);
1292 }
1293
1294 static void rna_Node_draw_buttons(struct uiLayout *layout, bContext *C, PointerRNA *ptr)
1295 {
1296         extern FunctionRNA rna_Node_draw_buttons_func;
1297
1298         bNode *node = (bNode *)ptr->data;
1299         ParameterList list;
1300         FunctionRNA *func;
1301
1302         func = &rna_Node_draw_buttons_func; /* RNA_struct_find_function(&ptr, "draw_buttons"); */
1303
1304         RNA_parameter_list_create(&list, ptr, func);
1305         RNA_parameter_set_lookup(&list, "context", &C);
1306         RNA_parameter_set_lookup(&list, "layout", &layout);
1307         node->typeinfo->ext.call(C, ptr, func, &list);
1308
1309         RNA_parameter_list_free(&list);
1310 }
1311
1312 static void rna_Node_draw_buttons_ext(struct uiLayout *layout, bContext *C, PointerRNA *ptr)
1313 {
1314         extern FunctionRNA rna_Node_draw_buttons_ext_func;
1315
1316         bNode *node = (bNode *)ptr->data;
1317         ParameterList list;
1318         FunctionRNA *func;
1319
1320         func = &rna_Node_draw_buttons_ext_func; /* RNA_struct_find_function(&ptr, "draw_buttons_ext"); */
1321
1322         RNA_parameter_list_create(&list, ptr, func);
1323         RNA_parameter_set_lookup(&list, "context", &C);
1324         RNA_parameter_set_lookup(&list, "layout", &layout);
1325         node->typeinfo->ext.call(C, ptr, func, &list);
1326
1327         RNA_parameter_list_free(&list);
1328 }
1329
1330 static void rna_Node_draw_label(bNodeTree *ntree, bNode *node, char *label, int maxlen)
1331 {
1332         extern FunctionRNA rna_Node_draw_label_func;
1333
1334         PointerRNA ptr;
1335         ParameterList list;
1336         FunctionRNA *func;
1337         void *ret;
1338         char *rlabel;
1339
1340         func = &rna_Node_draw_label_func; /* RNA_struct_find_function(&ptr, "draw_label"); */
1341
1342         RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr);
1343         RNA_parameter_list_create(&list, &ptr, func);
1344         node->typeinfo->ext.call(NULL, &ptr, func, &list);
1345
1346         RNA_parameter_get_lookup(&list, "label", &ret);
1347         rlabel = *(char **)ret;
1348         BLI_strncpy(label, rlabel != NULL ? rlabel : "", maxlen);
1349
1350         RNA_parameter_list_free(&list);
1351 }
1352
1353 static bool rna_Node_is_registered_node_type(StructRNA *type)
1354 {
1355         return (RNA_struct_blender_type_get(type) != NULL);
1356 }
1357
1358 static void rna_Node_is_registered_node_type_runtime(bContext *UNUSED(C), ReportList *UNUSED(reports), PointerRNA *ptr, ParameterList *parms)
1359 {
1360         int result = (RNA_struct_blender_type_get(ptr->type) != NULL);
1361         RNA_parameter_set_lookup(parms, "result", &result);
1362 }
1363
1364 static void rna_Node_unregister(Main *UNUSED(bmain), StructRNA *type)
1365 {
1366         bNodeType *nt = RNA_struct_blender_type_get(type);
1367
1368         if (!nt)
1369                 return;
1370
1371         RNA_struct_free_extension(type, &nt->ext);
1372         RNA_struct_free(&BLENDER_RNA, type);
1373
1374         /* this also frees the allocated nt pointer, no MEM_free call needed! */
1375         nodeUnregisterType(nt);
1376
1377
1378         /* update while blender is running */
1379         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1380 }
1381
1382 /* Generic internal registration function.
1383  * Can be used to implement callbacks for registerable RNA node subtypes.
1384  */
1385 static bNodeType *rna_Node_register_base(Main *bmain, ReportList *reports, StructRNA *basetype,
1386                                          void *data, const char *identifier,
1387                                          StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1388 {
1389         bNodeType *nt, dummynt;
1390         bNode dummynode;
1391         PointerRNA dummyptr;
1392         FunctionRNA *func;
1393         PropertyRNA *parm;
1394         int have_function[10];
1395
1396         /* setup dummy node & node type to store static properties in */
1397         memset(&dummynt, 0, sizeof(bNodeType));
1398         /* this does some additional initialization of default values */
1399         node_type_base_custom(&dummynt, identifier, "", 0, 0);
1400
1401         memset(&dummynode, 0, sizeof(bNode));
1402         dummynode.typeinfo = &dummynt;
1403         RNA_pointer_create(NULL, basetype, &dummynode, &dummyptr);
1404
1405         /* validate the python class */
1406         if (validate(&dummyptr, data, have_function) != 0)
1407                 return NULL;
1408
1409         if (strlen(identifier) >= sizeof(dummynt.idname)) {
1410                 BKE_reportf(reports, RPT_ERROR, "Registering node class: '%s' is too long, maximum length is %d",
1411                             identifier, (int)sizeof(dummynt.idname));
1412                 return NULL;
1413         }
1414
1415         /* check if we have registered this node type before, and remove it */
1416         nt = nodeTypeFind(dummynt.idname);
1417         if (nt) {
1418                 rna_Node_unregister(bmain, nt->ext.srna);
1419         }
1420
1421         /* create a new node type */
1422         nt = MEM_callocN(sizeof(bNodeType), "node type");
1423         memcpy(nt, &dummynt, sizeof(dummynt));
1424         /* make sure the node type struct is freed on unregister */
1425         nt->needs_free = 1;
1426
1427         nt->ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, nt->idname, basetype);
1428         nt->ext.data = data;
1429         nt->ext.call = call;
1430         nt->ext.free = free;
1431         RNA_struct_blender_type_set(nt->ext.srna, nt);
1432
1433         RNA_def_struct_ui_text(nt->ext.srna, nt->ui_name, nt->ui_description);
1434         RNA_def_struct_ui_icon(nt->ext.srna, nt->ui_icon);
1435
1436         func = RNA_def_function_runtime(nt->ext.srna, "is_registered_node_type", rna_Node_is_registered_node_type_runtime);
1437         RNA_def_function_ui_description(func, "True if a registered node type");
1438         RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_SELF_TYPE);
1439         parm = RNA_def_boolean(func, "result", false, "Result", "");
1440         RNA_def_function_return(func, parm);
1441
1442         /* XXX bad level call! needed to initialize the basic draw functions ... */
1443         ED_init_custom_node_type(nt);
1444
1445         nt->poll = (have_function[0]) ? rna_Node_poll : NULL;
1446         nt->poll_instance = (have_function[1]) ? rna_Node_poll_instance : rna_Node_poll_instance_default;
1447         nt->updatefunc = (have_function[2]) ? rna_Node_update_reg : NULL;
1448         nt->insert_link = (have_function[3]) ? rna_Node_insert_link : NULL;
1449         nt->initfunc_api = (have_function[4]) ? rna_Node_init : NULL;
1450         nt->copyfunc_api = (have_function[5]) ? rna_Node_copy : NULL;
1451         nt->freefunc_api = (have_function[6]) ? rna_Node_free : NULL;
1452         nt->draw_buttons = (have_function[7]) ? rna_Node_draw_buttons : NULL;
1453         nt->draw_buttons_ex = (have_function[8]) ? rna_Node_draw_buttons_ext : NULL;
1454         nt->labelfunc = (have_function[9]) ? rna_Node_draw_label : NULL;
1455
1456         /* sanitize size values in case not all have been registered */
1457         if (nt->maxwidth < nt->minwidth)
1458                 nt->maxwidth = nt->minwidth;
1459         if (nt->maxheight < nt->minheight)
1460                 nt->maxheight = nt->minheight;
1461         CLAMP(nt->width, nt->minwidth, nt->maxwidth);
1462         CLAMP(nt->height, nt->minheight, nt->maxheight);
1463
1464         return nt;
1465 }
1466
1467 static StructRNA *rna_Node_register(
1468         Main *bmain, ReportList *reports,
1469         void *data, const char *identifier,
1470         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1471 {
1472         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_Node, data, identifier, validate, call, free);
1473         if (!nt)
1474                 return NULL;
1475
1476         nodeRegisterType(nt);
1477
1478         /* update while blender is running */
1479         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1480
1481         return nt->ext.srna;
1482 }
1483
1484 static StructRNA *rna_ShaderNode_register(
1485         Main *bmain, ReportList *reports,
1486         void *data, const char *identifier,
1487         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1488 {
1489         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_ShaderNode, data, identifier, validate, call, free);
1490         if (!nt)
1491                 return NULL;
1492
1493         nodeRegisterType(nt);
1494
1495         /* update while blender is running */
1496         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1497
1498         return nt->ext.srna;
1499 }
1500
1501 static StructRNA *rna_CompositorNode_register(
1502         Main *bmain, ReportList *reports,
1503         void *data, const char *identifier,
1504         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1505 {
1506         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_CompositorNode, data, identifier, validate, call, free);
1507         if (!nt)
1508                 return NULL;
1509
1510         nodeRegisterType(nt);
1511
1512         /* update while blender is running */
1513         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1514
1515         return nt->ext.srna;
1516 }
1517
1518 static StructRNA *rna_TextureNode_register(
1519         Main *bmain, ReportList *reports,
1520         void *data, const char *identifier,
1521         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1522 {
1523         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_TextureNode, data, identifier, validate, call, free);
1524         if (!nt)
1525                 return NULL;
1526
1527         nodeRegisterType(nt);
1528
1529         /* update while blender is running */
1530         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1531
1532         return nt->ext.srna;
1533 }
1534
1535 static IDProperty *rna_Node_idprops(PointerRNA *ptr, bool create)
1536 {
1537         bNode *node = ptr->data;
1538
1539         if (create && !node->prop) {
1540                 IDPropertyTemplate val = {0};
1541                 node->prop = IDP_New(IDP_GROUP, &val, "RNA_Node ID properties");
1542         }
1543
1544         return node->prop;
1545 }
1546
1547 static void rna_Node_parent_set(PointerRNA *ptr, PointerRNA value)
1548 {
1549         bNode *node = ptr->data;
1550         bNode *parent = value.data;
1551
1552         if (parent) {
1553                 /* XXX only Frame node allowed for now,
1554                  * in the future should have a poll function or so to test possible attachment.
1555                  */
1556                 if (parent->type != NODE_FRAME)
1557                         return;
1558
1559                 /* make sure parent is not attached to the node */
1560                 if (nodeAttachNodeCheck(parent, node))
1561                         return;
1562         }
1563
1564         nodeDetachNode(node);
1565         if (parent) {
1566                 nodeAttachNode(node, parent);
1567         }
1568 }
1569
1570 static bool rna_Node_parent_poll(PointerRNA *ptr, PointerRNA value)
1571 {
1572         bNode *node = ptr->data;
1573         bNode *parent = value.data;
1574
1575         /* XXX only Frame node allowed for now,
1576          * in the future should have a poll function or so to test possible attachment.
1577          */
1578         if (parent->type != NODE_FRAME)
1579                 return false;
1580
1581         /* make sure parent is not attached to the node */
1582         if (nodeAttachNodeCheck(parent, node))
1583                 return false;
1584
1585         return true;
1586 }
1587
1588 static void rna_Node_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
1589 {
1590         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1591         bNode *node = (bNode *)ptr->data;
1592         ED_node_tag_update_nodetree(bmain, ntree, node);
1593 }
1594
1595 static void rna_Node_socket_value_update(ID *id, bNode *node, bContext *C)
1596 {
1597         ED_node_tag_update_nodetree(CTX_data_main(C), (bNodeTree *)id, node);
1598 }
1599
1600 static void rna_Node_select_set(PointerRNA *ptr, bool value)
1601 {
1602         bNode *node = (bNode *)ptr->data;
1603         nodeSetSelected(node, value);
1604 }
1605
1606 static void rna_Node_name_set(PointerRNA *ptr, const char *value)
1607 {
1608         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1609         bNode *node = (bNode *)ptr->data;
1610         char oldname[sizeof(node->name)];
1611
1612         /* make a copy of the old name first */
1613         BLI_strncpy(oldname, node->name, sizeof(node->name));
1614         /* set new name */
1615         BLI_strncpy_utf8(node->name, value, sizeof(node->name));
1616
1617         nodeUniqueName(ntree, node);
1618
1619         /* fix all the animation data which may link to this */
1620         BKE_animdata_fix_paths_rename_all(NULL, "nodes", oldname, node->name);
1621 }
1622
1623 static bNodeSocket *rna_Node_inputs_new(ID *id, bNode *node, Main *bmain, ReportList *reports, const char *type, const char *name, const char *identifier)
1624 {
1625         bNodeTree *ntree = (bNodeTree *)id;
1626         bNodeSocket *sock;
1627
1628         sock = nodeAddSocket(ntree, node, SOCK_IN, type, identifier, name);
1629
1630         if (sock == NULL) {
1631                 BKE_report(reports, RPT_ERROR, "Unable to create socket");
1632         }
1633         else {
1634                 ntreeUpdateTree(bmain, ntree);
1635                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1636         }
1637
1638         return sock;
1639 }
1640
1641 static bNodeSocket *rna_Node_outputs_new(ID *id, bNode *node, Main *bmain, ReportList *reports, const char *type, const char *name, const char *identifier)
1642 {
1643         bNodeTree *ntree = (bNodeTree *)id;
1644         bNodeSocket *sock;
1645
1646         sock = nodeAddSocket(ntree, node, SOCK_OUT, type, identifier, name);
1647
1648         if (sock == NULL) {
1649                 BKE_report(reports, RPT_ERROR, "Unable to create socket");
1650         }
1651         else {
1652                 ntreeUpdateTree(bmain, ntree);
1653                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1654         }
1655
1656         return sock;
1657 }
1658
1659 static void rna_Node_socket_remove(ID *id, bNode *node, Main *bmain, ReportList *reports, bNodeSocket *sock)
1660 {
1661         bNodeTree *ntree = (bNodeTree *)id;
1662
1663         if (BLI_findindex(&node->inputs, sock) == -1 && BLI_findindex(&node->outputs, sock) == -1) {
1664                 BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier);
1665         }
1666         else {
1667                 nodeRemoveSocket(ntree, node, sock);
1668
1669                 ntreeUpdateTree(bmain, ntree);
1670                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1671         }
1672 }
1673
1674 static void rna_Node_inputs_clear(ID *id, bNode *node, Main *bmain)
1675 {
1676         bNodeTree *ntree = (bNodeTree *)id;
1677         bNodeSocket *sock, *nextsock;
1678
1679         for (sock = node->inputs.first; sock; sock = nextsock) {
1680                 nextsock = sock->next;
1681                 nodeRemoveSocket(ntree, node, sock);
1682         }
1683
1684         ntreeUpdateTree(bmain, ntree);
1685         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1686 }
1687
1688 static void rna_Node_outputs_clear(ID *id, bNode *node, Main *bmain)
1689 {
1690         bNodeTree *ntree = (bNodeTree *)id;
1691         bNodeSocket *sock, *nextsock;
1692
1693         for (sock = node->outputs.first; sock; sock = nextsock) {
1694                 nextsock = sock->next;
1695                 nodeRemoveSocket(ntree, node, sock);
1696         }
1697
1698         ntreeUpdateTree(bmain, ntree);
1699         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1700 }
1701
1702 static void rna_Node_inputs_move(ID *id, bNode *node, Main *bmain, int from_index, int to_index)
1703 {
1704         bNodeTree *ntree = (bNodeTree *)id;
1705         bNodeSocket *sock;
1706
1707         if (from_index == to_index)
1708                 return;
1709         if (from_index < 0 || to_index < 0)
1710                 return;
1711
1712         sock = BLI_findlink(&node->inputs, from_index);
1713         if (to_index < from_index) {
1714                 bNodeSocket *nextsock = BLI_findlink(&node->inputs, to_index);
1715                 if (nextsock) {
1716                         BLI_remlink(&node->inputs, sock);
1717                         BLI_insertlinkbefore(&node->inputs, nextsock, sock);
1718                 }
1719         }
1720         else {
1721                 bNodeSocket *prevsock = BLI_findlink(&node->inputs, to_index);
1722                 if (prevsock) {
1723                         BLI_remlink(&node->inputs, sock);
1724                         BLI_insertlinkafter(&node->inputs, prevsock, sock);
1725                 }
1726         }
1727
1728         ntreeUpdateTree(bmain, ntree);
1729         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1730 }
1731
1732 static void rna_Node_outputs_move(ID *id, bNode *node, Main *bmain, int from_index, int to_index)
1733 {
1734         bNodeTree *ntree = (bNodeTree *)id;
1735         bNodeSocket *sock;
1736
1737         if (from_index == to_index)
1738                 return;
1739         if (from_index < 0 || to_index < 0)
1740                 return;
1741
1742         sock = BLI_findlink(&node->outputs, from_index);
1743         if (to_index < from_index) {
1744                 bNodeSocket *nextsock = BLI_findlink(&node->outputs, to_index);
1745                 if (nextsock) {
1746                         BLI_remlink(&node->outputs, sock);
1747                         BLI_insertlinkbefore(&node->outputs, nextsock, sock);
1748                 }
1749         }
1750         else {
1751                 bNodeSocket *prevsock = BLI_findlink(&node->outputs, to_index);
1752                 if (prevsock) {
1753                         BLI_remlink(&node->outputs, sock);
1754                         BLI_insertlinkafter(&node->outputs, prevsock, sock);
1755                 }
1756         }
1757
1758         ntreeUpdateTree(bmain, ntree);
1759         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1760 }
1761
1762 static void rna_Node_width_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
1763 {
1764         bNode *node = ptr->data;
1765         *min = *softmin = node->typeinfo->minwidth;
1766         *max = *softmax = node->typeinfo->maxwidth;
1767 }
1768
1769 static void rna_Node_height_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
1770 {
1771         bNode *node = ptr->data;
1772         *min = *softmin = node->typeinfo->minheight;
1773         *max = *softmax = node->typeinfo->maxheight;
1774 }
1775
1776 static void rna_Node_dimensions_get(PointerRNA *ptr, float *value)
1777 {
1778         bNode *node = ptr->data;
1779         value[0] = node->totr.xmax - node->totr.xmin;
1780         value[1] = node->totr.ymax - node->totr.ymin;
1781 }
1782
1783
1784 /* ******** Node Socket ******** */
1785
1786 static void rna_NodeSocket_draw(bContext *C, struct uiLayout *layout, PointerRNA *ptr, PointerRNA *node_ptr, const char *text)
1787 {
1788         extern FunctionRNA rna_NodeSocket_draw_func;
1789
1790         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1791         ParameterList list;
1792         FunctionRNA *func;
1793
1794         func = &rna_NodeSocket_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */
1795
1796         RNA_parameter_list_create(&list, ptr, func);
1797         RNA_parameter_set_lookup(&list, "context", &C);
1798         RNA_parameter_set_lookup(&list, "layout", &layout);
1799         RNA_parameter_set_lookup(&list, "node", node_ptr);
1800         RNA_parameter_set_lookup(&list, "text", &text);
1801         sock->typeinfo->ext_socket.call(C, ptr, func, &list);
1802
1803         RNA_parameter_list_free(&list);
1804 }
1805
1806 static void rna_NodeSocket_draw_color(bContext *C, PointerRNA *ptr, PointerRNA *node_ptr, float *r_color)
1807 {
1808         extern FunctionRNA rna_NodeSocket_draw_color_func;
1809
1810         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1811         ParameterList list;
1812         FunctionRNA *func;
1813         void *ret;
1814
1815         func = &rna_NodeSocket_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */
1816
1817         RNA_parameter_list_create(&list, ptr, func);
1818         RNA_parameter_set_lookup(&list, "context", &C);
1819         RNA_parameter_set_lookup(&list, "node", node_ptr);
1820         sock->typeinfo->ext_socket.call(C, ptr, func, &list);
1821
1822         RNA_parameter_get_lookup(&list, "color", &ret);
1823         copy_v4_v4(r_color, (float *)ret);
1824
1825         RNA_parameter_list_free(&list);
1826 }
1827
1828 static void rna_NodeSocket_unregister(Main *UNUSED(bmain), StructRNA *type)
1829 {
1830         bNodeSocketType *st = RNA_struct_blender_type_get(type);
1831         if (!st)
1832                 return;
1833
1834         RNA_struct_free_extension(type, &st->ext_socket);
1835         RNA_struct_free(&BLENDER_RNA, type);
1836
1837         nodeUnregisterSocketType(st);
1838
1839
1840         /* update while blender is running */
1841         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1842 }
1843
1844 static StructRNA *rna_NodeSocket_register(
1845         Main *UNUSED(bmain), ReportList *reports, void *data, const char *identifier,
1846         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1847 {
1848         bNodeSocketType *st, dummyst;
1849         bNodeSocket dummysock;
1850         PointerRNA dummyptr;
1851         int have_function[2];
1852
1853         /* setup dummy socket & socket type to store static properties in */
1854         memset(&dummyst, 0, sizeof(bNodeSocketType));
1855
1856         memset(&dummysock, 0, sizeof(bNodeSocket));
1857         dummysock.typeinfo = &dummyst;
1858         RNA_pointer_create(NULL, &RNA_NodeSocket, &dummysock, &dummyptr);
1859
1860         /* validate the python class */
1861         if (validate(&dummyptr, data, have_function) != 0)
1862                 return NULL;
1863
1864         if (strlen(identifier) >= sizeof(dummyst.idname)) {
1865                 BKE_reportf(reports, RPT_ERROR, "Registering node socket class: '%s' is too long, maximum length is %d",
1866                             identifier, (int)sizeof(dummyst.idname));
1867                 return NULL;
1868         }
1869
1870         /* check if we have registered this socket type before */
1871         st = nodeSocketTypeFind(dummyst.idname);
1872         if (!st) {
1873                 /* create a new node socket type */
1874                 st = MEM_callocN(sizeof(bNodeSocketType), "node socket type");
1875                 memcpy(st, &dummyst, sizeof(dummyst));
1876
1877                 nodeRegisterSocketType(st);
1878         }
1879
1880         /* if RNA type is already registered, unregister first */
1881         if (st->ext_socket.srna) {
1882                 StructRNA *srna = st->ext_socket.srna;
1883                 RNA_struct_free_extension(srna, &st->ext_socket);
1884                 RNA_struct_free(&BLENDER_RNA, srna);
1885         }
1886         st->ext_socket.srna = RNA_def_struct_ptr(&BLENDER_RNA, st->idname, &RNA_NodeSocket);
1887         st->ext_socket.data = data;
1888         st->ext_socket.call = call;
1889         st->ext_socket.free = free;
1890         RNA_struct_blender_type_set(st->ext_socket.srna, st);
1891
1892         /* XXX bad level call! needed to initialize the basic draw functions ... */
1893         ED_init_custom_node_socket_type(st);
1894
1895         st->draw = (have_function[0]) ? rna_NodeSocket_draw : NULL;
1896         st->draw_color = (have_function[1]) ? rna_NodeSocket_draw_color : NULL;
1897
1898         /* update while blender is running */
1899         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1900
1901         return st->ext_socket.srna;
1902 }
1903
1904 static StructRNA *rna_NodeSocket_refine(PointerRNA *ptr)
1905 {
1906         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1907
1908         if (sock->typeinfo->ext_socket.srna)
1909                 return sock->typeinfo->ext_socket.srna;
1910         else
1911                 return &RNA_NodeSocket;
1912 }
1913
1914 static char *rna_NodeSocket_path(PointerRNA *ptr)
1915 {
1916         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1917         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1918         bNode *node;
1919         int socketindex;
1920         char name_esc[sizeof(node->name) * 2];
1921
1922         if (!nodeFindNode(ntree, sock, &node, &socketindex))
1923                 return NULL;
1924
1925         BLI_strescape(name_esc, node->name, sizeof(name_esc));
1926
1927         if (sock->in_out == SOCK_IN) {
1928                 return BLI_sprintfN("nodes[\"%s\"].inputs[%d]", name_esc, socketindex);
1929         }
1930         else {
1931                 return BLI_sprintfN("nodes[\"%s\"].outputs[%d]", name_esc, socketindex);
1932         }
1933 }
1934
1935 static IDProperty *rna_NodeSocket_idprops(PointerRNA *ptr, bool create)
1936 {
1937         bNodeSocket *sock = ptr->data;
1938
1939         if (create && !sock->prop) {
1940                 IDPropertyTemplate val = {0};
1941                 sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocket ID properties");
1942         }
1943
1944         return sock->prop;
1945 }
1946
1947 static PointerRNA rna_NodeSocket_node_get(PointerRNA *ptr)
1948 {
1949         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1950         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1951         bNode *node;
1952         PointerRNA r_ptr;
1953
1954         nodeFindNode(ntree, sock, &node, NULL);
1955
1956         RNA_pointer_create((ID *)ntree, &RNA_Node, node, &r_ptr);
1957         return r_ptr;
1958 }
1959
1960 static void rna_NodeSocket_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
1961 {
1962         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1963         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1964         bNode *node;
1965         if (nodeFindNode(ntree, sock, &node, NULL)) {
1966                 ED_node_tag_update_nodetree(bmain, ntree, node);
1967         }
1968 }
1969
1970 static bool rna_NodeSocket_is_output_get(PointerRNA *ptr)
1971 {
1972         bNodeSocket *sock = ptr->data;
1973         return sock->in_out == SOCK_OUT;
1974 }
1975
1976 static void rna_NodeSocket_link_limit_set(PointerRNA *ptr, int value)
1977 {
1978         bNodeSocket *sock = ptr->data;
1979         sock->limit = (value == 0 ? 0xFFF : value);
1980 }
1981
1982 static void rna_NodeSocket_hide_set(PointerRNA *ptr, bool value)
1983 {
1984         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1985
1986         /* don't hide linked sockets */
1987         if (sock->flag & SOCK_IN_USE)
1988                 return;
1989
1990         if (value)
1991                 sock->flag |= SOCK_HIDDEN;
1992         else
1993                 sock->flag &= ~SOCK_HIDDEN;
1994 }
1995
1996
1997 static void rna_NodeSocketInterface_draw(bContext *C, struct uiLayout *layout, PointerRNA *ptr)
1998 {
1999         extern FunctionRNA rna_NodeSocketInterface_draw_func;
2000
2001         bNodeSocket *stemp = (bNodeSocket *)ptr->data;
2002         ParameterList list;
2003         FunctionRNA *func;
2004
2005         if (!stemp->typeinfo)
2006                 return;
2007
2008         func = &rna_NodeSocketInterface_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */
2009
2010         RNA_parameter_list_create(&list, ptr, func);
2011         RNA_parameter_set_lookup(&list, "context", &C);
2012         RNA_parameter_set_lookup(&list, "layout", &layout);
2013         stemp->typeinfo->ext_interface.call(C, ptr, func, &list);
2014
2015         RNA_parameter_list_free(&list);
2016 }
2017
2018 static void rna_NodeSocketInterface_draw_color(bContext *C, PointerRNA *ptr, float *r_color)
2019 {
2020         extern FunctionRNA rna_NodeSocketInterface_draw_color_func;
2021
2022         bNodeSocket *sock = (bNodeSocket *)ptr->data;
2023         ParameterList list;
2024         FunctionRNA *func;
2025         void *ret;
2026
2027         if (!sock->typeinfo)
2028                 return;
2029
2030         func = &rna_NodeSocketInterface_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */
2031
2032         RNA_parameter_list_create(&list, ptr, func);
2033         RNA_parameter_set_lookup(&list, "context", &C);
2034         sock->typeinfo->ext_interface.call(C, ptr, func, &list);
2035
2036         RNA_parameter_get_lookup(&list, "color", &ret);
2037         copy_v4_v4(r_color, (float *)ret);
2038
2039         RNA_parameter_list_free(&list);
2040 }
2041
2042 static void rna_NodeSocketInterface_register_properties(bNodeTree *ntree, bNodeSocket *stemp, StructRNA *data_srna)
2043 {
2044         extern FunctionRNA rna_NodeSocketInterface_register_properties_func;
2045
2046         PointerRNA ptr;
2047         ParameterList list;
2048         FunctionRNA *func;
2049
2050         if (!stemp->typeinfo)
2051                 return;
2052
2053         RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
2054         func = &rna_NodeSocketInterface_register_properties_func; /* RNA_struct_find_function(&ptr, "register_properties"); */
2055
2056         RNA_parameter_list_create(&list, &ptr, func);
2057         RNA_parameter_set_lookup(&list, "data_rna_type", &data_srna);
2058         stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
2059
2060         RNA_parameter_list_free(&list);
2061 }
2062
2063 static void rna_NodeSocketInterface_init_socket(bNodeTree *ntree, bNodeSocket *stemp, bNode *node, bNodeSocket *sock, const char *data_path)
2064 {
2065         extern FunctionRNA rna_NodeSocketInterface_init_socket_func;
2066
2067         PointerRNA ptr, node_ptr, sock_ptr;
2068         ParameterList list;
2069         FunctionRNA *func;
2070
2071         if (!stemp->typeinfo)
2072                 return;
2073
2074         RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
2075         RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr);
2076         RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr);
2077         func = &rna_NodeSocketInterface_init_socket_func; /* RNA_struct_find_function(&ptr, "init_socket"); */
2078
2079         RNA_parameter_list_create(&list, &ptr, func);
2080         RNA_parameter_set_lookup(&list, "node", &node_ptr);
2081         RNA_parameter_set_lookup(&list, "socket", &sock_ptr);
2082         RNA_parameter_set_lookup(&list, "data_path", &data_path);
2083         stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
2084
2085         RNA_parameter_list_free(&list);
2086 }
2087
2088 static void rna_NodeSocketInterface_from_socket(bNodeTree *ntree, bNodeSocket *stemp, bNode *node, bNodeSocket *sock)
2089 {
2090         extern FunctionRNA rna_NodeSocketInterface_from_socket_func;
2091
2092         PointerRNA ptr, node_ptr, sock_ptr;
2093         ParameterList list;
2094         FunctionRNA *func;
2095
2096         if (!stemp->typeinfo)
2097                 return;
2098
2099         RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
2100         RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr);
2101         RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr);
2102         func = &rna_NodeSocketInterface_from_socket_func; /* RNA_struct_find_function(&ptr, "from_socket"); */
2103
2104         RNA_parameter_list_create(&list, &ptr, func);
2105         RNA_parameter_set_lookup(&list, "node", &node_ptr);
2106         RNA_parameter_set_lookup(&list, "socket", &sock_ptr);
2107         stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
2108
2109         RNA_parameter_list_free(&list);
2110 }
2111
2112 static void rna_NodeSocketInterface_unregister(Main *UNUSED(bmain), StructRNA *type)
2113 {
2114         bNodeSocketType *st = RNA_struct_blender_type_get(type);
2115         if (!st)
2116                 return;
2117
2118         RNA_struct_free_extension(type, &st->ext_interface);
2119
2120         RNA_struct_free(&BLENDER_RNA, type);
2121
2122         /* update while blender is running */
2123         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2124 }
2125
2126 static StructRNA *rna_NodeSocketInterface_register(
2127         Main *UNUSED(bmain), ReportList *UNUSED(reports), void *data, const char *identifier,
2128         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
2129 {
2130         bNodeSocketType *st, dummyst;
2131         bNodeSocket dummysock;
2132         PointerRNA dummyptr;
2133         int have_function[5];
2134
2135         /* setup dummy socket & socket type to store static properties in */
2136         memset(&dummyst, 0, sizeof(bNodeSocketType));
2137
2138         memset(&dummysock, 0, sizeof(bNodeSocket));
2139         dummysock.typeinfo = &dummyst;
2140         RNA_pointer_create(NULL, &RNA_NodeSocketInterface, &dummysock, &dummyptr);
2141
2142         /* validate the python class */
2143         if (validate(&dummyptr, data, have_function) != 0)
2144                 return NULL;
2145
2146         /* check if we have registered this socket type before */
2147         st = nodeSocketTypeFind(dummyst.idname);
2148         if (st) {
2149                 /* basic socket type registered by a socket class before. */
2150         }
2151         else {
2152                 /* create a new node socket type */
2153                 st = MEM_callocN(sizeof(bNodeSocketType), "node socket type");
2154                 memcpy(st, &dummyst, sizeof(dummyst));
2155
2156                 nodeRegisterSocketType(st);
2157         }
2158
2159         /* if RNA type is already registered, unregister first */
2160         if (st->ext_interface.srna) {
2161                 StructRNA *srna = st->ext_interface.srna;
2162                 RNA_struct_free_extension(srna, &st->ext_interface);
2163                 RNA_struct_free(&BLENDER_RNA, srna);
2164         }
2165         st->ext_interface.srna = RNA_def_struct_ptr(&BLENDER_RNA, identifier, &RNA_NodeSocketInterface);
2166         st->ext_interface.data = data;
2167         st->ext_interface.call = call;
2168         st->ext_interface.free = free;
2169         RNA_struct_blender_type_set(st->ext_interface.srna, st);
2170
2171         st->interface_draw = (have_function[0]) ? rna_NodeSocketInterface_draw : NULL;
2172         st->interface_draw_color = (have_function[1]) ? rna_NodeSocketInterface_draw_color : NULL;
2173         st->interface_register_properties = (have_function[2]) ? rna_NodeSocketInterface_register_properties : NULL;
2174         st->interface_init_socket = (have_function[3]) ? rna_NodeSocketInterface_init_socket : NULL;
2175         st->interface_from_socket = (have_function[4]) ? rna_NodeSocketInterface_from_socket : NULL;
2176
2177         /* update while blender is running */
2178         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2179
2180         return st->ext_interface.srna;
2181 }
2182
2183 static StructRNA *rna_NodeSocketInterface_refine(PointerRNA *ptr)
2184 {
2185         bNodeSocket *sock = (bNodeSocket *)ptr->data;
2186
2187         if (sock->typeinfo && sock->typeinfo->ext_interface.srna)
2188                 return sock->typeinfo->ext_interface.srna;
2189         else
2190                 return &RNA_NodeSocketInterface;
2191 }
2192
2193 static char *rna_NodeSocketInterface_path(PointerRNA *ptr)
2194 {
2195         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2196         bNodeSocket *sock = (bNodeSocket *)ptr->data;
2197         int socketindex;
2198
2199         socketindex = BLI_findindex(&ntree->inputs, sock);
2200         if (socketindex != -1)
2201                 return BLI_sprintfN("inputs[%d]", socketindex);
2202
2203         socketindex = BLI_findindex(&ntree->outputs, sock);
2204         if (socketindex != -1)
2205                 return BLI_sprintfN("outputs[%d]", socketindex);
2206
2207         return NULL;
2208 }
2209
2210 static IDProperty *rna_NodeSocketInterface_idprops(PointerRNA *ptr, bool create)
2211 {
2212         bNodeSocket *sock = ptr->data;
2213
2214         if (create && !sock->prop) {
2215                 IDPropertyTemplate val = {0};
2216                 sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocketInterface ID properties");
2217         }
2218
2219         return sock->prop;
2220 }
2221
2222 static void rna_NodeSocketInterface_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2223 {
2224         bNodeTree *ntree = ptr->id.data;
2225         bNodeSocket *stemp = ptr->data;
2226
2227         if (!stemp->typeinfo)
2228                 return;
2229
2230         ntree->update |= NTREE_UPDATE_GROUP;
2231         ntreeUpdateTree(bmain, ntree);
2232
2233         ED_node_tag_update_nodetree(bmain, ntree, NULL);
2234 }
2235
2236
2237 /* ******** Standard Node Socket Base Types ******** */
2238
2239 static void rna_NodeSocketStandard_draw(ID *id, bNodeSocket *sock, struct bContext *C, struct uiLayout *layout, PointerRNA *nodeptr,
2240                                         const char *text)
2241 {
2242         PointerRNA ptr;
2243         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2244         sock->typeinfo->draw(C, layout, &ptr, nodeptr, text);
2245 }
2246
2247 static void rna_NodeSocketStandard_draw_color(ID *id, bNodeSocket *sock, struct bContext *C, PointerRNA *nodeptr, float *r_color)
2248 {
2249         PointerRNA ptr;
2250         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2251         sock->typeinfo->draw_color(C, &ptr, nodeptr, r_color);
2252 }
2253
2254 static void rna_NodeSocketInterfaceStandard_draw(ID *id, bNodeSocket *sock, struct bContext *C, struct uiLayout *layout)
2255 {
2256         PointerRNA ptr;
2257         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2258         sock->typeinfo->interface_draw(C, layout, &ptr);
2259 }
2260
2261 static void rna_NodeSocketInterfaceStandard_draw_color(ID *id, bNodeSocket *sock, struct bContext *C, float *r_color)
2262 {
2263         PointerRNA ptr;
2264         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2265         sock->typeinfo->interface_draw_color(C, &ptr, r_color);
2266 }
2267
2268 static void rna_NodeSocketStandard_float_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
2269 {
2270         bNodeSocket *sock = ptr->data;
2271         bNodeSocketValueFloat *dval = sock->default_value;
2272         int subtype = sock->typeinfo->subtype;
2273
2274         if (dval->max < dval->min) {
2275                 dval->max = dval->min;
2276         }
2277
2278         *min = (subtype == PROP_UNSIGNED ? 0.0f : -FLT_MAX);
2279         *max = FLT_MAX;
2280         *softmin = dval->min;
2281         *softmax = dval->max;
2282 }
2283
2284 static void rna_NodeSocketStandard_int_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
2285 {
2286         bNodeSocket *sock = ptr->data;
2287         bNodeSocketValueInt *dval = sock->default_value;
2288         int subtype = sock->typeinfo->subtype;
2289
2290         if (dval->max < dval->min) {
2291                 dval->max = dval->min;
2292         }
2293
2294         *min = (subtype == PROP_UNSIGNED ? 0 : INT_MIN);
2295         *max = INT_MAX;
2296         *softmin = dval->min;
2297         *softmax = dval->max;
2298 }
2299
2300 static void rna_NodeSocketStandard_vector_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
2301 {
2302         bNodeSocket *sock = ptr->data;
2303         bNodeSocketValueVector *dval = sock->default_value;
2304
2305         if (dval->max < dval->min) {
2306                 dval->max = dval->min;
2307         }
2308
2309         *min = -FLT_MAX;
2310         *max = FLT_MAX;
2311         *softmin = dval->min;
2312         *softmax = dval->max;
2313 }
2314
2315 /* using a context update function here, to avoid searching the node if possible */
2316 static void rna_NodeSocketStandard_value_update(struct bContext *C, PointerRNA *ptr)
2317 {
2318         bNode *node;
2319
2320         /* default update */
2321         rna_NodeSocket_update(CTX_data_main(C), CTX_data_scene(C), ptr);
2322
2323         /* try to use node from context, faster */
2324         node = CTX_data_pointer_get(C, "node").data;
2325         if (!node) {
2326                 bNodeTree *ntree = ptr->id.data;
2327                 bNodeSocket *sock = ptr->data;
2328
2329                 /* fall back to searching node in the tree */
2330                 nodeFindNode(ntree, sock, &node, NULL);
2331         }
2332 }
2333
2334
2335 /* ******** Node Types ******** */
2336
2337 static void rna_NodeInternalSocketTemplate_name_get(PointerRNA *ptr, char *value)
2338 {
2339         bNodeSocketTemplate *stemp = ptr->data;
2340         strcpy(value, stemp->name);
2341 }
2342
2343 static int rna_NodeInternalSocketTemplate_name_length(PointerRNA *ptr)
2344 {
2345         bNodeSocketTemplate *stemp = ptr->data;
2346         return strlen(stemp->name);
2347 }
2348
2349 static void rna_NodeInternalSocketTemplate_identifier_get(PointerRNA *ptr, char *value)
2350 {
2351         bNodeSocketTemplate *stemp = ptr->data;
2352         strcpy(value, stemp->identifier);
2353 }
2354
2355 static int rna_NodeInternalSocketTemplate_identifier_length(PointerRNA *ptr)
2356 {
2357         bNodeSocketTemplate *stemp = ptr->data;
2358         return strlen(stemp->identifier);
2359 }
2360
2361 static int rna_NodeInternalSocketTemplate_type_get(PointerRNA *ptr)
2362 {
2363         bNodeSocketTemplate *stemp = ptr->data;
2364         return stemp->type;
2365 }
2366
2367 static PointerRNA rna_NodeInternal_input_template(StructRNA *srna, int index)
2368 {
2369         bNodeType *ntype = RNA_struct_blender_type_get(srna);
2370         if (ntype && ntype->inputs) {
2371                 bNodeSocketTemplate *stemp = ntype->inputs;
2372                 int i = 0;
2373                 while (i < index && stemp->type >= 0) {
2374                         ++i;
2375                         ++stemp;
2376                 }
2377                 if (i == index && stemp->type >= 0) {
2378                         PointerRNA ptr;
2379                         RNA_pointer_create(NULL, &RNA_NodeInternalSocketTemplate, stemp, &ptr);
2380                         return ptr;
2381                 }
2382         }
2383         return PointerRNA_NULL;
2384 }
2385
2386 static PointerRNA rna_NodeInternal_output_template(StructRNA *srna, int index)
2387 {
2388         bNodeType *ntype = RNA_struct_blender_type_get(srna);
2389         if (ntype && ntype->outputs) {
2390                 bNodeSocketTemplate *stemp = ntype->outputs;
2391                 int i = 0;
2392                 while (i < index && stemp->type >= 0) {
2393                         ++i;
2394                         ++stemp;
2395                 }
2396                 if (i == index && stemp->type >= 0) {
2397                         PointerRNA ptr;
2398                         RNA_pointer_create(NULL, &RNA_NodeInternalSocketTemplate, stemp, &ptr);
2399                         return ptr;
2400                 }
2401         }
2402         return PointerRNA_NULL;
2403 }
2404
2405 static bool rna_NodeInternal_poll(StructRNA *srna, bNodeTree *ntree)
2406 {
2407         bNodeType *ntype = RNA_struct_blender_type_get(srna);
2408         return ntype && (!ntype->poll || ntype->poll(ntype, ntree));
2409 }
2410
2411 static bool rna_NodeInternal_poll_instance(bNode *node, bNodeTree *ntree)
2412 {
2413         bNodeType *ntype = node->typeinfo;
2414         if (ntype->poll_instance) {
2415                 return ntype->poll_instance(node, ntree);
2416         }
2417         else {
2418                 /* fall back to basic poll function */
2419                 return !ntype->poll || ntype->poll(ntype, ntree);
2420         }
2421 }
2422
2423 static void rna_NodeInternal_update(ID *id, bNode *node)
2424 {
2425         bNodeTree *ntree = (bNodeTree *)id;
2426         if (node->typeinfo->updatefunc)
2427                 node->typeinfo->updatefunc(ntree, node);
2428 }
2429
2430 static void rna_NodeInternal_draw_buttons(ID *id, bNode *node, struct bContext *C, struct uiLayout *layout)
2431 {
2432         if (node->typeinfo->draw_buttons) {
2433                 PointerRNA ptr;
2434                 RNA_pointer_create(id, &RNA_Node, node, &ptr);
2435                 node->typeinfo->draw_buttons(layout, C, &ptr);
2436         }
2437 }
2438
2439 static void rna_NodeInternal_draw_buttons_ext(ID *id, bNode *node, struct bContext *C, struct uiLayout *layout)
2440 {
2441         if (node->typeinfo->draw_buttons_ex) {
2442                 PointerRNA ptr;
2443                 RNA_pointer_create(id, &RNA_Node, node, &ptr);
2444                 node->typeinfo->draw_buttons_ex(layout, C, &ptr);
2445         }
2446         else if (node->typeinfo->draw_buttons) {
2447                 PointerRNA ptr;
2448                 RNA_pointer_create(id, &RNA_Node, node, &ptr);
2449                 node->typeinfo->draw_buttons(layout, C, &ptr);
2450         }
2451 }
2452
2453 static StructRNA *rna_NodeCustomGroup_register(
2454         Main *bmain, ReportList *reports,
2455         void *data, const char *identifier,
2456         StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
2457 {
2458         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_NodeCustomGroup, data, identifier, validate, call, free);
2459         if (!nt)
2460                 return NULL;
2461
2462         /* this updates the group node instance from the tree's interface */
2463         nt->verifyfunc = node_group_verify;
2464
2465         nodeRegisterType(nt);
2466
2467         /* update while blender is running */
2468         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2469
2470         return nt->ext.srna;
2471 }
2472
2473 static void rna_CompositorNode_tag_need_exec(bNode *node)
2474 {
2475         node->need_exec = true;
2476 }
2477
2478 static void rna_Node_tex_image_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2479 {
2480         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2481         bNode *node = (bNode *)ptr->data;
2482
2483         ED_node_tag_update_nodetree(bmain, ntree, node);
2484         WM_main_add_notifier(NC_IMAGE, NULL);
2485 }
2486
2487 static void rna_NodeGroup_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2488 {
2489         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2490         bNode *node = (bNode *)ptr->data;
2491
2492         if (node->id)
2493                 ntreeUpdateTree(bmain, (bNodeTree *)node->id);
2494
2495         ED_node_tag_update_nodetree(bmain, ntree, node);
2496 }
2497
2498 static void rna_NodeGroup_node_tree_set(PointerRNA *ptr, const PointerRNA value)
2499 {
2500         bNodeTree *ntree = ptr->id.data;
2501         bNode *node = ptr->data;
2502         bNodeTree *ngroup = value.data;
2503
2504         if (nodeGroupPoll(ntree, ngroup)) {
2505                 if (node->id)
2506                         id_us_min(node->id);
2507                 if (ngroup)
2508                         id_us_plus(&ngroup->id);
2509
2510                 node->id = &ngroup->id;
2511         }
2512 }
2513
2514 static bool rna_NodeGroup_node_tree_poll(PointerRNA *ptr, const PointerRNA value)
2515 {
2516         bNodeTree *ntree = ptr->id.data;
2517         bNodeTree *ngroup = value.data;
2518
2519         /* only allow node trees of the same type as the group node's tree */
2520         if (ngroup->type != ntree->type)
2521                 return false;
2522
2523         return nodeGroupPoll(ntree, ngroup);
2524 }
2525
2526
2527 static StructRNA *rna_NodeGroup_interface_typef(PointerRNA *ptr)
2528 {
2529         bNode *node = ptr->data;
2530         bNodeTree *ngroup = (bNodeTree *)node->id;
2531
2532         if (ngroup) {
2533                 StructRNA *srna = ntreeInterfaceTypeGet(ngroup, true);
2534                 if (srna)
2535                         return srna;
2536         }
2537         return &RNA_PropertyGroup;
2538 }
2539
2540 static StructRNA *rna_NodeGroupInputOutput_interface_typef(PointerRNA *ptr)
2541 {
2542         bNodeTree *ntree = ptr->id.data;
2543
2544         if (ntree) {
2545                 StructRNA *srna = ntreeInterfaceTypeGet(ntree, true);
2546                 if (srna)
2547                         return srna;
2548         }
2549         return &RNA_PropertyGroup;
2550 }
2551
2552 static void rna_distance_matte_t1_set(PointerRNA *ptr, float value)
2553 {
2554         bNode *node = (bNode *)ptr->data;
2555         NodeChroma *chroma = node->storage;
2556
2557         chroma->t1 = value;
2558 }
2559
2560 static void rna_distance_matte_t2_set(PointerRNA *ptr, float value)
2561 {
2562         bNode *node = (bNode *)ptr->data;
2563         NodeChroma *chroma = node->storage;
2564
2565         chroma->t2 = value;
2566 }
2567
2568 static void rna_difference_matte_t1_set(PointerRNA *ptr, float value)
2569 {
2570         bNode *node = (bNode *)ptr->data;
2571         NodeChroma *chroma = node->storage;
2572
2573         chroma->t1 = value;
2574 }
2575
2576 static void rna_difference_matte_t2_set(PointerRNA *ptr, float value)
2577 {
2578         bNode *node = (bNode *)ptr->data;
2579         NodeChroma *chroma = node->storage;
2580
2581         chroma->t2 = value;
2582 }
2583
2584 /* Button Set Funcs for Matte Nodes */
2585 static void rna_Matte_t1_set(PointerRNA *ptr, float value)
2586 {
2587         bNode *node = (bNode *)ptr->data;
2588         NodeChroma *chroma = node->storage;
2589
2590         chroma->t1 = value;
2591
2592         if (value < chroma->t2)
2593                 chroma->t2 = value;
2594 }
2595
2596 static void rna_Matte_t2_set(PointerRNA *ptr, float value)
2597 {
2598         bNode *node = (bNode *)ptr->data;
2599         NodeChroma *chroma = node->storage;
2600
2601         if (value > chroma->t1)
2602                 value = chroma->t1;
2603
2604         chroma->t2 = value;
2605 }
2606
2607 static void rna_Node_scene_set(PointerRNA *ptr, PointerRNA value)
2608 {
2609         bNode *node = (bNode *)ptr->data;
2610
2611         if (node->id) {
2612                 id_us_min(node->id);
2613                 node->id = NULL;
2614         }
2615
2616         node->id = value.data;
2617
2618         id_us_plus(node->id);
2619 }
2620
2621 static void rna_Node_image_layer_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2622 {
2623         bNode *node = (bNode *)ptr->data;
2624         Image *ima = (Image *)node->id;
2625         ImageUser *iuser = node->storage;
2626
2627         BKE_image_multilayer_index(ima->rr, iuser);
2628         BKE_image_signal(bmain, ima, iuser, IMA_SIGNAL_SRC_CHANGE);
2629
2630         rna_Node_update(bmain, scene, ptr);
2631
2632         if (scene->nodetree != NULL) {
2633                 ntreeCompositUpdateRLayers(scene->nodetree);
2634         }
2635 }
2636
2637 static const EnumPropertyItem *renderresult_layers_add_enum(RenderLayer *rl)
2638 {
2639         EnumPropertyItem *item = NULL;
2640         EnumPropertyItem tmp = {0};
2641         int i = 0, totitem = 0;
2642
2643         while (rl) {
2644                 tmp.identifier = rl->name;
2645                 /* little trick: using space char instead empty string makes the item selectable in the dropdown */
2646                 if (rl->name[0] == '\0')
2647                         tmp.name = " ";
2648                 else
2649                         tmp.name = rl->name;
2650                 tmp.value = i++;
2651                 RNA_enum_item_add(&item, &totitem, &tmp);
2652                 rl = rl->next;
2653         }
2654
2655         RNA_enum_item_end(&item, &totitem);
2656
2657         return item;
2658 }
2659
2660 static const EnumPropertyItem *rna_Node_image_layer_itemf(
2661         bContext *UNUSED(C), PointerRNA *ptr,
2662         PropertyRNA *UNUSED(prop), bool *r_free)
2663 {
2664         bNode *node = (bNode *)ptr->data;
2665         Image *ima = (Image *)node->id;
2666         const EnumPropertyItem *item = NULL;
2667         RenderLayer *rl;
2668
2669         if (ima == NULL || ima->rr == NULL) {
2670                 *r_free = false;
2671                 return DummyRNA_NULL_items;
2672         }
2673
2674         rl = ima->rr->layers.first;
2675         item = renderresult_layers_add_enum(rl);
2676
2677         *r_free = true;
2678
2679         return item;
2680 }
2681
2682 static bool rna_Node_image_has_layers_get(PointerRNA *ptr)
2683 {
2684         bNode *node = (bNode *)ptr->data;
2685         Image *ima = (Image *)node->id;
2686
2687         if (!ima || !(ima->rr)) return 0;
2688
2689         return RE_layers_have_name(ima->rr);
2690 }
2691
2692 static bool rna_Node_image_has_views_get(PointerRNA *ptr)
2693 {
2694         bNode *node = (bNode *)ptr->data;
2695         Image *ima = (Image *)node->id;
2696
2697         if (!ima || !(ima->rr)) return 0;
2698
2699         return BLI_listbase_count_at_most(&ima->rr->views, 2) > 1;
2700 }
2701
2702 static const EnumPropertyItem *renderresult_views_add_enum(RenderView *rv)
2703 {
2704         EnumPropertyItem *item = NULL;
2705         EnumPropertyItem tmp = {0, "ALL", 0, "All", ""};
2706         int i = 1, totitem = 0;
2707
2708         /* option to use all views */
2709         RNA_enum_item_add(&item, &totitem, &tmp);
2710
2711         while (rv) {
2712                 tmp.identifier = rv->name;
2713                 /* little trick: using space char instead empty string makes the item selectable in the dropdown */
2714                 if (rv->name[0] == '\0')
2715                         tmp.name = " ";
2716                 else
2717                         tmp.name = rv->name;
2718                 tmp.value = i++;
2719                 RNA_enum_item_add(&item, &totitem, &tmp);
2720                 rv = rv->next;
2721         }
2722
2723         RNA_enum_item_end(&item, &totitem);
2724
2725         return item;
2726 }
2727
2728 static const EnumPropertyItem *rna_Node_image_view_itemf(
2729         bContext *UNUSED(C), PointerRNA *ptr,
2730         PropertyRNA *UNUSED(prop), bool *r_free)
2731 {
2732         bNode *node = (bNode *)ptr->data;
2733         Image *ima = (Image *)node->id;
2734         const EnumPropertyItem *item = NULL;
2735         RenderView *rv;
2736
2737         if (ima == NULL || ima->rr == NULL) {
2738                 *r_free = false;
2739                 return DummyRNA_NULL_items;
2740         }
2741
2742         rv = ima->rr->views.first;
2743         item = renderresult_views_add_enum(rv);
2744
2745         *r_free = true;
2746
2747         return item;
2748 }
2749
2750 static const EnumPropertyItem *rna_Node_view_layer_itemf(
2751         bContext *UNUSED(C), PointerRNA *ptr,
2752         PropertyRNA *UNUSED(prop), bool *r_free)
2753 {
2754         bNode *node = (bNode *)ptr->data;
2755         Scene *sce = (Scene *)node->id;
2756         const EnumPropertyItem *item = NULL;
2757         RenderLayer *rl;
2758
2759         if (sce == NULL) {
2760                 *r_free = false;
2761                 return DummyRNA_NULL_items;
2762         }
2763
2764         rl = sce->view_layers.first;
2765         item = renderresult_layers_add_enum(rl);
2766
2767         *r_free = true;
2768
2769         return item;
2770 }
2771
2772 static void rna_Node_view_layer_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2773 {
2774         rna_Node_update(bmain, scene, ptr);
2775         if (scene->nodetree != NULL) {
2776                 ntreeCompositUpdateRLayers(scene->nodetree);
2777         }
2778 }
2779
2780 static const EnumPropertyItem *rna_Node_channel_itemf(
2781         bContext *UNUSED(C), PointerRNA *ptr,
2782         PropertyRNA *UNUSED(prop), bool *r_free)
2783 {
2784         bNode *node = (bNode *)ptr->data;
2785         EnumPropertyItem *item = NULL;
2786         EnumPropertyItem tmp = {0};
2787         int totitem = 0;
2788
2789         switch (node->custom1) {
2790                 case CMP_NODE_CHANNEL_MATTE_CS_RGB:
2791                         tmp.identifier = "R"; tmp.name = "R"; tmp.value = 1;
2792                         RNA_enum_item_add(&item, &totitem, &tmp);
2793                         tmp.identifier = "G"; tmp.name = "G"; tmp.value = 2;
2794                         RNA_enum_item_add(&item, &totitem, &tmp);
2795                         tmp.identifier = "B"; tmp.name = "B"; tmp.value = 3;
2796                         RNA_enum_item_add(&item, &totitem, &tmp);
2797                         break;
2798                 case CMP_NODE_CHANNEL_MATTE_CS_HSV:
2799                         tmp.identifier = "H"; tmp.name = "H"; tmp.value = 1;
2800                         RNA_enum_item_add(&item, &totitem, &tmp);
2801                         tmp.identifier = "S"; tmp.name = "S"; tmp.value = 2;
2802                         RNA_enum_item_add(&item, &totitem, &tmp);
2803                         tmp.identifier = "V"; tmp.name = "V"; tmp.value = 3;
2804                         RNA_enum_item_add(&item, &totitem, &tmp);
2805                         break;
2806                 case CMP_NODE_CHANNEL_MATTE_CS_YUV:
2807                         tmp.identifier = "Y"; tmp.name = "Y"; tmp.value = 1;
2808                         RNA_enum_item_add(&item, &totitem, &tmp);
2809                         tmp.identifier = "G"; tmp.name = "U"; tmp.value = 2;
2810                         RNA_enum_item_add(&item, &totitem, &tmp);
2811                         tmp.identifier = "V"; tmp.name = "V"; tmp.value = 3;
2812                         RNA_enum_item_add(&item, &totitem, &tmp);
2813                         break;
2814                 case CMP_NODE_CHANNEL_MATTE_CS_YCC:
2815                         tmp.identifier = "Y"; tmp.name = "Y"; tmp.value = 1;
2816                         RNA_enum_item_add(&item, &totitem, &tmp);
2817                         tmp.identifier = "CB"; tmp.name = "Cr"; tmp.value = 2;
2818                         RNA_enum_item_add(&item, &totitem, &tmp);
2819                         tmp.identifier = "CR"; tmp.name = "Cb"; tmp.value = 3;
2820                         RNA_enum_item_add(&item, &totitem, &tmp);
2821                         break;
2822                 default:
2823                         return DummyRNA_NULL_items;
2824         }
2825
2826         RNA_enum_item_end(&item, &totitem);
2827         *r_free = true;
2828
2829         return item;
2830 }
2831
2832 static void rna_Image_Node_update_id(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
2833 {
2834         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2835         bNode *node = (bNode *)ptr->data;
2836
2837         node->update |= NODE_UPDATE_ID;
2838         nodeUpdate(ntree, node);        /* to update image node sockets */
2839 }
2840
2841 static void rna_Mapping_Node_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2842 {
2843         bNode *node = ptr->data;
2844         BKE_texture_mapping_init(node->storage);
2845         rna_Node_update(bmain, scene, ptr);
2846 }
2847
2848 static void rna_NodeOutputFile_slots_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
2849 {
2850         bNode *node = ptr->data;
2851         rna_iterator_listbase_begin(iter, &node->inputs, NULL);
2852 }
2853
2854 static PointerRNA rna_NodeOutputFile_slot_file_get(CollectionPropertyIterator *iter)
2855 {
2856         PointerRNA ptr;
2857         bNodeSocket *sock = rna_iterator_listbase_get(iter);
2858         RNA_pointer_create(iter->parent.id.data, &RNA_NodeOutputFileSlotFile, sock->storage, &ptr);
2859         return ptr;
2860 }
2861
2862 static void rna_NodeColorBalance_update_lgg(Main *bmain, Scene *scene, PointerRNA *ptr)
2863 {
2864         ntreeCompositColorBalanceSyncFromLGG(ptr->id.data, ptr->data);
2865         rna_Node_update(bmain, scene, ptr);
2866 }
2867
2868 static void rna_NodeColorBalance_update_cdl(Main *bmain, Scene *scene, PointerRNA *ptr)
2869 {
2870         ntreeCompositColorBalanceSyncFromCDL(ptr->id.data, ptr->data);
2871         rna_Node_update(bmain, scene, ptr);
2872 }
2873
2874 static void rna_NodeCryptomatte_matte_get(PointerRNA *ptr, char *value)
2875 {
2876         bNode *node = (bNode *)ptr->data;
2877         NodeCryptomatte *nc = node->storage;
2878
2879         strcpy(value, (nc->matte_id) ? nc->matte_id : "");
2880 }
2881
2882 static int rna_NodeCryptomatte_matte_length(PointerRNA *ptr)
2883 {
2884         bNode *node = (bNode *)ptr->data;
2885         NodeCryptomatte *nc = node->storage;
2886
2887         return (nc->matte_id) ? strlen(nc->matte_id) : 0;
2888 }
2889
2890 static void rna_NodeCryptomatte_matte_set(PointerRNA *ptr, const char *value)
2891 {
2892         bNode *node = (bNode *)ptr->data;
2893         NodeCryptomatte *nc = node->storage;
2894
2895         if (nc->matte_id)
2896                 MEM_freeN(nc->matte_id);
2897
2898         if (value && value[0])
2899                 nc->matte_id = BLI_strdup(value);
2900         else
2901                 nc->matte_id = NULL;
2902 }
2903
2904 static void rna_NodeCryptomatte_update_add(Main *bmain, Scene *scene, PointerRNA *ptr)
2905 {
2906         ntreeCompositCryptomatteSyncFromAdd(ptr->id.data, ptr->data);
2907         rna_Node_update(bmain, scene, ptr);
2908 }
2909
2910 static void rna_NodeCryptomatte_update_remove(Main *bmain, Scene *scene, PointerRNA *ptr)
2911 {
2912         ntreeCompositCryptomatteSyncFromRemove(ptr->id.data, ptr->data);
2913         rna_Node_update(bmain, scene, ptr);
2914 }
2915
2916 /* ******** Node Socket Types ******** */
2917
2918 static PointerRNA rna_NodeOutputFile_slot_layer_get(CollectionPropertyIterator *iter)
2919 {
2920         PointerRNA ptr;
2921         bNodeSocket *sock = rna_iterator_listbase_get(iter);
2922         RNA_pointer_create(iter->parent.id.data, &RNA_NodeOutputFileSlotLayer, sock->storage, &ptr);
2923         return ptr;
2924 }
2925
2926 static int rna_NodeOutputFileSocket_find_node(bNodeTree *ntree, NodeImageMultiFileSocket *data, bNode **nodep, bNodeSocket **sockp)
2927 {
2928         bNode *node;
2929         bNodeSocket *sock;
2930
2931         for (node = ntree->nodes.first; node; node = node->next) {
2932                 for (sock = node->inputs.first; sock; sock = sock->next) {
2933                         NodeImageMultiFileSocket *sockdata = sock->storage;
2934                         if (sockdata == data) {
2935                                 *nodep = node;
2936                                 *sockp = sock;
2937                                 return 1;
2938                         }
2939                 }
2940         }
2941
2942         *nodep = NULL;
2943         *sockp = NULL;
2944         return 0;
2945 }
2946
2947 static void rna_NodeOutputFileSlotFile_path_set(PointerRNA *ptr, const char *value)
2948 {
2949         bNodeTree *ntree = ptr->id.data;
2950         NodeImageMultiFileSocket *sockdata = ptr->data;
2951         bNode *node;
2952         bNodeSocket *sock;
2953
2954         if (rna_NodeOutputFileSocket_find_node(ntree, sockdata, &node, &sock)) {
2955                 ntreeCompositOutputFileSetPath(node, sock, value);
2956         }
2957 }
2958
2959 static void rna_NodeOutputFileSlotLayer_name_set(PointerRNA *ptr, const char *value)
2960 {
2961         bNodeTree *ntree = ptr->id.data;
2962         NodeImageMultiFileSocket *sockdata = ptr->data;
2963         bNode *node;
2964         bNodeSocket *sock;
2965
2966         if (rna_NodeOutputFileSocket_find_node(ntree, sockdata, &node, &sock)) {
2967                 ntreeCompositOutputFileSetLayer(node, sock, value);
2968         }
2969 }
2970
2971 static bNodeSocket *rna_NodeOutputFile_slots_new(ID *id, bNode *node, bContext *C, ReportList *UNUSED(reports), const char *name)
2972 {
2973         bNodeTree *ntree = (bNodeTree *)id;
2974         Scene *scene = CTX_data_scene(C);
2975         ImageFormatData *im_format = NULL;
2976         bNodeSocket *sock;
2977         if (scene)
2978                 im_format = &scene->r.im_format;
2979
2980         sock = ntreeCompositOutputFileAddSocket(ntree, node, name, im_format);
2981
2982         ntreeUpdateTree(CTX_data_main(C), ntree);
2983         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
2984
2985         return sock;
2986 }
2987
2988 static void rna_ShaderNodeTexIES_mode_set(PointerRNA *ptr, int value)
2989 {
2990         bNode *node = (bNode *)ptr->data;
2991         NodeShaderTexIES *nss = node->storage;
2992
2993         if (nss->mode != value) {
2994                 nss->mode = value;
2995                 nss->filepath[0] = '\0';
2996
2997                 /* replace text datablock by filepath */
2998                 if (node->id) {
2999                         Text *text = (Text *)node->id;
3000
3001                         if (value == NODE_IES_EXTERNAL && text->name) {
3002                                 BLI_strncpy(nss->filepath, text->name, sizeof(nss->filepath));
3003                                 BLI_path_rel(nss->filepath, BKE_main_blendfile_path_from_global());
3004                         }
3005
3006                         id_us_min(node->id);
3007                         node->id = NULL;
3008                 }
3009         }
3010 }
3011
3012 static void rna_ShaderNodeScript_mode_set(PointerRNA *ptr, int value)
3013 {
3014         bNode *node = (bNode *)ptr->data;
3015         NodeShaderScript *nss = node->storage;
3016
3017         if (nss->mode != value) {
3018                 nss->mode = value;
3019                 nss->filepath[0] = '\0';
3020                 nss->flag &= ~NODE_SCRIPT_AUTO_UPDATE;
3021
3022                 /* replace text data-block by filepath */
3023                 if (node->id) {
3024                         Text *text = (Text *)node->id;
3025
3026                         if (value == NODE_SCRIPT_EXTERNAL && text->name) {
3027                                 BLI_strncpy(nss->filepath, text->name, sizeof(nss->filepath));
3028                                 BLI_path_rel(nss->filepath, BKE_main_blendfile_path_from_global());
3029                         }
3030
3031                         id_us_min(node->id);
3032                         node->id = NULL;
3033                 }
3034
3035                 /* remove any bytecode */
3036                 if (nss->bytecode) {
3037                         MEM_freeN(nss->bytecode);
3038                         nss->bytecode = NULL;
3039                 }
3040
3041                 nss->bytecode_hash[0] = '\0';
3042         }
3043 }
3044
3045 static void rna_ShaderNodeScript_bytecode_get(PointerRNA *ptr, char *value)
3046 {
3047         bNode *node = (bNode *)ptr->data;
3048         NodeShaderScript *nss = node->storage;
3049
3050         strcpy(value, (nss->bytecode) ? nss->bytecode : "");
3051 }
3052
3053 static int rna_ShaderNodeScript_bytecode_length(PointerRNA *ptr)
3054 {
3055         bNode *node = (bNode *)ptr->data;
3056         NodeShaderScript *nss = node->storage;
3057
3058         return (nss->bytecode) ? strlen(nss->bytecode) : 0;
3059 }
3060
3061 static void rna_ShaderNodeScript_bytecode_set(PointerRNA *ptr, const char *value)
3062 {
3063         bNode *node = (bNode *)ptr->data;
3064         NodeShaderScript *nss = node->storage;
3065
3066         if (nss->bytecode)
3067                 MEM_freeN(nss->bytecode);
3068
3069         if (value && value[0])
3070                 nss->bytecode = BLI_strdup(value);
3071         else
3072                 nss->bytecode = NULL;
3073 }
3074
3075 static void rna_ShaderNodeScript_update(Main *bmain, Scene *scene, PointerRNA *ptr)
3076 {
3077         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
3078         bNode *node = (bNode *)ptr->data;
3079         RenderEngineType *engine_type = RE_engines_find(scene->r.engine);
3080
3081         if (engine_type && engine_type->update_script_node) {
3082                 /* auto update node */
3083                 RenderEngine *engine = RE_engine_create(engine_type);
3084                 engine_type->update_script_node(engine, ntree, node);
3085                 RE_engine_free(engine);
3086         }
3087
3088         ED_node_tag_update_nodetree(bmain, ntree, node);
3089 }
3090
3091 static void rna_ShaderNode_socket_update(Main *bmain, Scene *scene, PointerRNA *ptr)
3092 {
3093         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
3094         bNode *node = (bNode *)ptr->data;
3095
3096         nodeUpdate(ntree, node);
3097         rna_Node_update(bmain, scene, ptr);
3098 }
3099
3100 static void rna_CompositorNodeScale_update(Main *bmain, Scene *scene, PointerRNA *ptr)
3101 {
3102         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
3103         bNode *node = (bNode *)ptr->data;
3104
3105         nodeUpdate(ntree, node);
3106         rna_Node_update(bmain, scene, ptr);
3107 }
3108
3109 static PointerRNA rna_ShaderNodePointDensity_psys_get(PointerRNA *ptr)
3110 {
3111         bNode *node = ptr->data;
3112         NodeShaderTexPointDensity *shader_point_density = node->storage;
3113         Object *ob = (Object *)node->id;
3114         ParticleSystem *psys = NULL;
3115         PointerRNA value;
3116
3117         if (ob && shader_point_density->particle_system) {
3118                 psys = BLI_findlink(&ob->particlesystem, shader_point_density->particle_system - 1);
3119         }
3120
3121         RNA_pointer_create(&ob->id, &RNA_ParticleSystem, psys, &value);
3122         return value;
3123 }
3124
3125 static void rna_ShaderNodePointDensity_psys_set(PointerRNA *ptr, PointerRNA value)
3126 {
3127         bNode *node = ptr->data;
3128         NodeShaderTexPointDensity *shader_point_density = node->storage;
3129         Object *ob = (Object *)node->id;
3130
3131         if (ob && value.id.data == ob) {
3132                 shader_point_density->particle_system = BLI_findindex(&ob->particlesystem, value.data) + 1;
3133         }
3134         else {
3135                 shader_point_density->particle_system = 0;
3136         }
3137 }
3138
3139 static int point_density_particle_color_source_from_shader(NodeShaderTexPointDensity *shader_point_density)
3140 {
3141         switch (shader_point_density->color_source) {
3142                 case SHD_POINTDENSITY_COLOR_PARTAGE:
3143                         return TEX_PD_COLOR_PARTAGE;
3144                 case SHD_POINTDENSITY_COLOR_PARTSPEED:
3145                         return TEX_PD_COLOR_PARTSPEED;
3146                 case SHD_POINTDENSITY_COLOR_PARTVEL:
3147                         return TEX_PD_COLOR_PARTVEL;
3148                 default:
3149                         BLI_assert(!"Unknown color source");
3150                         return TEX_PD_COLOR_CONSTANT;
3151         }
3152 }
3153
3154 static int point_density_vertex_color_source_from_shader(NodeShaderTexPointDensity *shader_point_density)
3155 {
3156         switch (shader_point_density->ob_color_source) {
3157                 case SHD_POINTDENSITY_COLOR_VERTCOL:
3158                         return TEX_PD_COLOR_VERTCOL;
3159                 case SHD_POINTDENSITY_COLOR_VERTWEIGHT:
3160                         return TEX_PD_COLOR_VERTWEIGHT;
3161                 case SHD_POINTDENSITY_COLOR_VERTNOR:
3162                         return TEX_PD_COLOR_VERTNOR;
3163                 default:
3164                         BLI_assert(!"Unknown color source");
3165                         return TEX_PD_COLOR_CONSTANT;
3166         }
3167 }
3168
3169 void rna_ShaderNodePointDensity_density_cache(bNode *self,
3170                                               Depsgraph *depsgraph)
3171 {
3172         NodeShaderTexPointDensity *shader_point_density = self->storage;
3173         PointDensity *pd = &shader_point_density->pd;
3174
3175         if (depsgraph == NULL) {
3176                 return;
3177         }
3178
3179         /* Make sure there's no cached data. */
3180         BKE_texture_pointdensity_free_data(pd);
3181         RE_point_density_free(pd);
3182
3183         /* Create PointDensity structure from node for sampling. */
3184         BKE_texture_pointdensity_init_data(pd);
3185         pd->object = (Object *)self->id;
3186         pd->radius = shader_point_density->radius;
3187         if (shader_point_density->point_source == SHD_POINTDENSITY_SOURCE_PSYS) {
3188                 pd->source = TEX_PD_PSYS;
3189                 pd->psys = shader_point_density->particle_system;
3190                 pd->psys_cache_space = TEX_PD_OBJECTSPACE;
3191                 pd->color_source = point_density_particle_color_source_from_shader(shader_point_density);
3192         }
3193         else {
3194                 BLI_assert(shader_point_density->point_source == SHD_POINTDENSITY_SOURCE_OBJECT);
3195                 pd->source = TEX_PD_OBJECT;
3196                 pd->ob_cache_space = TEX_PD_OBJECTSPACE;
3197                 pd->ob_color_source = point_density_vertex_color_source_from_shader(shader_point_density);
3198                 BLI_strncpy(pd->vertex_attribute_name,
3199                             shader_point_density->vertex_attribute_name,
3200                             sizeof(pd->vertex_attribute_name));
3201         }
3202
3203         /* Store resolution, so it can be changed in the UI. */
3204         shader_point_density->cached_resolution = shader_point_density->resolution;
3205
3206         /* Single-threaded sampling of the voxel domain. */
3207         RE_point_density_cache(depsgraph, pd);
3208 }
3209
3210 void rna_ShaderNodePointDensity_density_calc(bNode *self,
3211                                              Depsgraph *depsgraph,
3212                                              int *length,
3213                                              float **values)
3214 {
3215         NodeShaderTexPointDensity *shader_point_density = self->storage;
3216         PointDensity *pd = &shader_point_density->pd;
3217         const int resolution = shader_point_density->cached_resolution;
3218
3219         if (depsgraph == NULL) {
3220                 *length = 0;
3221                 return;
3222         }
3223
3224         /* TODO(sergey): Will likely overflow, but how to pass size_t via RNA? */
3225         *length = 4 * resolution * resolution * resolution;
3226
3227         if (*values == NULL) {
3228                 *values = MEM_mallocN(sizeof(float) * (*length), "point density dynamic array");
3229         }
3230
3231         /* Single-threaded sampling of the voxel domain. */
3232         RE_point_density_sample(depsgraph, pd, resolution, *values);
3233
3234         /* We're done, time to clean up. */
3235         BKE_texture_pointdensity_free_data(pd);
3236         memset(pd, 0, sizeof(*pd));
3237         shader_point_density->cached_resolution = 0.0f;
3238 }
3239
3240 void rna_ShaderNodePointDensity_density_minmax(bNode *self,
3241                                                Depsgraph *depsgraph,
3242                                                float r_min[3],
3243                                                float r_max[3])
3244 {
3245         NodeShaderTexPointDensity *shader_point_density = self->storage;
3246         PointDensity *pd = &shader_point_density->pd;
3247
3248         if (depsgraph == NULL) {
3249                 zero_v3(r_min);
3250                 zero_v3(r_max);
3251                 return;
3252         }
3253
3254         RE_point_density_minmax(depsgraph, pd, r_min, r_max);
3255 }
3256
3257 #else
3258
3259 static const EnumPropertyItem prop_image_layer_items[] = {
3260         { 0, "PLACEHOLDER",          0, "Placeholder",          ""},
3261         {0, NULL, 0, NULL, NULL}
3262 };
3263
3264 static const EnumPropertyItem prop_image_view_items[] = {
3265         { 0, "ALL", 0, "All", ""},
3266         {0, NULL, 0, NULL, NULL}
3267 };
3268
3269 static const EnumPropertyItem prop_view_layer_items[] = {
3270         { 0, "PLACEHOLDER",          0, "Placeholder",          ""},
3271         {0, NULL, 0, NULL, NULL}
3272 };
3273
3274 static const EnumPropertyItem prop_tri_channel_items[] = {
3275         { 1, "R", 0, "R", ""},
3276         { 2, "G", 0, "G", ""},
3277         { 3, "B", 0, "B", ""},
3278         {0, NULL, 0, NULL, NULL}
3279 };
3280
3281 static const EnumPropertyItem node_flip_items[] = {
3282         {0, "X",  0, "Flip X",     ""},
3283         {1, "Y",  0, "Flip Y",     ""},
3284         {2, "XY", 0, "Flip X & Y", ""},
3285         {0, NULL, 0, NULL, NULL}
3286 };
3287
3288 static const EnumPropertyItem node_ycc_items[] = {
3289         { 0, "ITUBT601", 0, "ITU 601",  ""},
3290         { 1, "ITUBT709", 0, "ITU 709",  ""},
3291         { 2, "JFIF",     0, "Jpeg",     ""},
3292         {0, NULL, 0, NULL, NULL}
3293 };
3294
3295 static const EnumPropertyItem node_glossy_items[] = {
3296         {SHD_GLOSSY_SHARP,             "SHARP",             0, "Sharp",    ""},
3297         {SHD_GLOSSY_BECKMANN,          "BECKMANN",          0, "Beckmann", ""},
3298         {SHD_GLOSSY_GGX,               "GGX",               0, "GGX",      ""},
3299         {SHD_GLOSSY_ASHIKHMIN_SHIRLEY, "ASHIKHMIN_SHIRLEY", 0, "Ashikhmin-Shirley", ""},
3300         {SHD_GLOSSY_MULTI_GGX,         "MULTI_GGX",         0, "Multiscatter GGX", ""},
3301         {0, NULL, 0, NULL, NULL}
3302 };
3303
3304 static const EnumPropertyItem node_anisotropic_items[] = {
3305         {SHD_GLOSSY_BECKMANN,          "BECKMANN",          0, "Beckmann", ""},
3306         {SHD_GLOSSY_GGX,               "GGX",               0, "GGX",      ""},
3307         {SHD_GLOSSY_MULTI_GGX,         "MULTI_GGX",         0, "Multiscatter GGX", ""},
3308         {SHD_GLOSSY_ASHIKHMIN_SHIRLEY, "ASHIKHMIN_SHIRLEY", 0, "Ashikhmin-Shirley", ""},
3309         {0, NULL, 0, NULL, NULL}
3310 };
3311
3312 static const EnumPropertyItem node_glass_items[] = {
3313         {SHD_GLOSSY_SHARP,             "SHARP",             0, "Sharp",    ""},
3314         {SHD_GLOSSY_BECKMANN,          "BECKMANN",          0, "Beckmann", ""},
3315         {SHD_GLOSSY_GGX,               "GGX",               0, "GGX",      ""},
3316         {SHD_GLOSSY_MULTI_GGX,         "MULTI_GGX",         0, "Multiscatter GGX", ""},
3317         {0, NULL, 0, NULL, NULL}
3318 };
3319
3320 static const EnumPropertyItem node_refraction_items[] = {
3321         {SHD_GLOSSY_SHARP,             "SHARP",             0, "Sharp",    ""},
3322         {SHD_GLOSSY_BECKMANN,          "BECKMANN",          0, "Beckmann", ""},
3323         {SHD_GLOSSY_GGX,               "GGX",               0, "GGX",      ""},
3324         {0, NULL, 0, NULL, NULL}
3325 };
3326
3327 static const EnumPropertyItem node_toon_items[] = {
3328         {SHD_TOON_DIFFUSE,    "DIFFUSE",  0, "Diffuse", ""},
3329         {SHD_TOON_GLOSSY,     "GLOSSY",   0, "Glossy",  ""},
3330         {0, NULL, 0, NULL, NULL}
3331 };
3332
3333 static const EnumPropertyItem node_hair_items[] = {
3334         {SHD_HAIR_REFLECTION,     "Reflection",    0,   "Reflection", ""},
3335         {SHD_HAIR_TRANSMISSION,   "Transmission",    0,  "Transmission", ""},
3336         {0, NULL, 0, NULL, NULL}
3337 };
3338
3339 static const EnumPropertyItem node_principled_hair_items[] = {
3340         {SHD_PRINCIPLED_HAIR_DIRECT_ABSORPTION,     "ABSORPTION", 0, "Absorption coefficient",
3341          "Directly set the absorption coefficient sigma_a (this is not the most intuitive way to color hair)"},
3342         {SHD_PRINCIPLED_HAIR_PIGMENT_CONCENTRATION, "MELANIN",    0, "Melanin concentration",
3343          "Define the melanin concentrations below to get the most realistic-looking hair"
3344          "(you can get the concentrations for different types of hair online)"},
3345         {SHD_PRINCIPLED_HAIR_REFLECTANCE,           "COLOR",      0, "Direct coloring",
3346          "Choose the color of your preference, and the shader will approximate the absorption coefficient to render lookalike hair"},
3347         {0, NULL, 0, NULL, NULL}
3348 };
3349
3350 static const EnumPropertyItem node_script_mode_items[] = {
3351         {NODE_SCRIPT_INTERNAL, "INTERNAL", 0, "Internal", "Use internal text data-block"},
3352         {NODE_SCRIPT_EXTERNAL, "EXTERNAL", 0, "External", "Use external .osl or .oso file"},
3353         {0, NULL, 0, NULL, NULL}
3354 };
3355
3356 static EnumPropertyItem node_ies_mode_items[] = {
3357         {NODE_IES_INTERNAL, "INTERNAL", 0, "Internal", "Use internal text datablock"},
3358         {NODE_IES_EXTERNAL, "EXTERNAL", 0, "External", "Use external .ies file"},
3359         {0, NULL, 0, NULL, NULL}
3360 };
3361
3362 static const EnumPropertyItem node_principled_distribution_items[] = {
3363         {SHD_GLOSSY_GGX, "GGX", 0, "GGX", ""},
3364         {SHD_GLOSSY_MULTI_GGX, "MULTI_GGX", 0, "Multiscatter GGX", ""},
3365         {0, NULL, 0, NULL, NULL}
3366 };
3367
3368 static const EnumPropertyItem node_subsurface_method_items[] = {
3369         {SHD_SUBSURFACE_BURLEY, "BURLEY", 0, "Christensen-Burley", "Approximation to physically based volume scattering"},
3370         {SHD_SUBSURFACE_RANDOM_WALK, "RANDOM_WALK", 0, "Random Walk", "Volumetric approximation to physically based volume scattering"},
3371         { 0, NULL, 0, NULL, NULL }
3372 };
3373
3374
3375 /* -- Common nodes ---------------------------------------------------------- */
3376
3377 static void def_group_input(StructRNA *srna)
3378 {
3379         PropertyRNA *prop;
3380
3381         prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
3382         RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroupInputOutput_interface_typef", NULL);
3383         RNA_def_property_struct_type(prop, "PropertyGroup");
3384         RNA_def_property_flag(prop, PROP_IDPROPERTY);
3385         RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
3386 }
3387
3388 static void def_group_output(StructRNA *srna)
3389 {
3390         PropertyRNA *prop;
3391
3392         prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
3393         RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroupInputOutput_interface_typef", NULL);
3394         RNA_def_property_struct_type(prop, "PropertyGroup");
3395         RNA_def_property_flag(prop, PROP_IDPROPERTY);
3396         RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
3397
3398         prop = RNA_def_property(srna, "is_active_output", PROP_BOOLEAN, PROP_NONE);
3399         RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_DO_OUTPUT);
3400         RNA_def_property_ui_text(prop, "Active Output", "True if this node is used as the active group output");
3401         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3402 }
3403
3404 static void def_group(StructRNA *srna)
3405 {
3406         PropertyRNA *prop;
3407
3408         prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
3409         RNA_def_property_pointer_sdna(prop, NULL, "id");
3410         RNA_def_property_struct_type(prop, "NodeTree");
3411         RNA_def_property_pointer_funcs(prop, NULL, "rna_NodeGroup_node_tree_set", NULL, "rna_NodeGroup_node_tree_poll");
3412         RNA_def_property_flag(prop, PROP_EDITABLE);
3413         RNA_def_property_ui_text(prop, "Node Tree", "");
3414         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeGroup_update");
3415
3416         prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
3417         RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroup_interface_typef", NULL);
3418         RNA_def_property_struct_type(prop, "PropertyGroup");
3419         RNA_def_property_flag(prop, PROP_IDPROPERTY);
3420         RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
3421 }
3422
3423 static void def_custom_group(BlenderRNA *brna)
3424 {
3425         StructRNA *srna;
3426
3427         srna = RNA_def_struct(brna, "NodeCustomGroup", "Node");
3428         RNA_def_struct_ui_text(srna, "Custom Group", "Base node type for custom registered node group types");
3429         RNA_def_struct_sdna(srna, "bNode");
3430
3431         RNA_def_struct_register_funcs(srna, "rna_NodeCustomGroup_register", "rna_Node_unregister", NULL);
3432
3433         def_group(srna);
3434 }
3435
3436 static void def_frame(StructRNA *srna)
3437 {
3438         PropertyRNA *prop;
3439
3440         prop = RNA_def_property(srna, "text", PROP_POINTER, PROP_NONE);
3441         RNA_def_property_pointer_sdna(prop, NULL, "id");
3442         RNA_def_property_struct_type(prop, "Text");
3443         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
3444         RNA_def_property_ui_text(prop, "Text", "");
3445         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3446
3447         RNA_def_struct_sdna_from(srna, "NodeFrame", "storage");
3448         RNA_def_struct_translation_context(srna, BLT_I18NCONTEXT_ID_NODETREE);
3449
3450         prop = RNA_def_property(srna, "shrink", PROP_BOOLEAN, PROP_NONE);
3451         RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_FRAME_SHRINK);
3452         RNA_def_property_ui_text(prop, "Shrink", "Shrink the frame to minimal bounding box");
3453         RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, NULL);
3454
3455         prop = RNA_def_property(srna, "label_size", PROP_INT, PROP_NONE);
3456         RNA_def_property_int_sdna(prop, NULL, "label_size");
3457         RNA_def_property_range(prop, 8, 64);
3458         RNA_def_property_ui_text(prop, "Label Font Size", "Font size to use for displaying the label");
3459         RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, NULL);
3460 }
3461
3462 static void def_math(StructRNA *srna)