Math Node:
[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         /* node buttons are only drawn if the options flag is set */
1340         if (nt->uifunc || nt->uifuncbut)
1341                 nt->flag |= NODE_OPTIONS;
1342         
1343         /* sanitize size values in case not all have been registered */
1344         if (nt->maxwidth < nt->minwidth)
1345                 nt->maxwidth = nt->minwidth;
1346         if (nt->maxheight < nt->minheight)
1347                 nt->maxheight = nt->minheight;
1348         CLAMP(nt->width, nt->minwidth, nt->maxwidth);
1349         CLAMP(nt->height, nt->minheight, nt->maxheight);
1350         
1351         return nt;
1352 }
1353
1354 static StructRNA *rna_Node_register(Main *bmain, ReportList *reports,
1355                                     void *data, const char *identifier,
1356                                     StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1357 {
1358         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_Node, data, identifier, validate, call, free);
1359         if (!nt)
1360                 return NULL;
1361         
1362         nodeRegisterType(nt);
1363         
1364         /* update while blender is running */
1365         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1366         
1367         return nt->ext.srna;
1368 }
1369
1370 static StructRNA *rna_NodeGroup_register(Main *bmain, ReportList *reports,
1371                                          void *data, const char *identifier,
1372                                          StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1373 {
1374         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_NodeGroup, data, identifier, validate, call, free);
1375         if (!nt)
1376                 return NULL;
1377         
1378         nodeRegisterType(nt);
1379         
1380         /* update while blender is running */
1381         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1382         
1383         return nt->ext.srna;
1384 }
1385
1386 static StructRNA *rna_ShaderNode_register(Main *bmain, ReportList *reports,
1387                                           void *data, const char *identifier,
1388                                           StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1389 {
1390         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_ShaderNode, data, identifier, validate, call, free);
1391         if (!nt)
1392                 return NULL;
1393         
1394         nodeRegisterType(nt);
1395         
1396         /* update while blender is running */
1397         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1398         
1399         return nt->ext.srna;
1400 }
1401
1402 static StructRNA *rna_CompositorNode_register(Main *bmain, ReportList *reports,
1403                                               void *data, const char *identifier,
1404                                               StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1405 {
1406         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_CompositorNode, data, identifier, validate, call, free);
1407         if (!nt)
1408                 return NULL;
1409         
1410         nodeRegisterType(nt);
1411         
1412         /* update while blender is running */
1413         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1414         
1415         return nt->ext.srna;
1416 }
1417
1418 static StructRNA *rna_TextureNode_register(Main *bmain, ReportList *reports,
1419                                            void *data, const char *identifier,
1420                                            StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1421 {
1422         bNodeType *nt = rna_Node_register_base(bmain, reports, &RNA_TextureNode, data, identifier, validate, call, free);
1423         if (!nt)
1424                 return NULL;
1425         
1426         nodeRegisterType(nt);
1427         
1428         /* update while blender is running */
1429         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1430         
1431         return nt->ext.srna;
1432 }
1433
1434 static IDProperty *rna_Node_idprops(PointerRNA *ptr, bool create)
1435 {
1436         bNode *node = ptr->data;
1437         
1438         if (create && !node->prop) {
1439                 IDPropertyTemplate val = {0};
1440                 node->prop = IDP_New(IDP_GROUP, &val, "RNA_Node ID properties");
1441         }
1442         
1443         return node->prop;
1444 }
1445
1446 static void rna_Node_parent_set(PointerRNA *ptr, PointerRNA value)
1447 {
1448         bNode *node = ptr->data;
1449         bNode *parent = value.data;
1450         
1451         if (parent) {
1452                 /* XXX only Frame node allowed for now,
1453                  * in the future should have a poll function or so to test possible attachment.
1454                  */
1455                 if (parent->type != NODE_FRAME)
1456                         return;
1457                 
1458                 /* make sure parent is not attached to the node */
1459                 if (nodeAttachNodeCheck(parent, node))
1460                         return;
1461         }
1462         
1463         nodeDetachNode(node);
1464         if (parent) {
1465                 nodeAttachNode(node, parent);
1466         }
1467 }
1468
1469 static int rna_Node_parent_poll(PointerRNA *ptr, PointerRNA value)
1470 {
1471         bNode *node = ptr->data;
1472         bNode *parent = value.data;
1473         
1474         /* XXX only Frame node allowed for now,
1475          * in the future should have a poll function or so to test possible attachment.
1476          */
1477         if (parent->type != NODE_FRAME)
1478                 return FALSE;
1479         
1480         /* make sure parent is not attached to the node */
1481         if (nodeAttachNodeCheck(parent, node))
1482                 return FALSE;
1483         
1484         return TRUE;
1485 }
1486
1487 static void rna_Node_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
1488 {
1489         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1490         ED_node_tag_update_nodetree(bmain, ntree);
1491 }
1492
1493 static void rna_Node_socket_value_update(ID *id, bNode *UNUSED(node), bContext *C)
1494 {
1495         ED_node_tag_update_nodetree(CTX_data_main(C), (bNodeTree *)id);
1496 }
1497
1498 static void rna_Node_select_set(PointerRNA *ptr, int value)
1499 {
1500         bNode *node = (bNode *)ptr->data;
1501         nodeSetSelected(node, value);
1502 }
1503
1504 static void rna_Node_name_set(PointerRNA *ptr, const char *value)
1505 {
1506         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1507         bNode *node = (bNode *)ptr->data;
1508         char oldname[sizeof(node->name)];
1509         
1510         /* make a copy of the old name first */
1511         BLI_strncpy(oldname, node->name, sizeof(node->name));
1512         /* set new name */
1513         BLI_strncpy_utf8(node->name, value, sizeof(node->name));
1514         
1515         nodeUniqueName(ntree, node);
1516         
1517         /* fix all the animation data which may link to this */
1518         BKE_all_animdata_fix_paths_rename(NULL, "nodes", oldname, node->name);
1519 }
1520
1521 static int rna_Node_inputs_lookupstring(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
1522 {
1523         bNode *node = (bNode *)ptr->data;
1524         bNodeSocket *sock = nodeFindSocket(node, SOCK_IN, key);
1525         RNA_pointer_create(ptr->id.data, &RNA_NodeSocket, sock, r_ptr);
1526         return (sock != NULL);
1527 }
1528
1529 static int rna_Node_outputs_lookupstring(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
1530 {
1531         bNode *node = (bNode *)ptr->data;
1532         bNodeSocket *sock = nodeFindSocket(node, SOCK_OUT, key);
1533         RNA_pointer_create(ptr->id.data, &RNA_NodeSocket, sock, r_ptr);
1534         return (sock != NULL);
1535 }
1536
1537 static bNodeSocket *rna_Node_inputs_new(ID *id, bNode *node, ReportList *reports, const char *type, const char *name, const char *identifier)
1538 {
1539         bNodeTree *ntree = (bNodeTree *)id;
1540         bNodeSocket *sock;
1541         
1542         sock = nodeAddSocket(ntree, node, SOCK_IN, type, identifier, name);
1543         
1544         if (sock == NULL) {
1545                 BKE_report(reports, RPT_ERROR, "Unable to create socket");
1546         }
1547         else {
1548                 ntreeUpdateTree(G.main, ntree);
1549                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1550         }
1551         
1552         return sock;
1553 }
1554
1555 static bNodeSocket *rna_Node_outputs_new(ID *id, bNode *node, ReportList *reports, const char *type, const char *name, const char *identifier)
1556 {
1557         bNodeTree *ntree = (bNodeTree *)id;
1558         bNodeSocket *sock;
1559         
1560         sock = nodeAddSocket(ntree, node, SOCK_OUT, type, identifier, name);
1561         
1562         if (sock == NULL) {
1563                 BKE_reportf(reports, RPT_ERROR, "Unable to create socket");
1564         }
1565         else {
1566                 ntreeUpdateTree(G.main, ntree);
1567                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1568         }
1569         
1570         return sock;
1571 }
1572
1573 static void rna_Node_socket_remove(ID *id, bNode *node, ReportList *reports, bNodeSocket *sock)
1574 {
1575         bNodeTree *ntree = (bNodeTree *)id;
1576         
1577         if (BLI_findindex(&node->inputs, sock) == -1 && BLI_findindex(&node->outputs, sock) == -1) {
1578                 BKE_reportf(reports, RPT_ERROR, "Unable to locate socket '%s' in node", sock->identifier);
1579         }
1580         else {
1581                 nodeRemoveSocket(ntree, node, sock);
1582                 
1583                 ntreeUpdateTree(G.main, ntree);
1584                 WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1585         }
1586 }
1587
1588 static void rna_Node_inputs_clear(ID *id, bNode *node)
1589 {
1590         bNodeTree *ntree = (bNodeTree *)id;
1591         bNodeSocket *sock, *nextsock;
1592         
1593         for (sock = node->inputs.first; sock; sock = nextsock) {
1594                 nextsock = sock->next;
1595                 nodeRemoveSocket(ntree, node, sock);
1596         }
1597
1598         ntreeUpdateTree(G.main, ntree);
1599         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1600 }
1601
1602 static void rna_Node_outputs_clear(ID *id, bNode *node)
1603 {
1604         bNodeTree *ntree = (bNodeTree *)id;
1605         bNodeSocket *sock, *nextsock;
1606         
1607         for (sock = node->outputs.first; sock; sock = nextsock) {
1608                 nextsock = sock->next;
1609                 nodeRemoveSocket(ntree, node, sock);
1610         }
1611
1612         ntreeUpdateTree(G.main, ntree);
1613         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1614 }
1615
1616 static void rna_Node_inputs_move(ID *id, bNode *node, int from_index, int to_index)
1617 {
1618         bNodeTree *ntree = (bNodeTree *)id;
1619         bNodeSocket *sock;
1620         
1621         if (from_index == to_index)
1622                 return;
1623         if (from_index < 0 || to_index < 0)
1624                 return;
1625         
1626         sock = BLI_findlink(&node->inputs, from_index);
1627         if (to_index < from_index) {
1628                 bNodeSocket *nextsock = BLI_findlink(&node->inputs, to_index);
1629                 if (nextsock) {
1630                         BLI_remlink(&node->inputs, sock);
1631                         BLI_insertlinkbefore(&node->inputs, nextsock, sock);
1632                 }
1633         }
1634         else {
1635                 bNodeSocket *prevsock = BLI_findlink(&node->inputs, to_index);
1636                 if (prevsock) {
1637                         BLI_remlink(&node->inputs, sock);
1638                         BLI_insertlinkafter(&node->inputs, prevsock, sock);
1639                 }
1640         }
1641         
1642         ntreeUpdateTree(G.main, ntree);
1643         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1644 }
1645
1646 static void rna_Node_outputs_move(ID *id, bNode *node, int from_index, int to_index)
1647 {
1648         bNodeTree *ntree = (bNodeTree *)id;
1649         bNodeSocket *sock;
1650         
1651         if (from_index == to_index)
1652                 return;
1653         if (from_index < 0 || to_index < 0)
1654                 return;
1655         
1656         sock = BLI_findlink(&node->outputs, from_index);
1657         if (to_index < from_index) {
1658                 bNodeSocket *nextsock = BLI_findlink(&node->outputs, to_index);
1659                 if (nextsock) {
1660                         BLI_remlink(&node->outputs, sock);
1661                         BLI_insertlinkbefore(&node->outputs, nextsock, sock);
1662                 }
1663         }
1664         else {
1665                 bNodeSocket *prevsock = BLI_findlink(&node->outputs, to_index);
1666                 if (prevsock) {
1667                         BLI_remlink(&node->outputs, sock);
1668                         BLI_insertlinkafter(&node->outputs, prevsock, sock);
1669                 }
1670         }
1671         
1672         ntreeUpdateTree(G.main, ntree);
1673         WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
1674 }
1675
1676 static void rna_Node_width_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
1677 {
1678         bNode *node = ptr->data;
1679         *min = *softmin = node->typeinfo->minwidth;
1680         *max = *softmax = node->typeinfo->maxwidth;
1681 }
1682
1683 static void rna_Node_height_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
1684 {
1685         bNode *node = ptr->data;
1686         *min = *softmin = node->typeinfo->minheight;
1687         *max = *softmax = node->typeinfo->maxheight;
1688 }
1689
1690
1691 /* ******** Node Socket ******** */
1692
1693 static void rna_NodeSocket_draw(bContext *C, struct uiLayout *layout, PointerRNA *ptr, PointerRNA *node_ptr, const char *text)
1694 {
1695         extern FunctionRNA rna_NodeSocket_draw_func;
1696
1697         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1698         ParameterList list;
1699         FunctionRNA *func;
1700
1701         func = &rna_NodeSocket_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */
1702
1703         RNA_parameter_list_create(&list, ptr, func);
1704         RNA_parameter_set_lookup(&list, "context", &C);
1705         RNA_parameter_set_lookup(&list, "layout", &layout);
1706         RNA_parameter_set_lookup(&list, "node", node_ptr);
1707         RNA_parameter_set_lookup(&list, "text", &text);
1708         sock->typeinfo->ext_socket.call(C, ptr, func, &list);
1709
1710         RNA_parameter_list_free(&list);
1711 }
1712
1713 static void rna_NodeSocket_draw_color(bContext *C, PointerRNA *ptr, PointerRNA *node_ptr, float *r_color)
1714 {
1715         extern FunctionRNA rna_NodeSocket_draw_color_func;
1716
1717         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1718         ParameterList list;
1719         FunctionRNA *func;
1720         void *ret;
1721
1722         func = &rna_NodeSocket_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */
1723
1724         RNA_parameter_list_create(&list, ptr, func);
1725         RNA_parameter_set_lookup(&list, "context", &C);
1726         RNA_parameter_set_lookup(&list, "node", node_ptr);
1727         sock->typeinfo->ext_socket.call(C, ptr, func, &list);
1728
1729         RNA_parameter_get_lookup(&list, "color", &ret);
1730         copy_v4_v4(r_color, (float *)ret);
1731
1732         RNA_parameter_list_free(&list);
1733 }
1734
1735 static void rna_NodeSocket_unregister(Main *UNUSED(bmain), StructRNA *type)
1736 {
1737         bNodeSocketType *st = RNA_struct_blender_type_get(type);
1738         if (!st)
1739                 return;
1740         
1741         RNA_struct_free_extension(type, &st->ext_socket);
1742
1743         nodeUnregisterSocketType(st);
1744
1745         RNA_struct_free(&BLENDER_RNA, type);
1746
1747         /* update while blender is running */
1748         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1749 }
1750
1751 static StructRNA *rna_NodeSocket_register(Main *bmain, ReportList *reports, void *data, const char *identifier,
1752                                           StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
1753 {
1754         bNodeSocketType *st, dummyst;
1755         bNodeSocket dummysock;
1756         PointerRNA dummyptr;
1757         int have_function[2];
1758
1759         /* setup dummy socket & socket type to store static properties in */
1760         memset(&dummyst, 0, sizeof(bNodeSocketType));
1761         
1762         memset(&dummysock, 0, sizeof(bNodeSocket));
1763         dummysock.typeinfo = &dummyst;
1764         RNA_pointer_create(NULL, &RNA_NodeSocket, &dummysock, &dummyptr);
1765
1766         /* validate the python class */
1767         if (validate(&dummyptr, data, have_function) != 0)
1768                 return NULL;
1769         
1770         if (strlen(identifier) >= sizeof(dummyst.idname)) {
1771                 BKE_reportf(reports, RPT_ERROR, "Registering node socket class: '%s' is too long, maximum length is %d",
1772                             identifier, (int)sizeof(dummyst.idname));
1773                 return NULL;
1774         }
1775
1776         /* check if we have registered this socket type before */
1777         st = nodeSocketTypeFind(dummyst.idname);
1778         if (!st) {
1779                 /* create a new node socket type */
1780                 st = MEM_callocN(sizeof(bNodeSocketType), "node socket type");
1781                 memcpy(st, &dummyst, sizeof(dummyst));
1782                 
1783                 nodeRegisterSocketType(st);
1784         }
1785         
1786         /* if RNA type is already registered, unregister first */
1787         if (st->ext_socket.srna) {
1788                 StructRNA *srna = st->ext_socket.srna;
1789                 RNA_struct_free_extension(srna, &st->ext_socket);
1790                 RNA_struct_free(&BLENDER_RNA, srna);
1791         }
1792         st->ext_socket.srna = RNA_def_struct_ptr(&BLENDER_RNA, st->idname, &RNA_NodeSocket); 
1793         st->ext_socket.data = data;
1794         st->ext_socket.call = call;
1795         st->ext_socket.free = free;
1796         RNA_struct_blender_type_set(st->ext_socket.srna, st);
1797         
1798         /* XXX bad level call! needed to initialize the basic draw functions ... */
1799         ED_init_custom_node_socket_type(st);
1800
1801         st->draw = (have_function[0]) ? rna_NodeSocket_draw : NULL;
1802         st->draw_color = (have_function[1]) ? rna_NodeSocket_draw_color : NULL;
1803
1804         /* update while blender is running */
1805         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
1806         
1807         return st->ext_socket.srna;
1808 }
1809
1810 static StructRNA *rna_NodeSocket_refine(PointerRNA *ptr)
1811 {
1812         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1813         
1814         if (sock->typeinfo->ext_socket.srna)
1815                 return sock->typeinfo->ext_socket.srna;
1816         else
1817                 return &RNA_NodeSocket;
1818 }
1819
1820 static char *rna_NodeSocket_path(PointerRNA *ptr)
1821 {
1822         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1823         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1824         bNode *node;
1825         int socketindex;
1826         char name_esc[sizeof(node->name) * 2];
1827         
1828         if (!nodeFindNode(ntree, sock, &node, &socketindex))
1829                 return NULL;
1830         
1831         BLI_strescape(name_esc, node->name, sizeof(name_esc));
1832
1833         if (sock->in_out == SOCK_IN) {
1834                 return BLI_sprintfN("nodes[\"%s\"].inputs[%d]", name_esc, socketindex);
1835         }
1836         else {
1837                 return BLI_sprintfN("nodes[\"%s\"].outputs[%d]", name_esc, socketindex);
1838         }
1839 }
1840
1841 static IDProperty *rna_NodeSocket_idprops(PointerRNA *ptr, bool create)
1842 {
1843         bNodeSocket *sock = ptr->data;
1844         
1845         if (create && !sock->prop) {
1846                 IDPropertyTemplate val = {0};
1847                 sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocket ID properties");
1848         }
1849         
1850         return sock->prop;
1851 }
1852
1853 static PointerRNA rna_NodeSocket_node_get(PointerRNA *ptr)
1854 {
1855         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1856         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1857         bNode *node;
1858         PointerRNA r_ptr;
1859         
1860         nodeFindNode(ntree, sock, &node, NULL);
1861         
1862         RNA_pointer_create((ID *)ntree, &RNA_Node, node, &r_ptr);
1863         return r_ptr;
1864 }
1865
1866 static void rna_NodeSocket_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
1867 {
1868         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
1869         ED_node_tag_update_nodetree(bmain, ntree);
1870 }
1871
1872 static void rna_NodeSocket_link_limit_set(PointerRNA *ptr, int value)
1873 {
1874         bNodeSocket *sock = ptr->data;
1875         sock->limit = (value == 0 ? 0xFFF : value);
1876 }
1877
1878 static void rna_NodeSocket_hide_set(PointerRNA *ptr, int value)
1879 {
1880         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1881         
1882         /* don't hide linked sockets */
1883         if (sock->flag & SOCK_IN_USE)
1884                 return;
1885         
1886         if (value)
1887                 sock->flag |= SOCK_HIDDEN;
1888         else
1889                 sock->flag &= ~SOCK_HIDDEN;
1890 }
1891
1892
1893 static void rna_NodeSocketInterface_draw(bContext *C, struct uiLayout *layout, PointerRNA *ptr)
1894 {
1895         extern FunctionRNA rna_NodeSocketInterface_draw_func;
1896
1897         bNodeSocket *stemp = (bNodeSocket *)ptr->data;
1898         ParameterList list;
1899         FunctionRNA *func;
1900
1901         if (!stemp->typeinfo)
1902                 return;
1903
1904         func = &rna_NodeSocketInterface_draw_func; /* RNA_struct_find_function(&ptr, "draw"); */
1905
1906         RNA_parameter_list_create(&list, ptr, func);
1907         RNA_parameter_set_lookup(&list, "context", &C);
1908         RNA_parameter_set_lookup(&list, "layout", &layout);
1909         stemp->typeinfo->ext_interface.call(C, ptr, func, &list);
1910
1911         RNA_parameter_list_free(&list);
1912 }
1913
1914 static void rna_NodeSocketInterface_draw_color(bContext *C, PointerRNA *ptr, float *r_color)
1915 {
1916         extern FunctionRNA rna_NodeSocketInterface_draw_color_func;
1917
1918         bNodeSocket *sock = (bNodeSocket *)ptr->data;
1919         ParameterList list;
1920         FunctionRNA *func;
1921         void *ret;
1922
1923         if (!sock->typeinfo)
1924                 return;
1925
1926         func = &rna_NodeSocketInterface_draw_color_func; /* RNA_struct_find_function(&ptr, "draw_color"); */
1927
1928         RNA_parameter_list_create(&list, ptr, func);
1929         RNA_parameter_set_lookup(&list, "context", &C);
1930         sock->typeinfo->ext_interface.call(C, ptr, func, &list);
1931
1932         RNA_parameter_get_lookup(&list, "color", &ret);
1933         copy_v4_v4(r_color, (float *)ret);
1934
1935         RNA_parameter_list_free(&list);
1936 }
1937
1938 static void rna_NodeSocketInterface_register_properties(bNodeTree *ntree, bNodeSocket *stemp, StructRNA *data_srna)
1939 {
1940         extern FunctionRNA rna_NodeSocketInterface_register_properties_func;
1941
1942         PointerRNA ptr;
1943         ParameterList list;
1944         FunctionRNA *func;
1945
1946         if (!stemp->typeinfo)
1947                 return;
1948
1949         RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
1950         func = &rna_NodeSocketInterface_register_properties_func; /* RNA_struct_find_function(&ptr, "register_properties"); */
1951
1952         RNA_parameter_list_create(&list, &ptr, func);
1953         RNA_parameter_set_lookup(&list, "data_rna_type", &data_srna);
1954         stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
1955
1956         RNA_parameter_list_free(&list);
1957 }
1958
1959 static void rna_NodeSocketInterface_init_socket(bNodeTree *ntree, bNodeSocket *stemp, bNode *node, bNodeSocket *sock, const char *data_path)
1960 {
1961         extern FunctionRNA rna_NodeSocketInterface_init_socket_func;
1962
1963         PointerRNA ptr, node_ptr, sock_ptr;
1964         ParameterList list;
1965         FunctionRNA *func;
1966
1967         if (!stemp->typeinfo)
1968                 return;
1969
1970         RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
1971         RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr);
1972         RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr);
1973         func = &rna_NodeSocketInterface_init_socket_func; /* RNA_struct_find_function(&ptr, "init_socket"); */
1974
1975         RNA_parameter_list_create(&list, &ptr, func);
1976         RNA_parameter_set_lookup(&list, "node", &node_ptr);
1977         RNA_parameter_set_lookup(&list, "socket", &sock_ptr);
1978         RNA_parameter_set_lookup(&list, "data_path", &data_path);
1979         stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
1980
1981         RNA_parameter_list_free(&list);
1982 }
1983
1984 static void rna_NodeSocketInterface_from_socket(bNodeTree *ntree, bNodeSocket *stemp, bNode *node, bNodeSocket *sock)
1985 {
1986         extern FunctionRNA rna_NodeSocketInterface_from_socket_func;
1987
1988         PointerRNA ptr, node_ptr, sock_ptr;
1989         ParameterList list;
1990         FunctionRNA *func;
1991
1992         if (!stemp->typeinfo)
1993                 return;
1994
1995         RNA_pointer_create((ID *)ntree, &RNA_NodeSocketInterface, stemp, &ptr);
1996         RNA_pointer_create((ID *)ntree, &RNA_Node, node, &node_ptr);
1997         RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &sock_ptr);
1998         func = &rna_NodeSocketInterface_from_socket_func; /* RNA_struct_find_function(&ptr, "from_socket"); */
1999
2000         RNA_parameter_list_create(&list, &ptr, func);
2001         RNA_parameter_set_lookup(&list, "node", &node_ptr);
2002         RNA_parameter_set_lookup(&list, "socket", &sock_ptr);
2003         stemp->typeinfo->ext_interface.call(NULL, &ptr, func, &list);
2004
2005         RNA_parameter_list_free(&list);
2006 }
2007
2008 static void rna_NodeSocketInterface_unregister(Main *UNUSED(bmain), StructRNA *type)
2009 {
2010         bNodeSocketType *st = RNA_struct_blender_type_get(type);
2011         if (!st)
2012                 return;
2013         
2014         RNA_struct_free_extension(type, &st->ext_interface);
2015         
2016         RNA_struct_free(&BLENDER_RNA, type);
2017         
2018         /* update while blender is running */
2019         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2020 }
2021
2022 static StructRNA *rna_NodeSocketInterface_register(Main *bmain, ReportList *reports, void *data, const char *identifier,
2023                                                   StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
2024 {
2025         bNodeSocketType *st, dummyst;
2026         bNodeSocket dummysock;
2027         PointerRNA dummyptr;
2028         int have_function[5];
2029
2030         /* setup dummy socket & socket type to store static properties in */
2031         memset(&dummyst, 0, sizeof(bNodeSocketType));
2032         
2033         memset(&dummysock, 0, sizeof(bNodeSocket));
2034         dummysock.typeinfo = &dummyst;
2035         RNA_pointer_create(NULL, &RNA_NodeSocketInterface, &dummysock, &dummyptr);
2036
2037         /* validate the python class */
2038         if (validate(&dummyptr, data, have_function) != 0)
2039                 return NULL;
2040
2041         /* check if we have registered this socket type before */
2042         st = nodeSocketTypeFind(dummyst.idname);
2043         if (st) {
2044                 /* basic socket type registered by a socket class before. */
2045         }
2046         else {
2047                 /* create a new node socket type */
2048                 st = MEM_callocN(sizeof(bNodeSocketType), "node socket type");
2049                 memcpy(st, &dummyst, sizeof(dummyst));
2050                 
2051                 nodeRegisterSocketType(st);
2052         }
2053         
2054         /* if RNA type is already registered, unregister first */
2055         if (st->ext_interface.srna) {
2056                 StructRNA *srna = st->ext_interface.srna;
2057                 RNA_struct_free_extension(srna, &st->ext_interface);
2058                 RNA_struct_free(&BLENDER_RNA, srna);
2059         }
2060         st->ext_interface.srna = RNA_def_struct_ptr(&BLENDER_RNA, identifier, &RNA_NodeSocketInterface); 
2061         st->ext_interface.data = data;
2062         st->ext_interface.call = call;
2063         st->ext_interface.free = free;
2064         RNA_struct_blender_type_set(st->ext_interface.srna, st);
2065         
2066         st->interface_draw = (have_function[0]) ? rna_NodeSocketInterface_draw : NULL;
2067         st->interface_draw_color = (have_function[1]) ? rna_NodeSocketInterface_draw_color : NULL;
2068         st->interface_register_properties = (have_function[2]) ? rna_NodeSocketInterface_register_properties : NULL;
2069         st->interface_init_socket = (have_function[3]) ? rna_NodeSocketInterface_init_socket : NULL;
2070         st->interface_from_socket = (have_function[4]) ? rna_NodeSocketInterface_from_socket : NULL;
2071         
2072         /* update while blender is running */
2073         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
2074         
2075         return st->ext_interface.srna;
2076 }
2077
2078 static StructRNA *rna_NodeSocketInterface_refine(PointerRNA *ptr)
2079 {
2080         bNodeSocket *sock = (bNodeSocket *)ptr->data;
2081         
2082         if (sock->typeinfo && sock->typeinfo->ext_interface.srna)
2083                 return sock->typeinfo->ext_interface.srna;
2084         else
2085                 return &RNA_NodeSocketInterface;
2086 }
2087
2088 static char *rna_NodeSocketInterface_path(PointerRNA *ptr)
2089 {
2090         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2091         bNodeSocket *sock = (bNodeSocket *)ptr->data;
2092         int socketindex;
2093         
2094         socketindex = BLI_findindex(&ntree->inputs, sock);
2095         if (socketindex != -1)
2096                 return BLI_sprintfN("inputs[%d]", socketindex);
2097         
2098         socketindex = BLI_findindex(&ntree->outputs, sock);
2099         if (socketindex != -1)
2100                 return BLI_sprintfN("outputs[%d]", socketindex);
2101         
2102         return NULL;
2103 }
2104
2105 static IDProperty *rna_NodeSocketInterface_idprops(PointerRNA *ptr, bool create)
2106 {
2107         bNodeSocket *sock = ptr->data;
2108         
2109         if (create && !sock->prop) {
2110                 IDPropertyTemplate val = {0};
2111                 sock->prop = IDP_New(IDP_GROUP, &val, "RNA_NodeSocketInterface ID properties");
2112         }
2113         
2114         return sock->prop;
2115 }
2116
2117 static void rna_NodeSocketInterface_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2118 {
2119         bNodeTree *ntree = ptr->id.data;
2120         bNodeSocket *stemp = ptr->data;
2121         
2122         if (!stemp->typeinfo)
2123                 return;
2124         
2125         ntree->update |= NTREE_UPDATE_GROUP;
2126         ntreeUpdateTree(G.main, ntree);
2127         
2128         ED_node_tag_update_nodetree(bmain, ntree);
2129 }
2130
2131
2132 /* ******** Standard Node Socket Base Types ******** */
2133
2134 static void rna_NodeSocketStandard_draw(ID *id, bNodeSocket *sock, struct bContext *C, struct uiLayout *layout, PointerRNA *nodeptr,
2135                                         const char *text)
2136 {
2137         PointerRNA ptr;
2138         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2139         sock->typeinfo->draw(C, layout, &ptr, nodeptr, text);
2140 }
2141
2142 static void rna_NodeSocketStandard_draw_color(ID *id, bNodeSocket *sock, struct bContext *C, PointerRNA *nodeptr, float *r_color)
2143 {
2144         PointerRNA ptr;
2145         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2146         sock->typeinfo->draw_color(C, &ptr, nodeptr, r_color);
2147 }
2148
2149 static void rna_NodeSocketInterfaceStandard_draw(ID *id, bNodeSocket *sock, struct bContext *C, struct uiLayout *layout)
2150 {
2151         PointerRNA ptr;
2152         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2153         sock->typeinfo->interface_draw(C, layout, &ptr);
2154 }
2155
2156 static void rna_NodeSocketInterfaceStandard_draw_color(ID *id, bNodeSocket *sock, struct bContext *C, float *r_color)
2157 {
2158         PointerRNA ptr;
2159         RNA_pointer_create(id, &RNA_NodeSocket, sock, &ptr);
2160         sock->typeinfo->interface_draw_color(C, &ptr, r_color);
2161 }
2162
2163 static void rna_NodeSocketStandard_float_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
2164 {
2165         bNodeSocket *sock = ptr->data;
2166         bNodeSocketValueFloat *dval = sock->default_value;
2167         int subtype = sock->typeinfo->subtype;
2168         
2169         *min = (subtype == PROP_UNSIGNED ? 0.0f : -FLT_MAX);
2170         *max = FLT_MAX;
2171         *softmin = dval->min;
2172         *softmax = dval->max;
2173 }
2174
2175 static void rna_NodeSocketStandard_int_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
2176 {
2177         bNodeSocket *sock = ptr->data;
2178         bNodeSocketValueInt *dval = sock->default_value;
2179         int subtype = sock->typeinfo->subtype;
2180         
2181         *min = (subtype == PROP_UNSIGNED ? 0 : INT_MIN);
2182         *max = INT_MAX;
2183         *softmin = dval->min;
2184         *softmax = dval->max;
2185 }
2186
2187 static void rna_NodeSocketStandard_vector_range(PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax)
2188 {
2189         bNodeSocket *sock = ptr->data;
2190         bNodeSocketValueVector *dval = sock->default_value;
2191         
2192         *min = -FLT_MAX;
2193         *max = FLT_MAX;
2194         *softmin = dval->min;
2195         *softmax = dval->max;
2196 }
2197
2198 /* using a context update function here, to avoid searching the node if possible */
2199 static void rna_NodeSocketStandard_value_update(struct bContext *C, PointerRNA *ptr)
2200 {
2201         bNode *node;
2202         
2203         /* default update */
2204         rna_NodeSocket_update(CTX_data_main(C), CTX_data_scene(C), ptr);
2205         
2206         /* try to use node from context, faster */
2207         node = CTX_data_pointer_get(C, "node").data;
2208         if (!node) {
2209                 bNodeTree *ntree = ptr->id.data;
2210                 bNodeSocket *sock = ptr->data;
2211                 
2212                 /* fall back to searching node in the tree */
2213                 nodeFindNode(ntree, sock, &node, NULL);
2214         }
2215         
2216         if (node)
2217                 nodeSynchronizeID(node, true);
2218 }
2219
2220
2221 /* ******** Node Types ******** */
2222
2223 static void rna_NodeInternalSocketTemplate_name_get(PointerRNA *ptr, char *value)
2224 {
2225         bNodeSocketTemplate *stemp = ptr->data;
2226         strcpy(value, stemp->name);
2227 }
2228
2229 static int rna_NodeInternalSocketTemplate_name_length(PointerRNA *ptr)
2230 {
2231         bNodeSocketTemplate *stemp = ptr->data;
2232         return strlen(stemp->name);
2233 }
2234
2235 static void rna_NodeInternalSocketTemplate_identifier_get(PointerRNA *ptr, char *value)
2236 {
2237         bNodeSocketTemplate *stemp = ptr->data;
2238         strcpy(value, stemp->identifier);
2239 }
2240
2241 static int rna_NodeInternalSocketTemplate_identifier_length(PointerRNA *ptr)
2242 {
2243         bNodeSocketTemplate *stemp = ptr->data;
2244         return strlen(stemp->identifier);
2245 }
2246
2247 static int rna_NodeInternalSocketTemplate_type_get(PointerRNA *ptr)
2248 {
2249         bNodeSocketTemplate *stemp = ptr->data;
2250         return stemp->type;
2251 }
2252
2253 static PointerRNA rna_NodeInternal_input_template(StructRNA *srna, int index)
2254 {
2255         bNodeType *ntype = RNA_struct_blender_type_get(srna);
2256         if (ntype && ntype->inputs) {
2257                 bNodeSocketTemplate *stemp = ntype->inputs;
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 PointerRNA rna_NodeInternal_output_template(StructRNA *srna, int index)
2273 {
2274         bNodeType *ntype = RNA_struct_blender_type_get(srna);
2275         if (ntype && ntype->outputs) {
2276                 bNodeSocketTemplate *stemp = ntype->outputs;
2277                 int i = 0;
2278                 while (i < index && stemp->type >= 0) {
2279                         ++i;
2280                         ++stemp;
2281                 }
2282                 if (i == index && stemp->type >= 0) {
2283                         PointerRNA ptr;
2284                         RNA_pointer_create(NULL, &RNA_NodeInternalSocketTemplate, stemp, &ptr);
2285                         return ptr;
2286                 }
2287         }
2288         return PointerRNA_NULL;
2289 }
2290
2291 static int rna_NodeInternal_poll(StructRNA *srna, bNodeTree *ntree)
2292 {
2293         bNodeType *ntype = RNA_struct_blender_type_get(srna);
2294         return ntype && (!ntype->poll || ntype->poll(ntype, ntree));
2295 }
2296
2297 static int rna_NodeInternal_poll_instance(bNode *node, bNodeTree *ntree)
2298 {
2299         bNodeType *ntype = node->typeinfo;
2300         if (ntype->poll_instance) {
2301                 return ntype->poll_instance(node, ntree);
2302         }
2303         else {
2304                 /* fall back to basic poll function */
2305                 return !ntype->poll || ntype->poll(ntype, ntree);
2306         }
2307 }
2308
2309 static void rna_NodeInternal_update(ID *id, bNode *node)
2310 {
2311         bNodeTree *ntree = (bNodeTree *)id;
2312         if (node->typeinfo->updatefunc)
2313                 node->typeinfo->updatefunc(ntree, node);
2314 }
2315
2316 static void rna_NodeInternal_draw_buttons(ID *id, bNode *node, struct bContext *C, struct uiLayout *layout)
2317 {
2318         if (node->typeinfo->uifunc) {
2319                 PointerRNA ptr;
2320                 RNA_pointer_create(id, &RNA_Node, node, &ptr);
2321                 node->typeinfo->uifunc(layout, C, &ptr);
2322         }
2323 }
2324
2325 static void rna_NodeInternal_draw_buttons_ext(ID *id, bNode *node, struct bContext *C, struct uiLayout *layout)
2326 {
2327         if (node->typeinfo->uifuncbut) {
2328                 PointerRNA ptr;
2329                 RNA_pointer_create(id, &RNA_Node, node, &ptr);
2330                 node->typeinfo->uifuncbut(layout, C, &ptr);
2331         }
2332 }
2333
2334 static void rna_CompositorNode_tag_need_exec(bNode *node)
2335 {
2336         node->need_exec = TRUE;
2337 }
2338
2339 static void rna_Node_tex_image_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2340 {
2341         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2342
2343         ED_node_tag_update_nodetree(bmain, ntree);
2344         WM_main_add_notifier(NC_IMAGE, NULL);
2345 }
2346
2347 static void rna_Node_material_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2348 {
2349         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2350         bNode *node = (bNode *)ptr->data;
2351
2352         if (node->id)
2353                 nodeSetActive(ntree, node);
2354
2355         ED_node_tag_update_nodetree(bmain, ntree);
2356 }
2357
2358 static void rna_NodeGroup_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
2359 {
2360         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2361         bNode *node = (bNode *)ptr->data;
2362         
2363         if (node->id)
2364                 ntreeUpdateTree(bmain, (bNodeTree *)node->id);
2365         
2366         ED_node_tag_update_nodetree(bmain, ntree);
2367 }
2368
2369 static void rna_NodeGroup_node_tree_set(PointerRNA *ptr, const PointerRNA value)
2370 {
2371         bNodeTree *ntree = ptr->id.data;
2372         bNode *node = ptr->data;
2373         bNodeTree *ngroup = value.data;
2374         
2375         if (nodeGroupPoll(ntree, ngroup)) {
2376                 if (node->id)
2377                         id_us_min(node->id);
2378                 if (ngroup)
2379                         id_us_plus(&ngroup->id);
2380                 
2381                 node->id = &ngroup->id;
2382         }
2383 }
2384
2385 static int rna_NodeGroup_node_tree_poll(PointerRNA *ptr, const PointerRNA value)
2386 {
2387         bNodeTree *ntree = ptr->id.data;
2388         bNodeTree *ngroup = value.data;
2389         
2390         /* only allow node trees of the same type as the group node's tree */
2391         if (ngroup->type != ntree->type)
2392                 return false;
2393         
2394         return nodeGroupPoll(ntree, ngroup);
2395 }
2396
2397
2398 static StructRNA *rna_NodeGroup_interface_typef(PointerRNA *ptr)
2399 {
2400         bNode *node = ptr->data;
2401         bNodeTree *ngroup = (bNodeTree *)node->id;
2402
2403         if (ngroup) {
2404                 StructRNA *srna = ntreeInterfaceTypeGet(ngroup, TRUE);
2405                 if (srna)
2406                         return srna;
2407         }
2408         return &RNA_PropertyGroup;
2409 }
2410
2411 static StructRNA *rna_NodeGroupInputOutput_interface_typef(PointerRNA *ptr)
2412 {
2413         bNodeTree *ntree = ptr->id.data;
2414         
2415         if (ntree) {
2416                 StructRNA *srna = ntreeInterfaceTypeGet(ntree, TRUE);
2417                 if (srna)
2418                         return srna;
2419         }
2420         return &RNA_PropertyGroup;
2421 }
2422
2423 static void rna_distance_matte_t1_set(PointerRNA *ptr, float value)
2424 {
2425         bNode *node = (bNode *)ptr->data;
2426         NodeChroma *chroma = node->storage;
2427
2428         chroma->t1 = value;
2429 }
2430
2431 static void rna_distance_matte_t2_set(PointerRNA *ptr, float value)
2432 {
2433         bNode *node = (bNode *)ptr->data;
2434         NodeChroma *chroma = node->storage;
2435
2436         chroma->t2 = value;
2437 }
2438
2439 static void rna_difference_matte_t1_set(PointerRNA *ptr, float value)
2440 {
2441         bNode *node = (bNode *)ptr->data;
2442         NodeChroma *chroma = node->storage;
2443
2444         chroma->t1 = value;
2445 }
2446
2447 static void rna_difference_matte_t2_set(PointerRNA *ptr, float value)
2448 {
2449         bNode *node = (bNode *)ptr->data;
2450         NodeChroma *chroma = node->storage;
2451
2452         chroma->t2 = value;
2453 }
2454
2455 /* Button Set Funcs for Matte Nodes */
2456 static void rna_Matte_t1_set(PointerRNA *ptr, float value)
2457 {
2458         bNode *node = (bNode *)ptr->data;
2459         NodeChroma *chroma = node->storage;
2460         
2461         chroma->t1 = value;
2462         
2463         if (value < chroma->t2) 
2464                 chroma->t2 = value;
2465 }
2466
2467 static void rna_Matte_t2_set(PointerRNA *ptr, float value)
2468 {
2469         bNode *node = (bNode *)ptr->data;
2470         NodeChroma *chroma = node->storage;
2471         
2472         if (value > chroma->t1) 
2473                 value = chroma->t1;
2474         
2475         chroma->t2 = value;
2476 }
2477
2478 static void rna_Node_scene_set(PointerRNA *ptr, PointerRNA value)
2479 {
2480         bNode *node = (bNode *)ptr->data;
2481
2482         if (node->id) {
2483                 id_us_min(node->id);
2484                 node->id = NULL;
2485         }
2486
2487         node->id = value.data;
2488
2489         id_us_plus(node->id);
2490 }
2491
2492 static void rna_Node_image_layer_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2493 {
2494         bNode *node = (bNode *)ptr->data;
2495         Image *ima = (Image *)node->id;
2496         ImageUser *iuser = node->storage;
2497         
2498         BKE_image_multilayer_index(ima->rr, iuser);
2499         BKE_image_signal(ima, iuser, IMA_SIGNAL_SRC_CHANGE);
2500         
2501         rna_Node_update(bmain, scene, ptr);
2502 }
2503
2504 static EnumPropertyItem *renderresult_layers_add_enum(RenderLayer *rl)
2505 {
2506         EnumPropertyItem *item = NULL;
2507         EnumPropertyItem tmp = {0, "", 0, "", ""};
2508         int i = 0, totitem = 0;
2509         
2510         while (rl) {
2511                 tmp.identifier = rl->name;
2512                 /* little trick: using space char instead empty string makes the item selectable in the dropdown */
2513                 if (rl->name[0] == '\0')
2514                         tmp.name = " ";
2515                 else
2516                         tmp.name = rl->name;
2517                 tmp.value = i++;
2518                 RNA_enum_item_add(&item, &totitem, &tmp);
2519                 rl = rl->next;
2520         }
2521         
2522         RNA_enum_item_end(&item, &totitem);
2523
2524         return item;
2525 }
2526
2527 static EnumPropertyItem *rna_Node_image_layer_itemf(bContext *UNUSED(C), PointerRNA *ptr,
2528                                                     PropertyRNA *UNUSED(prop), int *free)
2529 {
2530         bNode *node = (bNode *)ptr->data;
2531         Image *ima = (Image *)node->id;
2532         EnumPropertyItem *item = NULL;
2533         RenderLayer *rl;
2534         
2535         if (!ima || !(ima->rr)) return NULL;
2536         
2537         rl = ima->rr->layers.first;
2538         item = renderresult_layers_add_enum(rl);
2539         
2540         *free = 1;
2541         
2542         return item;
2543 }
2544
2545 static EnumPropertyItem *rna_Node_scene_layer_itemf(bContext *UNUSED(C), PointerRNA *ptr,
2546                                                     PropertyRNA *UNUSED(prop), int *free)
2547 {
2548         bNode *node = (bNode *)ptr->data;
2549         Scene *sce = (Scene *)node->id;
2550         EnumPropertyItem *item = NULL;
2551         RenderLayer *rl;
2552         
2553         if (!sce) return NULL;
2554         
2555         rl = sce->r.layers.first;
2556         item = renderresult_layers_add_enum(rl);
2557         
2558         *free = 1;
2559         
2560         return item;
2561 }
2562
2563 static EnumPropertyItem *rna_Node_channel_itemf(bContext *UNUSED(C), PointerRNA *ptr,
2564                                                 PropertyRNA *UNUSED(prop), int *free)
2565 {
2566         bNode *node = (bNode *)ptr->data;
2567         EnumPropertyItem *item = NULL;
2568         EnumPropertyItem tmp = {0, "", 0, "", ""};
2569         int totitem = 0;
2570         
2571         switch (node->custom1) {
2572                 case CMP_NODE_CHANNEL_MATTE_CS_RGB:
2573                         tmp.identifier = "R"; tmp.name = "R"; tmp.value = 1;
2574                         RNA_enum_item_add(&item, &totitem, &tmp);
2575                         tmp.identifier = "G"; tmp.name = "G"; tmp.value = 2;
2576                         RNA_enum_item_add(&item, &totitem, &tmp);
2577                         tmp.identifier = "B"; tmp.name = "B"; tmp.value = 3;
2578                         RNA_enum_item_add(&item, &totitem, &tmp);
2579                         break;
2580                 case CMP_NODE_CHANNEL_MATTE_CS_HSV:
2581                         tmp.identifier = "H"; tmp.name = "H"; tmp.value = 1;
2582                         RNA_enum_item_add(&item, &totitem, &tmp);
2583                         tmp.identifier = "S"; tmp.name = "S"; tmp.value = 2;
2584                         RNA_enum_item_add(&item, &totitem, &tmp);
2585                         tmp.identifier = "V"; tmp.name = "V"; tmp.value = 3;
2586                         RNA_enum_item_add(&item, &totitem, &tmp);
2587                         break;
2588                 case CMP_NODE_CHANNEL_MATTE_CS_YUV:
2589                         tmp.identifier = "Y"; tmp.name = "Y"; tmp.value = 1;
2590                         RNA_enum_item_add(&item, &totitem, &tmp);
2591                         tmp.identifier = "G"; tmp.name = "U"; tmp.value = 2;
2592                         RNA_enum_item_add(&item, &totitem, &tmp);
2593                         tmp.identifier = "V"; tmp.name = "V"; tmp.value = 3;
2594                         RNA_enum_item_add(&item, &totitem, &tmp);
2595                         break;
2596                 case CMP_NODE_CHANNEL_MATTE_CS_YCC:
2597                         tmp.identifier = "Y"; tmp.name = "Y"; tmp.value = 1;
2598                         RNA_enum_item_add(&item, &totitem, &tmp);
2599                         tmp.identifier = "CB"; tmp.name = "Cr"; tmp.value = 2;
2600                         RNA_enum_item_add(&item, &totitem, &tmp);
2601                         tmp.identifier = "CR"; tmp.name = "Cb"; tmp.value = 3;
2602                         RNA_enum_item_add(&item, &totitem, &tmp);
2603                         break;
2604                 default:
2605                         break;
2606         }
2607
2608         RNA_enum_item_end(&item, &totitem);
2609         *free = 1;
2610         
2611         return item;
2612 }
2613
2614 static void rna_Image_Node_update_id(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
2615 {
2616         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2617         bNode *node = (bNode *)ptr->data;
2618
2619         node->update |= NODE_UPDATE_ID;
2620         nodeUpdate(ntree, node);        /* to update image node sockets */
2621 }
2622
2623 static void rna_Mapping_Node_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2624 {
2625         bNode *node = ptr->data;
2626         init_tex_mapping(node->storage);
2627         rna_Node_update(bmain, scene, ptr);
2628 }
2629
2630 static void rna_NodeOutputFile_slots_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
2631 {
2632         bNode *node = ptr->data;
2633         rna_iterator_listbase_begin(iter, &node->inputs, NULL);
2634 }
2635
2636 static PointerRNA rna_NodeOutputFile_slot_file_get(CollectionPropertyIterator *iter)
2637 {
2638         PointerRNA ptr;
2639         bNodeSocket *sock = rna_iterator_listbase_get(iter);
2640         RNA_pointer_create(iter->parent.id.data, &RNA_NodeOutputFileSlotFile, sock->storage, &ptr);
2641         return ptr;
2642 }
2643
2644 /* ******** Node Socket Types ******** */
2645
2646 static PointerRNA rna_NodeOutputFile_slot_layer_get(CollectionPropertyIterator *iter)
2647 {
2648         PointerRNA ptr;
2649         bNodeSocket *sock = rna_iterator_listbase_get(iter);
2650         RNA_pointer_create(iter->parent.id.data, &RNA_NodeOutputFileSlotLayer, sock->storage, &ptr);
2651         return ptr;
2652 }
2653
2654 static int rna_NodeOutputFileSocket_find_node(bNodeTree *ntree, NodeImageMultiFileSocket *data, bNode **nodep, bNodeSocket **sockp)
2655 {
2656         bNode *node;
2657         bNodeSocket *sock;
2658         
2659         for (node = ntree->nodes.first; node; node = node->next) {
2660                 for (sock = node->inputs.first; sock; sock = sock->next) {
2661                         NodeImageMultiFileSocket *sockdata = sock->storage;
2662                         if (sockdata == data) {
2663                                 *nodep = node;
2664                                 *sockp = sock;
2665                                 return 1;
2666                         }
2667                 }
2668         }
2669         
2670         *nodep = NULL;
2671         *sockp = NULL;
2672         return 0;
2673 }
2674
2675 static void rna_NodeOutputFileSlotFile_path_set(PointerRNA *ptr, const char *value)
2676 {
2677         bNodeTree *ntree = ptr->id.data;
2678         NodeImageMultiFileSocket *sockdata = ptr->data;
2679         bNode *node;
2680         bNodeSocket *sock;
2681         
2682         if (rna_NodeOutputFileSocket_find_node(ntree, sockdata, &node, &sock)) {
2683                 ntreeCompositOutputFileSetPath(node, sock, value);
2684         }
2685 }
2686
2687 static void rna_NodeOutputFileSlotLayer_name_set(PointerRNA *ptr, const char *value)
2688 {
2689         bNodeTree *ntree = ptr->id.data;
2690         NodeImageMultiFileSocket *sockdata = ptr->data;
2691         bNode *node;
2692         bNodeSocket *sock;
2693         
2694         if (rna_NodeOutputFileSocket_find_node(ntree, sockdata, &node, &sock)) {
2695                 ntreeCompositOutputFileSetLayer(node, sock, value);
2696         }
2697 }
2698
2699 static void rna_ShaderNodeScript_mode_set(PointerRNA *ptr, int value)
2700 {
2701         bNode *node = (bNode *)ptr->data;
2702         NodeShaderScript *nss = node->storage;
2703
2704         if (nss->mode != value) {
2705                 nss->mode = value;
2706                 nss->filepath[0] = '\0';
2707                 nss->flag &= ~NODE_SCRIPT_AUTO_UPDATE;
2708
2709                 /* replace text datablock by filepath */
2710                 if (node->id) {
2711                         Text *text = (Text *)node->id;
2712
2713                         if (value == NODE_SCRIPT_EXTERNAL && text->name) {
2714                                 BLI_strncpy(nss->filepath, text->name, sizeof(nss->filepath));
2715                                 BLI_path_rel(nss->filepath, G.main->name);
2716                         }
2717
2718                         id_us_min(node->id);
2719                         node->id = NULL;
2720                 }
2721
2722                 /* remove any bytecode */
2723                 if (nss->bytecode) {
2724                         MEM_freeN(nss->bytecode);
2725                         nss->bytecode = NULL;
2726                 }
2727
2728                 nss->bytecode_hash[0] = '\0';
2729         }
2730 }
2731
2732 static void rna_ShaderNodeScript_bytecode_get(PointerRNA *ptr, char *value)
2733 {
2734         bNode *node = (bNode *)ptr->data;
2735         NodeShaderScript *nss = node->storage;
2736
2737         strcpy(value, (nss->bytecode) ? nss->bytecode : "");
2738 }
2739
2740 static int rna_ShaderNodeScript_bytecode_length(PointerRNA *ptr)
2741 {
2742         bNode *node = (bNode *)ptr->data;
2743         NodeShaderScript *nss = node->storage;
2744
2745         return (nss->bytecode) ? strlen(nss->bytecode) : 0;
2746 }
2747
2748 static void rna_ShaderNodeScript_bytecode_set(PointerRNA *ptr, const char *value)
2749 {
2750         bNode *node = (bNode *)ptr->data;
2751         NodeShaderScript *nss = node->storage;
2752
2753         if (nss->bytecode)
2754                 MEM_freeN(nss->bytecode);
2755
2756         if (value && value[0])
2757                 nss->bytecode = BLI_strdup(value);
2758         else
2759                 nss->bytecode = NULL;
2760 }
2761
2762 static void rna_ShaderNodeScript_update(Main *bmain, Scene *scene, PointerRNA *ptr)
2763 {
2764         bNodeTree *ntree = (bNodeTree *)ptr->id.data;
2765         bNode *node = (bNode *)ptr->data;
2766         RenderEngineType *engine_type = RE_engines_find(scene->r.engine);
2767
2768         if (engine_type && engine_type->update_script_node) {
2769                 /* auto update node */
2770                 RenderEngine *engine = RE_engine_create(engine_type);
2771                 engine_type->update_script_node(engine, ntree, node);
2772                 RE_engine_free(engine);
2773         }
2774
2775         ED_node_tag_update_nodetree(bmain, ntree);
2776 }
2777
2778 #else
2779
2780 static EnumPropertyItem prop_image_layer_items[] = {
2781         { 0, "PLACEHOLDER",          0, "Placeholder",          ""},
2782         {0, NULL, 0, NULL, NULL}
2783 };
2784
2785 static EnumPropertyItem prop_scene_layer_items[] = {
2786         { 0, "PLACEHOLDER",          0, "Placeholder",          ""},
2787         {0, NULL, 0, NULL, NULL}
2788 };
2789
2790 static EnumPropertyItem prop_tri_channel_items[] = {
2791         { 1, "R", 0, "R", ""},
2792         { 2, "G", 0, "G", ""},
2793         { 3, "B", 0, "B", ""},
2794         {0, NULL, 0, NULL, NULL}
2795 };
2796
2797 static EnumPropertyItem node_flip_items[] = {
2798         {0, "X",  0, "Flip X",     ""},
2799         {1, "Y",  0, "Flip Y",     ""},
2800         {2, "XY", 0, "Flip X & Y", ""},
2801         {0, NULL, 0, NULL, NULL}
2802 };
2803
2804 static EnumPropertyItem node_ycc_items[] = {
2805         { 0, "ITUBT601", 0, "ITU 601",  ""},
2806         { 1, "ITUBT709", 0, "ITU 709",  ""},
2807         { 2, "JFIF",     0, "Jpeg",     ""},
2808         {0, NULL, 0, NULL, NULL}
2809 };
2810
2811 static EnumPropertyItem node_glossy_items[] = {
2812         {SHD_GLOSSY_SHARP,    "SHARP",    0, "Sharp",    ""},
2813         {SHD_GLOSSY_BECKMANN, "BECKMANN", 0, "Beckmann", ""},
2814         {SHD_GLOSSY_GGX,      "GGX",      0, "GGX",      ""},
2815         {0, NULL, 0, NULL, NULL}
2816 };
2817
2818 static EnumPropertyItem node_script_mode_items[] = {
2819         {NODE_SCRIPT_INTERNAL, "INTERNAL", 0, "Internal", "Use internal text datablock"},
2820         {NODE_SCRIPT_EXTERNAL, "EXTERNAL", 0, "External", "Use external .osl or .oso file"},
2821         {0, NULL, 0, NULL, NULL}
2822 };
2823
2824 /* -- Common nodes ---------------------------------------------------------- */
2825
2826 static void def_group_input(StructRNA *srna)
2827 {
2828         PropertyRNA *prop;
2829         
2830         prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
2831         RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroupInputOutput_interface_typef", NULL);
2832         RNA_def_property_struct_type(prop, "PropertyGroup");
2833         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2834         RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
2835 }
2836
2837 static void def_group_output(StructRNA *srna)
2838 {
2839         PropertyRNA *prop;
2840         
2841         prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
2842         RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroupInputOutput_interface_typef", NULL);
2843         RNA_def_property_struct_type(prop, "PropertyGroup");
2844         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2845         RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
2846         
2847         prop = RNA_def_property(srna, "is_active_output", PROP_BOOLEAN, PROP_NONE);
2848         RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_DO_OUTPUT);
2849         RNA_def_property_ui_text(prop, "Active Output", "True if this node is used as the active group output");
2850         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2851 }
2852
2853 static void def_group(StructRNA *srna)
2854 {
2855         PropertyRNA *prop;
2856         
2857         RNA_def_struct_register_funcs(srna, "rna_NodeGroup_register", "rna_Node_unregister", NULL);
2858         
2859         prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
2860         RNA_def_property_pointer_sdna(prop, NULL, "id");
2861         RNA_def_property_struct_type(prop, "NodeTree");
2862         RNA_def_property_pointer_funcs(prop, NULL, "rna_NodeGroup_node_tree_set", NULL, "rna_NodeGroup_node_tree_poll");
2863         RNA_def_property_flag(prop, PROP_EDITABLE);
2864         RNA_def_property_ui_text(prop, "Node Tree", "");
2865         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeGroup_update");
2866
2867         prop = RNA_def_property(srna, "interface", PROP_POINTER, PROP_NONE);
2868         RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_NodeGroup_interface_typef", NULL);
2869         RNA_def_property_struct_type(prop, "PropertyGroup");
2870         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2871         RNA_def_property_ui_text(prop, "Interface", "Interface socket data");
2872 }
2873
2874 static void def_frame(StructRNA *srna)
2875 {
2876         PropertyRNA *prop; 
2877         
2878         RNA_def_struct_sdna_from(srna, "NodeFrame", "storage");
2879         
2880         prop = RNA_def_property(srna, "shrink", PROP_BOOLEAN, PROP_NONE);
2881         RNA_def_property_boolean_sdna(prop, NULL, "flag", NODE_FRAME_SHRINK);
2882         RNA_def_property_ui_text(prop, "Shrink", "Shrink the frame to minimal bounding box");
2883         RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, NULL);
2884
2885         prop = RNA_def_property(srna, "label_size", PROP_INT, PROP_NONE);
2886         RNA_def_property_int_sdna(prop, NULL, "label_size");
2887         RNA_def_property_range(prop, 8, 64);
2888         RNA_def_property_ui_text(prop, "Label Font Size", "Font size to use for displaying the label");
2889         RNA_def_property_update(prop, NC_NODE | ND_DISPLAY, NULL);
2890 }
2891
2892 static void def_math(StructRNA *srna)
2893 {
2894         PropertyRNA *prop;
2895         
2896         prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
2897         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2898         RNA_def_property_enum_items(prop, node_math_items);
2899         RNA_def_property_ui_text(prop, "Operation", "");
2900         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2901
2902         prop = RNA_def_property(srna, "use_clamp", PROP_BOOLEAN, PROP_NONE);
2903         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 1);
2904         RNA_def_property_ui_text(prop, "Clamp", "Clamp result of the node to 0..1 range");
2905         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2906 }
2907
2908 static void def_vector_math(StructRNA *srna)
2909 {
2910         PropertyRNA *prop;
2911         
2912         prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
2913         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2914         RNA_def_property_enum_items(prop, node_vec_math_items);
2915         RNA_def_property_ui_text(prop, "Operation", "");
2916         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2917 }
2918
2919 static void def_rgb_curve(StructRNA *srna)
2920 {
2921         PropertyRNA *prop;
2922         
2923         prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
2924         RNA_def_property_pointer_sdna(prop, NULL, "storage");
2925         RNA_def_property_struct_type(prop, "CurveMapping");
2926         RNA_def_property_ui_text(prop, "Mapping", "");
2927         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2928 }
2929
2930 static void def_vector_curve(StructRNA *srna)
2931 {
2932         PropertyRNA *prop;
2933         
2934         prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
2935         RNA_def_property_pointer_sdna(prop, NULL, "storage");
2936         RNA_def_property_struct_type(prop, "CurveMapping");
2937         RNA_def_property_ui_text(prop, "Mapping", "");
2938         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2939 }
2940
2941 static void def_time(StructRNA *srna)
2942 {
2943         PropertyRNA *prop;
2944         
2945         prop = RNA_def_property(srna, "curve", PROP_POINTER, PROP_NONE);
2946         RNA_def_property_pointer_sdna(prop, NULL, "storage");
2947         RNA_def_property_struct_type(prop, "CurveMapping");
2948         RNA_def_property_ui_text(prop, "Curve", "");
2949         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2950         
2951         prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_NONE);
2952         RNA_def_property_int_sdna(prop, NULL, "custom1");
2953         RNA_def_property_ui_text(prop, "Start Frame", "");
2954         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2955         
2956         prop = RNA_def_property(srna, "frame_end", PROP_INT, PROP_NONE);
2957         RNA_def_property_int_sdna(prop, NULL, "custom2");
2958         RNA_def_property_ui_text(prop, "End Frame", "");
2959         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2960 }
2961
2962 static void def_colorramp(StructRNA *srna)
2963 {
2964         PropertyRNA *prop;
2965         
2966         prop = RNA_def_property(srna, "color_ramp", PROP_POINTER, PROP_NONE);
2967         RNA_def_property_pointer_sdna(prop, NULL, "storage");
2968         RNA_def_property_struct_type(prop, "ColorRamp");
2969         RNA_def_property_ui_text(prop, "Color Ramp", "");
2970         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2971 }
2972
2973 static void def_mix_rgb(StructRNA *srna)
2974 {
2975         PropertyRNA *prop;
2976         
2977         prop = RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
2978         RNA_def_property_enum_sdna(prop, NULL, "custom1");
2979         RNA_def_property_enum_items(prop, ramp_blend_items);
2980         RNA_def_property_ui_text(prop, "Blend Type", "");
2981         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2982         
2983         prop = RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
2984         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 1);
2985         RNA_def_property_ui_text(prop, "Alpha", "Include alpha of second input in this operation");
2986         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2987
2988         prop = RNA_def_property(srna, "use_clamp", PROP_BOOLEAN, PROP_NONE);
2989         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 2);
2990         RNA_def_property_ui_text(prop, "Clamp", "Clamp result of the node to 0..1 range");
2991         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
2992 }
2993
2994 static void def_texture(StructRNA *srna)
2995 {
2996         PropertyRNA *prop;
2997         
2998         prop = RNA_def_property(srna, "texture", PROP_POINTER, PROP_NONE);
2999         RNA_def_property_pointer_sdna(prop, NULL, "id");
3000         RNA_def_property_struct_type(prop, "Texture");
3001         RNA_def_property_flag(prop, PROP_EDITABLE);
3002         RNA_def_property_ui_text(prop, "Texture", "");
3003         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3004         
3005         prop = RNA_def_property(srna, "node_output", PROP_INT, PROP_NONE);
3006         RNA_def_property_int_sdna(prop, NULL, "custom1");
3007         RNA_def_property_ui_text(prop, "Node Output", "For node-based textures, which output node to use");
3008         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3009 }
3010
3011
3012 /* -- Shader Nodes ---------------------------------------------------------- */
3013
3014 static void def_sh_material(StructRNA *srna)
3015 {
3016         PropertyRNA *prop;
3017
3018         prop = RNA_def_property(srna, "material", PROP_POINTER, PROP_NONE);
3019         RNA_def_property_pointer_sdna(prop, NULL, "id");
3020         RNA_def_property_struct_type(prop, "Material");
3021         RNA_def_property_flag(prop, PROP_EDITABLE);
3022         RNA_def_property_ui_text(prop, "Material", "");
3023         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_material_update");
3024
3025         prop = RNA_def_property(srna, "use_diffuse", PROP_BOOLEAN, PROP_NONE);
3026         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_DIFF);
3027         RNA_def_property_ui_text(prop, "Diffuse", "Material Node outputs Diffuse");
3028         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3029
3030         prop = RNA_def_property(srna, "use_specular", PROP_BOOLEAN, PROP_NONE);
3031         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_SPEC);
3032         RNA_def_property_ui_text(prop, "Specular", "Material Node outputs Specular");
3033         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3034         
3035         prop = RNA_def_property(srna, "invert_normal", PROP_BOOLEAN, PROP_NONE);
3036         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_NEG);
3037         RNA_def_property_ui_text(prop, "Invert Normal", "Material Node uses inverted normal");
3038         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3039 }
3040
3041 static void def_sh_mapping(StructRNA *srna)
3042 {
3043         PropertyRNA *prop;
3044         
3045         RNA_def_struct_sdna_from(srna, "TexMapping", "storage");
3046
3047         prop = RNA_def_property(srna, "translation", PROP_FLOAT, PROP_TRANSLATION);
3048         RNA_def_property_float_sdna(prop, NULL, "loc");
3049         RNA_def_property_ui_text(prop, "Location", "");
3050         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3051         
3052         /* Not PROP_XYZ, this is now in radians, no more degrees */
3053         prop = RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_EULER);
3054         RNA_def_property_float_sdna(prop, NULL, "rot");
3055         RNA_def_property_ui_text(prop, "Rotation", "");
3056         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3057         
3058         prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
3059         RNA_def_property_float_sdna(prop, NULL, "size");
3060         RNA_def_property_ui_text(prop, "Scale", "");
3061         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3062         
3063         prop = RNA_def_property(srna, "min", PROP_FLOAT, PROP_XYZ);
3064         RNA_def_property_float_sdna(prop, NULL, "min");
3065         RNA_def_property_ui_text(prop, "Minimum", "Minimum value for clipping");
3066         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3067         
3068         prop = RNA_def_property(srna, "max", PROP_FLOAT, PROP_XYZ);
3069         RNA_def_property_float_sdna(prop, NULL, "max");
3070         RNA_def_property_ui_text(prop, "Maximum", "Maximum value for clipping");
3071         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3072         
3073         prop = RNA_def_property(srna, "use_min", PROP_BOOLEAN, PROP_NONE);
3074         RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MIN);
3075         RNA_def_property_ui_text(prop, "Has Minimum", "Whether to use minimum clipping value");
3076         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3077         
3078         prop = RNA_def_property(srna, "use_max", PROP_BOOLEAN, PROP_NONE);
3079         RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MAX);
3080         RNA_def_property_ui_text(prop, "Has Maximum", "Whether to use maximum clipping value");
3081         RNA_def_property_update(prop, 0, "rna_Mapping_Node_update");
3082 }
3083
3084 static void def_sh_geometry(StructRNA *srna)
3085 {
3086         PropertyRNA *prop;
3087         
3088         RNA_def_struct_sdna_from(srna, "NodeGeometry", "storage");
3089         
3090         prop = RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE);
3091         RNA_def_property_string_sdna(prop, NULL, "uvname");
3092         RNA_def_property_ui_text(prop, "UV Map", "");
3093         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3094         
3095         prop = RNA_def_property(srna, "color_layer", PROP_STRING, PROP_NONE);
3096         RNA_def_property_string_sdna(prop, NULL, "colname");
3097         RNA_def_property_ui_text(prop, "Vertex Color Layer", "");
3098         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3099 }
3100
3101 static void def_sh_attribute(StructRNA *srna)
3102 {
3103         PropertyRNA *prop;
3104         
3105         RNA_def_struct_sdna_from(srna, "NodeShaderAttribute", "storage");
3106         
3107         prop = RNA_def_property(srna, "attribute_name", PROP_STRING, PROP_NONE);
3108         RNA_def_property_string_sdna(prop, NULL, "name");
3109         RNA_def_property_ui_text(prop, "Attribute Name", "");
3110         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3111 }
3112
3113 static void def_sh_tex(StructRNA *srna)
3114 {
3115         PropertyRNA *prop;
3116
3117         prop = RNA_def_property(srna, "texture_mapping", PROP_POINTER, PROP_NONE);
3118         RNA_def_property_pointer_sdna(prop, NULL, "base.tex_mapping");
3119         RNA_def_property_flag(prop, PROP_NEVER_NULL);
3120         RNA_def_property_ui_text(prop, "Texture Mapping", "Texture coordinate mapping settings");
3121
3122         prop = RNA_def_property(srna, "color_mapping", PROP_POINTER, PROP_NONE);
3123         RNA_def_property_pointer_sdna(prop, NULL, "base.color_mapping");
3124         RNA_def_property_flag(prop, PROP_NEVER_NULL);
3125         RNA_def_property_ui_text(prop, "Color Mapping", "Color mapping settings");
3126 }
3127
3128 static void def_sh_tex_sky(StructRNA *srna)
3129 {
3130         PropertyRNA *prop;
3131         
3132         RNA_def_struct_sdna_from(srna, "NodeTexSky", "storage");
3133         def_sh_tex(srna);
3134         
3135         prop = RNA_def_property(srna, "sun_direction", PROP_FLOAT, PROP_DIRECTION);
3136         RNA_def_property_ui_text(prop, "Sun Direction", "Direction from where the sun is shining");
3137         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3138         
3139         prop = RNA_def_property(srna, "turbidity", PROP_FLOAT, PROP_NONE);
3140         RNA_def_property_range(prop, 1.0f, 30.0f);
3141         RNA_def_property_ui_text(prop, "Turbidity", "Atmospheric turbidity");
3142         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
3143 }
3144
3145 static void def_sh_tex_environment(StructRNA *srna)
3146 {
3147         static const EnumPropertyItem prop_color_space_items[] = {
3148                 {SHD_COLORSPACE_COLOR, "COLOR", 0, "Color",
3149                                        "Image contains color data, and will be converted to linear color for rendering"},
3150                 {SHD_COLORSPACE_NONE, "NONE", 0, "Non-Color Data",
3151                                       "Image contains non-color data, for example a displacement or normal map, "
3152                                       "and will not be converted"},
3153                 {0, NULL, 0, NULL, NULL}
3154         };
3155
3156         static const EnumPropertyItem prop_projection_items[] = {
3157                 {SHD_PROJ_EQUIRECTANGULAR, "EQUIRECTANGULAR", 0, "Equirectangular",
3158                                            "Equirectangular or latitude-longitude projection"},
3159                 {SHD_PROJ_MIRROR_BALL, "MIRROR_BALL", 0, "Mirror Ball",
3160                                        "Projection from an orthographic photo of a mirror ball"},
3161                 {0, NULL, 0, NULL, NULL}
3162         };
3163         
3164         PropertyRNA *prop;
3165
3166         prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
3167         RNA_def_property_pointer_sdna(prop, NULL, "id");
3168         RNA_def_property_struct_type(prop, "Image");
3169         RNA_def_property_flag(prop, PROP_EDITABLE);
3170         RNA_def_property_ui_text(prop, "Image", "");
3171         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_tex_image_update");
3172
3173         RNA_def_struct_sdna_from(srna, "NodeTexEnvironment", "storage");
3174         def_sh_tex(srna);
3175
3176         prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
3177         RNA_def_property_enum_items(prop, prop_color_space_items);
3178         RNA_def_property_ui_text(prop, "Color Space", "Image file color space");
3179         RNA_def_property_update(prop, 0, "rna_Node_update");
3180
3181         prop = RNA_def_property(srna, "projection", PROP_ENUM, PROP_NONE);
3182         RNA_def_property_enum_items(prop, prop_projection_items);
3183         RNA_def_property_ui_text(prop, "Projection", "Projection of the input image");
3184         RNA_def_property_update(prop, 0, "rna_Node_update");
3185
3186         prop = RNA_def_property(srna, "image_user", PROP_POINTER, PROP_NONE);
3187         RNA_def_property_flag(prop, PROP_NEVER_NULL);
3188         RNA_def_property_pointer_sdna(prop, NULL, "iuser");
3189         RNA_def_property_ui_text(prop, "Image User",
3190                                  "Parameters defining which layer, pass and frame of the image is displayed");
3191         RNA_def_property_update(prop, 0, "rna_Node_update");
3192 }
3193
3194 static void def_sh_tex_image(StructRNA *srna)
3195 {
3196         static const EnumPropertyItem prop_color_space_items[] = {
3197                 {SHD_COLORSPACE_COLOR, "COLOR", 0, "Color",
3198                                        "Image contains color data, and will be converted to linear color for rendering"},
3199                 {SHD_COLORSPACE_NONE, "NONE", 0, "Non-Color Data",
3200                                       "Image contains non-color data, for example a displacement or normal map, "
3201                                       "and will not be converted"},
3202                 {0, NULL, 0, NULL, NULL}
3203         };
3204
3205         static const EnumPropertyItem prop_projection_items[] = {
3206                 {SHD_PROJ_FLAT, "FLAT", 0, "Flat",
3207                                 "Image is projected flat using the X and Y coordinates of the texture vector"},
3208                 {SHD_PROJ_BOX,  "BOX", 0, "Box",
3209                                 "Image is projected using different components for each side of the object space bounding box"},
3210                 {0, NULL, 0, NULL, NULL}
3211         };
3212
3213
3214         PropertyRNA *prop;
3215
3216         prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
3217         RNA_def_property_pointer_sdna(prop, NULL, "id");
3218         RNA_def_property_struct_type(prop, "Image");
3219         RNA_def_property_flag(prop, PROP_EDITABLE);
3220         RNA_def_property_ui_text(prop, "Image", "");
3221         RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_tex_image_update");
3222
3223         RNA_def_struct_sdna_from(srna, "NodeTexImage", "storage");
3224         def_sh_tex(srna);
3225
3226         prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
3227         RNA_def_property_enum_items(prop, prop_color_space_items);
3228         RNA_def_property_ui_text(prop, "Color Space", "Image file color space");
3229         RNA_def_property_update(prop, 0, "rna_Node_update");
3230
3231         prop = RNA_def_property(srna, "projection", PROP_ENUM, PROP_NONE);
3232         RNA_def_property_enum_items(prop, prop_projection_items);
3233         RNA_def_property_ui_text(prop, "Projection", "Method to project 2D image on object with a 3D texture vector");
3234         RNA_def_property_update(prop, 0, "rna_Node_update");
3235
3236         prop = RNA_def_property(srna, "projection_blend", PROP_FLOAT, PROP_FACTOR);
3237         RNA_def_property_ui_text(prop, "Projection Blend", "For box projection, amount of blend to use between sides");
3238         RNA_def_property_update(prop, 0, "rna_Node_update");
3239
3240         prop = RNA_def_property(srna, "image_user", PROP_POINTER, PROP_NONE);
3241         RNA_def_property_flag(prop, PROP_NEVER_NULL);
3242         RNA_def_property_pointer_sdna(prop, NULL, "iuser");
3243         RNA_def_property_ui_text(prop, "Image User",
3244                                  "Parameters defining which layer, pass and frame of the image is displayed");
3245         RNA_def_property_update(prop, 0, "rna_Node_update");
3246 }
3247
3248 static void def_sh_tex_gradient(StructRNA *srna)
3249 {
3250         static EnumPropertyItem prop_gradient_type[] = {
3251                 {SHD_BLEND_LINEAR, "LINEAR", 0, "Linear", "Create a linear progression"},
3252                 {SHD_BLEND_QUADRATIC, "QUADRATIC", 0, "Quadratic", "Create a quadratic progression"},
3253                 {SHD_BLEND_EASING, "EASING", 0, "Easing", "Create a progression easing from one step to the next"},
3254                 {SHD_BLEND_DIAGONAL, "DIAGONAL", 0, "Diagonal", "Create a diagonal progression"},
3255                 {SHD_BLEND_SPHERICAL, "SPHERICAL", 0, "Spherical", "Create a spherical progression"},
3256                 {SHD_BLEND_QUADRATIC_SPHERE, "QUADRATIC_SPHERE", 0, "Quadratic sphere",
3257                                              "Create a quadratic progression in the shape of a sphere"},
3258                 {SHD_BLEND_RADIAL, "RADIAL", 0, "Radial", "Create a radial progression"},
3259                 {0, NULL, 0, NULL, NULL}
3260         };
3261
3262         PropertyRNA *prop;
3263         
3264         RNA_def_struct_sdna_from(srna, "NodeTexGradient", "storage");
3265         def_sh_tex(srna);
3266
3267         prop = RNA_def_property(srna, "gradient_type", PROP_ENUM, PROP_NONE);
3268         RNA_def_property_enum_items(prop, prop_gradient_type);
3269         RNA_def_property_ui_text(prop, "Gradient Type", "Style of the color blending");
3270         RNA_def_property_update(prop, 0, "rna_Node_update");
3271 }
3272
3273 static void def_sh_tex_noise(StructRNA *srna)
3274 {
3275         RNA_def_struct_sdna_from(srna, "NodeTexNoise", "storage");
3276         def_sh_tex(srna);
3277 }
3278
3279 static void def_sh_tex_checker(StructRNA *srna)
3280 {
3281         RNA_def_struct_sdna_from(srna, "NodeTexChecker", "storage");
3282         def_sh_tex(srna);
3283 }
3284
3285 static void def_sh_tex_brick(StructRNA *srna)
3286 {
3287         PropertyRNA *prop;
3288         
3289         RNA_def_struct_sdna_from(srna, "NodeTexBrick", "storage");
3290         def_sh_tex(srna);
3291         
3292         prop = RNA_def_property(srna, "offset_frequency", PROP_INT, PROP_NONE);
3293         RNA_def_property_int_sdna(prop, NULL, "offset_freq");
3294         RNA_def_property_int_default(prop, 2);
3295         RNA_def_property_range(prop, 1, 99);
3296         RNA_def_property_ui_text(prop, "Offset Frequency", "");
3297         RNA_def_property_update(prop, 0, "rna_Node_update");
3298         
3299         prop = RNA_def_property(srna, "squash_frequency", PROP_INT, PROP_NONE);
3300         RNA_def_property_int_sdna(prop, NULL, "squash_freq");
3301         RNA_def_property_int_default(prop, 2);
3302         RNA_def_property_range(prop, 1, 99);
3303         RNA_def_property_ui_text(prop, "Squash Frequency", "");
3304         RNA_def_property_update(prop, 0, "rna_Node_update");
3305         
3306         prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
3307         RNA_def_property_float_sdna(prop, NULL, "offset");
3308         RNA_def_property_float_default(prop, 0.5f);
3309         RNA_def_property_range(prop, 0.0f, 1.0f);
3310         RNA_def_property_ui_text(prop, "Offset Amount", "");
3311         RNA_def_property_update(prop, 0, "rna_Node_update");
3312         
3313         prop = RNA_def_property(srna, "squash", PROP_FLOAT, PROP_NONE);
3314         RNA_def_property_float_sdna(prop, NULL, "squash");
3315         RNA_def_property_float_default(prop, 1.0f);
3316         RNA_def_property_range(prop, 0.0f, 99.0f);
3317         RNA_def_property_ui_text(prop, "Squash Amount", "");
3318         RNA_def_property_update(prop, 0, "rna_Node_update");
3319         
3320 }
3321
3322 static void def_sh_tex_magic(StructRNA *srna)
3323 {
3324         PropertyRNA *prop;
3325         
3326         RNA_def_struct_sdna_from(srna, "NodeTexMagic", "storage");
3327         def_sh_tex(srna);
3328
3329         prop = RNA_def_property(srna, "turbulence_depth", PROP_INT, PROP_NONE);
3330         RNA_def_property_int_sdna(prop, NULL, "depth");
3331         RNA_def_property_range(prop, 0, 10);
3332         RNA_def_property_ui_text(prop, "Depth", "Level of detail in the added turbulent noise");
3333         RNA_def_property_update(prop, 0, "rna_Node_update");
3334 }
3335
3336 static void def_sh_tex_musgrave(StructRNA *srna)
3337 {
3338         static EnumPropertyItem prop_musgrave_type[] = {
3339                 {SHD_MUSGRAVE_MULTIFRACTAL, "MULTIFRACTAL", 0, "Multifractal", ""},
3340                 {SHD_MUSGRAVE_RIDGED_MULTIFRACTAL, "RIDGED_MULTIFRACTAL", 0, "Ridged Multifractal", ""},
3341                 {SHD_MUSGRAVE_HYBRID_MULTIFRACTAL, "HYBRID_MULTIFRACTAL", 0, "Hybrid Multifractal", ""},
3342                 {SHD_MUSGRAVE_FBM, "FBM", 0, "fBM", ""},
3343                 {SHD_MUSGRAVE_HETERO_TERRAIN, "HETERO_TERRAIN", 0, "Hetero Terrain", ""},
3344                 {0, NULL, 0, NULL, NULL}
3345         };
3346
3347         PropertyRNA *prop;
3348         
3349         RNA_def_struct_sdna_from(srna, "NodeTexMusgrave", "storage");
3350         def_sh_tex(srna);
3351
3352         prop = RNA_def_property(srna, "musgrave_type", PROP_ENUM, PROP_NONE);
3353         RNA_def_property_enum_sdna(prop, NULL, "musgrave_type");
3354         RNA_def_property_enum_items(prop, prop_musgrave_type);
3355         RNA_def_property_ui_text(prop, "Type", "");
3356         RNA_def_property_update(prop, 0, "rna_Node_update");
3357 }
3358
3359 static void def_sh_tex_voronoi(StructRNA *srna)
3360 {
3361         static EnumPropertyItem prop_coloring_items[] = {
3362                 {SHD_VORONOI_INTENSITY, "INTENSITY", 0, "Intensity", "Only calculate intensity"},
3363                 {SHD_VORONOI_CELLS, "CELLS", 0, "Cells", "Color cells by position"},
3364                 {0, NULL, 0, NULL, NULL}
3365         };
3366
3367         PropertyRNA *prop;
3368         
3369         RNA_def_struct_sdna_from(srna, "NodeTexVoronoi", "storage");
3370         def_sh_tex(srna);
3371
3372         prop = RNA_def_property(srna, "coloring", PROP_ENUM, PROP_NONE);
3373         RNA_def_property_enum_sdna(prop, NULL, "coloring");
3374         RNA_def_property_enum_items(prop, prop_coloring_items);
3375         RNA_def_property_ui_text(prop, "Coloring", "");
3376         RNA_def_property_update(prop, 0, "rna_Node_update");
3377 }
3378
3379 static void def_sh_tex_wave(StructRNA *srna)
3380 {
3381         static EnumPropertyItem prop_wave_type_items[] = {
3382                 {SHD_WAVE_BANDS, "BANDS", 0, "Bands", "Use standard wave texture in bands"},
3383                 {SHD_WAVE_RINGS, "RINGS", 0, "Rings", "Use wave texture in rings"},
3384                 {0, NULL, 0, NULL, NULL}
3385         };
3386
3387         PropertyRNA *prop;
3388         
3389         RNA_def_struct_sdna_from(srna, "NodeTexWave", "storage");
3390         def_sh_tex(srna);
3391
3392         prop = RNA_def_property(srna, "wave_type", PROP_ENUM, PROP_NONE);
3393         RNA_def_property_enum_sdna(prop, NULL, "wave_type");
3394         RNA_def_property_enum_items(prop, prop_wave_type_items);
3395         RNA_def_property_ui_text(prop, "Wave Type", "");
3396         RNA_def_property_update(prop, 0, "rna_Node_update");
3397 }
3398
3399 static void def_sh_tex