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