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