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