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