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