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