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