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