Cleaned up the node wrapping code
[blender.git] / source / blender / makesrna / intern / rna_nodetree.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * Contributor(s): Blender Foundation (2008), Nathan Letwory, Robin Allen
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include "RNA_define.h"
29 #include "RNA_types.h"
30
31 #include "rna_internal.h"
32
33 #include "DNA_node_types.h"
34 #include "DNA_scene_types.h"
35 #include "DNA_texture_types.h"
36
37 #include "BKE_node.h"
38 #include "BKE_image.h"
39
40 #ifdef RNA_RUNTIME
41
42 StructRNA *rna_Node_refine(struct PointerRNA *ptr)
43 {
44         bNode *node = (bNode*)ptr->data;
45
46         switch(node->type) {
47                 
48                 #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
49                         case ID: return &RNA_##Category##StructName;
50                                 
51                 #include "rna_nodetree_types.h"
52                 
53                 #undef DefNode
54                 
55                 default:
56                         return &RNA_Node;
57         }
58 }
59
60 #else
61
62 #define MaxNodes 1000
63
64 enum
65 {
66         Category_NoCategory,
67         Category_ShaderNode,
68         Category_CompositorNode,
69         Category_TextureNode
70 };
71
72 typedef struct NodeInfo
73 {
74         int defined;
75         int category;
76         const char *enum_name;
77         const char *struct_name;
78         const char *base_name;
79         const char *ui_name;
80         const char *ui_desc;
81 } NodeInfo;
82
83 static NodeInfo nodes[MaxNodes];
84
85 static void reg_node(
86         int ID, 
87         int category,
88         const char *enum_name,
89         const char *struct_name,
90         const char *base_name,
91         const char *ui_name,
92         const char *ui_desc
93 ){
94         NodeInfo *ni = nodes + ID;
95         
96         ni->defined = 1;
97         ni->category = category;
98         ni->enum_name = enum_name;
99         ni->struct_name = struct_name;
100         ni->base_name = base_name;
101         ni->ui_name = ui_name;
102         ni->ui_desc = ui_desc;
103 }
104
105 static void init(void)
106 {
107         memset(nodes, 0, sizeof nodes);
108         
109         #define Str(x) #x
110         
111         #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
112                 reg_node(ID, Category_##Category, EnumName, Str(Category##StructName), #Category, UIName, UIDesc);
113                 
114         #include "rna_nodetree_types.h"
115         
116         #undef DefNode
117         #undef Str
118 }
119
120 static StructRNA* def_node(BlenderRNA *brna, int node_id)
121 {
122         StructRNA *srna;
123         NodeInfo *node = nodes + node_id;
124         
125         srna = RNA_def_struct(brna, node->struct_name, node->base_name);
126         RNA_def_struct_ui_text(srna, node->ui_name, node->ui_desc);
127         RNA_def_struct_sdna(srna, "bNode");
128         
129         return srna;
130 }
131
132 static EnumPropertyItem* alloc_node_type_items(int category)
133 {
134         int i;
135         int count = 2;
136         EnumPropertyItem *item, *items;
137         
138         for(i=0; i<MaxNodes; i++)
139                 if(nodes[i].defined && nodes[i].category == category)
140                         count++;
141                 
142         item = items = malloc(count * sizeof(EnumPropertyItem));
143         
144         for(i=0; i<MaxNodes; i++) {
145                 NodeInfo *node = nodes + i;
146                 if(node->defined && node->category == category) {
147                         item->value = i;
148                         item->identifier = node->enum_name;
149                         item->name = node->ui_name;
150                         item->description = node->ui_desc;
151                 
152                         item++;
153                 }
154         }
155         
156         item->value = NODE_DYNAMIC;
157         item->identifier = "SCRIPT";
158         item->name = "Script";
159         item->description = "";
160         
161         item++;
162         
163         memset(item, 0, sizeof(EnumPropertyItem));
164         
165         return items;
166 }
167
168
169 /* -- Common nodes ---------------------------------------------------------- */
170
171 static void def_math(StructRNA *srna)
172 {
173         PropertyRNA *prop;
174         
175         static EnumPropertyItem items[] = {
176                 { 0, "ADD",          "Add",          ""},
177                 { 1, "SUBTRACT",     "Subtract",     ""},
178                 { 2, "MULTIPLY",     "Multiply",     ""},
179                 { 3, "DIVIDE",       "Divide",       ""},
180                 { 4, "SINE",         "Sine",         ""},
181                 { 5, "COSINE",       "Cosine",       ""},
182                 { 6, "TANGENT",      "Tangent",      ""},
183                 { 7, "ARCSINE",      "Arcsine",      ""},
184                 { 8, "ARCCOSINE",    "Arccosine",    ""},
185                 { 9, "ARCTANGENT",   "Arctangent",   ""},
186                 {10, "POWER",        "Power",        ""},
187                 {11, "LOGARITHM",    "Logarithm",    ""},
188                 {12, "MINIMUM",      "Minimum",      ""},
189                 {13, "MAXIMUM",      "Maximum",      ""},
190                 {14, "ROUND",        "Round",        ""},
191                 {15, "LESS_THAN",    "Less Than",    ""},
192                 {16, "GREATER_THAN", "Greater Than", ""},
193                 
194                 {0, NULL, NULL, NULL}
195         };
196         
197         prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
198         RNA_def_property_enum_sdna(prop, NULL, "custom1");
199         RNA_def_property_enum_items(prop, items);
200         RNA_def_property_ui_text(prop, "Operation", "");
201 }
202
203 static void def_vector_math(StructRNA *srna)
204 {
205         PropertyRNA *prop;
206         
207         static EnumPropertyItem items[] = {
208                 {0, "ADD",           "Add",           ""},
209                 {1, "SUBTRACT",      "Subtract",      ""},
210                 {2, "AVERAGE",       "Average",       ""},
211                 {3, "DOT_PRODUCT",   "Dot Product",   ""},
212                 {4, "CROSS_PRODUCT", "Cross Product", ""},
213                 {5, "NORMALIZE",     "Normalize",     ""},
214                 
215                 {0, NULL, NULL, NULL}
216         };
217         
218         prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
219         RNA_def_property_enum_sdna(prop, NULL, "custom1");
220         RNA_def_property_enum_items(prop, items);
221         RNA_def_property_ui_text(prop, "Operation", "");
222 }
223
224 static void def_rgb_curve(StructRNA *srna)
225 {
226         PropertyRNA *prop;
227         
228         prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
229         RNA_def_property_pointer_sdna(prop, NULL, "storage");
230         RNA_def_property_struct_type(prop, "CurveMapping");
231         RNA_def_property_ui_text(prop, "Mapping", "");
232 }
233
234 static void def_vector_curve(StructRNA *srna)
235 {
236         PropertyRNA *prop;
237         
238         prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
239         RNA_def_property_pointer_sdna(prop, NULL, "storage");
240         RNA_def_property_struct_type(prop, "CurveMapping");
241         RNA_def_property_ui_text(prop, "Mapping", "");
242 }
243
244 static void def_time(StructRNA *srna)
245 {
246         PropertyRNA *prop;
247         
248         prop = RNA_def_property(srna, "curve", PROP_POINTER, PROP_NONE);
249         RNA_def_property_pointer_sdna(prop, NULL, "storage");
250         RNA_def_property_struct_type(prop, "CurveMapping");
251         RNA_def_property_ui_text(prop, "Curve", "");
252         
253         prop = RNA_def_property(srna, "start", PROP_INT, PROP_NONE);
254         RNA_def_property_int_sdna(prop, NULL, "custom1");
255         RNA_def_property_ui_text(prop, "Start Frame", "");
256         
257         prop = RNA_def_property(srna, "end", PROP_INT, PROP_NONE);
258         RNA_def_property_int_sdna(prop, NULL, "custom2");
259         RNA_def_property_ui_text(prop, "End Frame", "");
260 }
261
262 static void def_val_to_rgb(StructRNA *srna)
263 {
264         /*PropertyRNA *prop;*/
265         
266         /* TODO: uncomment when ColorBand is wrapped *//*
267         prop = RNA_def_property(srna, "color_band", PROP_POINTER, PROP_NONE);
268         RNA_def_property_pointer_sdna(prop, NULL, "storage");
269         RNA_def_property_struct_type(prop, "ColorBand");
270         RNA_def_property_ui_text(prop, "Color Band", "");*/
271 }
272
273 static void def_mix_rgb(StructRNA *srna)
274 {
275         PropertyRNA *prop;
276         
277         static EnumPropertyItem blend_type_items[] = {
278                 { 0, "MIX",        "Mix",         ""},
279                 { 1, "ADD",        "Add",         ""},
280                 { 3, "SUBTRACT",   "Subtract",    ""},
281                 { 2, "MULTIPLY",   "Multiply",    ""},
282                 { 4, "SCREEN",     "Screen",      ""},
283                 { 9, "OVERLAY",    "Overlay",     ""},
284                 { 5, "DIVIDE",     "Divide",      ""},
285                 { 6, "DIFFERENCE", "Difference",  ""},
286                 { 7, "DARKEN",     "Darken",      ""},
287                 { 8, "LIGHTEN",    "Lighten",     ""},
288                 {10, "DODGE",      "Dodge",       ""},
289                 {11, "BURN",       "Burn",        ""},
290                 {15, "COLOR",      "Color",       ""},
291                 {14, "VALUE",      "Value",       ""},
292                 {13, "SATURATION", "Saturation",  ""},
293                 {12, "HUE",        "Hue",         ""},
294                 {0, NULL, NULL, NULL}
295         };
296         
297         prop = RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
298         RNA_def_property_enum_sdna(prop, NULL, "custom1");
299         RNA_def_property_enum_items(prop, blend_type_items);
300         RNA_def_property_ui_text(prop, "Blend Type", "");
301         
302         prop = RNA_def_property(srna, "alpha", PROP_BOOLEAN, PROP_NONE);
303         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 1);
304         RNA_def_property_ui_text(prop, "Diffuse", "Include alpha of second input in this operation");
305 }
306
307 static void def_texture(StructRNA *srna)
308 {
309         PropertyRNA *prop;
310         
311         prop = RNA_def_property(srna, "texture", PROP_POINTER, PROP_NONE);
312         RNA_def_property_pointer_sdna(prop, NULL, "id");
313         RNA_def_property_struct_type(prop, "Texture");
314         RNA_def_property_flag(prop, PROP_EDITABLE);
315         RNA_def_property_ui_text(prop, "Texture", "");
316         
317         prop = RNA_def_property(srna, "node_output", PROP_INT, PROP_NONE);
318         RNA_def_property_int_sdna(prop, NULL, "custom1");
319         RNA_def_property_ui_text(prop, "Node Output", "For node-based textures, which output node to use");
320 }
321
322
323 /* -- Shader Nodes ---------------------------------------------------------- */
324
325 static void def_sh_material(StructRNA *srna)
326 {
327         PropertyRNA *prop;
328
329         prop = RNA_def_property(srna, "material", PROP_POINTER, PROP_NONE);
330         RNA_def_property_pointer_sdna(prop, NULL, "id");
331         RNA_def_property_struct_type(prop, "Material");
332         RNA_def_property_flag(prop, PROP_EDITABLE);
333         RNA_def_property_ui_text(prop, "Material", "");
334
335         prop = RNA_def_property(srna, "diffuse", PROP_BOOLEAN, PROP_NONE);
336         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_DIFF);
337         RNA_def_property_ui_text(prop, "Diffuse", "Material Node outputs Diffuse");
338
339         prop = RNA_def_property(srna, "specular", PROP_BOOLEAN, PROP_NONE);
340         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_SPEC);
341         RNA_def_property_ui_text(prop, "Specular", "Material Node outputs Specular");
342         
343         prop = RNA_def_property(srna, "invert_normal", PROP_BOOLEAN, PROP_NONE);
344         RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_NEG);
345         RNA_def_property_ui_text(prop, "Invert Normal", "Material Node uses inverted normal");
346 }
347
348 static void def_sh_mapping(StructRNA *srna)
349 {
350         PropertyRNA *prop;
351         
352         prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
353         RNA_def_property_pointer_sdna(prop, NULL, "storage");
354         RNA_def_property_struct_type(prop, "TexMapping");
355         RNA_def_property_ui_text(prop, "Mapping", "");
356 }
357
358 static void def_sh_geometry(StructRNA *srna)
359 {
360         PropertyRNA *prop;
361         
362         RNA_def_struct_sdna_from(srna, "NodeGeometry", "storage");
363         
364         prop = RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE);
365         RNA_def_property_string_sdna(prop, NULL, "uvname");
366         RNA_def_property_ui_text(prop, "UV Layer", "");
367         
368         prop = RNA_def_property(srna, "color_layer", PROP_STRING, PROP_NONE);
369         RNA_def_property_string_sdna(prop, NULL, "colname");
370         RNA_def_property_ui_text(prop, "Vertex Color Layer", "");
371 }
372
373
374 /* -- Compositor Nodes ------------------------------------------------------ */
375
376 static void def_cmp_alpha_over(StructRNA *srna)
377 {
378         PropertyRNA *prop;
379
380         prop = RNA_def_property(srna, "convert_premul", PROP_BOOLEAN, PROP_NONE);
381         RNA_def_property_boolean_sdna(prop, NULL, "custom1", 1);
382         RNA_def_property_ui_text(prop, "convert_premul", "TODO: don't know what this is");
383         
384         RNA_def_struct_sdna_from(srna, "NodeTwoFloats", "storage");
385         
386         prop = RNA_def_property(srna, "premul", PROP_FLOAT, PROP_NONE);
387         RNA_def_property_float_sdna(prop, NULL, "x");
388         RNA_def_property_ui_text(prop, "Premul", "Mix Factor");
389 }
390
391 static void def_cmp_blur(StructRNA *srna)
392 {
393         PropertyRNA *prop;
394         
395         static EnumPropertyItem filter_type_items[] = {
396                 {R_FILTER_BOX,        "FLAT",       "Flat",          ""},
397                 {R_FILTER_TENT,       "TENT",       "Tent",          ""},
398                 {R_FILTER_QUAD,       "QUAD",       "Quadratic",     ""},
399                 {R_FILTER_CUBIC,      "CUBIC",      "Cubic",         ""},
400                 {R_FILTER_GAUSS,      "GAUSS",      "Gaussian",      ""},
401                 {R_FILTER_FAST_GAUSS, "FAST_GAUSS", "Fast Gaussian", ""},
402                 {R_FILTER_CATROM,     "CATROM",     "Catrom",        ""},
403                 {R_FILTER_MITCH,      "MITCH",      "Mitch",         ""},
404                 {0, NULL, NULL, NULL}
405         };
406
407         RNA_def_struct_sdna_from(srna, "NodeBlurData", "storage");
408         
409         prop = RNA_def_property(srna, "sizex", PROP_INT, PROP_NONE);
410         RNA_def_property_int_sdna(prop, NULL, "sizex");
411         RNA_def_property_ui_text(prop, "Size X", "");
412         
413         prop = RNA_def_property(srna, "sizey", PROP_INT, PROP_NONE);
414         RNA_def_property_int_sdna(prop, NULL, "sizey");
415         RNA_def_property_ui_text(prop, "Size Y", "");
416         
417         prop = RNA_def_property(srna, "samples", PROP_INT, PROP_NONE);
418         RNA_def_property_int_sdna(prop, NULL, "samples");
419         RNA_def_property_ui_text(prop, "Samples", "");
420         
421         prop = RNA_def_property(srna, "max_speed", PROP_INT, PROP_NONE);
422         RNA_def_property_int_sdna(prop, NULL, "maxspeed");
423         RNA_def_property_ui_text(prop, "Max Speed", "");
424         
425         prop = RNA_def_property(srna, "min_speed", PROP_INT, PROP_NONE);
426         RNA_def_property_int_sdna(prop, NULL, "minspeed");
427         RNA_def_property_ui_text(prop, "Min Speed", "");
428         
429         prop = RNA_def_property(srna, "relative", PROP_BOOLEAN, PROP_NONE);
430         RNA_def_property_boolean_sdna(prop, NULL, "relative", 1);
431         RNA_def_property_ui_text(prop, "Relative", "");
432         
433         prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
434         RNA_def_property_float_sdna(prop, NULL, "fac");
435         RNA_def_property_ui_text(prop, "Factor", "");
436         
437         prop = RNA_def_property(srna, "factor_x", PROP_FLOAT, PROP_NONE);
438         RNA_def_property_float_sdna(prop, NULL, "percentx");
439         RNA_def_property_ui_text(prop, "Relative Size X", "");
440         
441         prop = RNA_def_property(srna, "factor_y", PROP_FLOAT, PROP_NONE);
442         RNA_def_property_float_sdna(prop, NULL, "percenty");
443         RNA_def_property_ui_text(prop, "Relative Size Y", "");
444         
445         prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
446         RNA_def_property_enum_sdna(prop, NULL, "filtertype");
447         RNA_def_property_enum_items(prop, filter_type_items);
448         RNA_def_property_ui_text(prop, "Filter Type", "");
449         
450         prop = RNA_def_property(srna, "bokeh", PROP_BOOLEAN, PROP_NONE);
451         RNA_def_property_boolean_sdna(prop, NULL, "bokeh", 1);
452         RNA_def_property_ui_text(prop, "Bokeh", "");
453         
454         prop = RNA_def_property(srna, "gamma", PROP_BOOLEAN, PROP_NONE);
455         RNA_def_property_boolean_sdna(prop, NULL, "gamma", 1);
456         RNA_def_property_ui_text(prop, "Gamma", "");
457         
458         /*
459                 TODO:
460                         curved
461                         image_in_width
462                         image_in_height
463                         
464                 Don't know if these need wrapping, can't find them in interface
465         */
466         
467 }
468
469 static void def_cmp_filter(StructRNA *srna)
470 {
471         PropertyRNA *prop;
472
473         static EnumPropertyItem type_items[] = {
474                 {0, "SOFTEN",  "Soften",  ""},
475                 {1, "SHARPEN", "Sharpen", ""},
476                 {2, "LAPLACE", "Laplace", ""},
477                 {3, "SOBEL",   "Sobel",   ""},
478                 {4, "PREWITT", "Prewitt", ""},
479                 {5, "KIRSCH",  "Kirsch",  ""},
480                 {6, "SHADOW",  "Shadow",  ""},
481                 {0, NULL, NULL, NULL}
482         };
483         
484         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
485         RNA_def_property_enum_sdna(prop, NULL, "custom1");
486         RNA_def_property_enum_items(prop, type_items);
487         RNA_def_property_ui_text(prop, "Type", "");
488 }
489
490 static void def_cmp_map_value(StructRNA *srna)
491 {
492         PropertyRNA *prop;
493         
494         RNA_def_struct_sdna_from(srna, "TexMapping", "storage");
495         
496         prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
497         RNA_def_property_float_sdna(prop, NULL, "loc");
498         RNA_def_property_ui_text(prop, "Offset", "");
499         
500         prop = RNA_def_property(srna, "size", PROP_FLOAT, PROP_NONE);
501         RNA_def_property_float_sdna(prop, NULL, "size");
502         RNA_def_property_ui_text(prop, "Size", "");
503         
504         prop = RNA_def_property(srna, "use_min", PROP_BOOLEAN, PROP_NONE);
505         RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MIN);
506         RNA_def_property_ui_text(prop, "Use Minimum", "");
507         
508         prop = RNA_def_property(srna, "use_max", PROP_BOOLEAN, PROP_NONE);
509         RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MAX);
510         RNA_def_property_ui_text(prop, "Use Maximum", "");
511         
512         prop = RNA_def_property(srna, "min", PROP_FLOAT, PROP_NONE);
513         RNA_def_property_float_sdna(prop, NULL, "min");
514         RNA_def_property_ui_text(prop, "Minimum", "");
515         
516         prop = RNA_def_property(srna, "max", PROP_FLOAT, PROP_NONE);
517         RNA_def_property_float_sdna(prop, NULL, "max");
518         RNA_def_property_ui_text(prop, "Maximum", "");
519 }
520
521 static void def_cmp_vector_blur(StructRNA *srna)
522 {
523         PropertyRNA *prop;
524         
525         RNA_def_struct_sdna_from(srna, "NodeBlurData", "storage");
526         
527         prop = RNA_def_property(srna, "samples", PROP_INT, PROP_NONE);
528         RNA_def_property_int_sdna(prop, NULL, "samples");
529         RNA_def_property_ui_text(prop, "Samples", "");
530         
531         prop = RNA_def_property(srna, "min_speed", PROP_INT, PROP_NONE);
532         RNA_def_property_int_sdna(prop, NULL, "minspeed");
533         RNA_def_property_ui_text(prop, "Min Speed", "Minimum speed for a pixel to be blurred; used to separate background from foreground");
534                 
535         prop = RNA_def_property(srna, "max_speed", PROP_INT, PROP_NONE);
536         RNA_def_property_int_sdna(prop, NULL, "maxspeed");
537         RNA_def_property_ui_text(prop, "Min Speed", "Maximum speed, or zero for none");
538         
539         prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
540         RNA_def_property_float_sdna(prop, NULL, "fac");
541         RNA_def_property_ui_text(prop, "Blur Factor", "Scaling factor for motion vectors; actually 'shutter speed' in frames");
542         
543         prop = RNA_def_property(srna, "curved", PROP_BOOLEAN, PROP_NONE);
544         RNA_def_property_boolean_sdna(prop, NULL, "curved", 1);
545         RNA_def_property_ui_text(prop, "Curved", "Interpolate between frames in a bezier curve, rather than linearly");
546 }
547
548 static void def_cmp_image(StructRNA *srna)
549 {
550         PropertyRNA *prop;
551         
552         static EnumPropertyItem type_items[] = {
553                 {IMA_SRC_FILE,      "IMAGE",     "Image",     ""},
554                 {IMA_SRC_MOVIE,     "MOVIE",     "Movie",     ""},
555                 {IMA_SRC_SEQUENCE,  "SEQUENCE",  "Sequence",  ""},
556                 {IMA_SRC_GENERATED, "GENERATED", "Generated", ""},
557                 {0, NULL, NULL, NULL}
558         };
559         
560         prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
561         RNA_def_property_pointer_sdna(prop, NULL, "id");
562         RNA_def_property_struct_type(prop, "Image");
563         RNA_def_property_flag(prop, PROP_EDITABLE);
564         RNA_def_property_ui_text(prop, "Image", "");
565         
566         RNA_def_struct_sdna_from(srna, "ImageUser", "storage");
567
568         /* TODO: if movie or sequence { */
569         
570         prop = RNA_def_property(srna, "frames", PROP_INT, PROP_NONE);
571         RNA_def_property_int_sdna(prop, NULL, "frames");
572         RNA_def_property_ui_text(prop, "Frames", "Number of images used in animation");
573         
574         prop = RNA_def_property(srna, "start", PROP_INT, PROP_NONE);
575         RNA_def_property_int_sdna(prop, NULL, "sfra");
576         RNA_def_property_ui_text(prop, "Start Frame", "");
577         
578         prop = RNA_def_property(srna, "offset", PROP_INT, PROP_NONE);
579         RNA_def_property_int_sdna(prop, NULL, "offset");
580         RNA_def_property_ui_text(prop, "Offset", "Offsets the number of the frame to use in the animation");
581         
582         prop = RNA_def_property(srna, "cyclic", PROP_BOOLEAN, PROP_NONE);
583         RNA_def_property_boolean_sdna(prop, NULL, "cycl", 1);
584         RNA_def_property_ui_text(prop, "Cyclic", "");
585         
586         prop = RNA_def_property(srna, "auto_refresh", PROP_BOOLEAN, PROP_NONE);
587         RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_ANIM_ALWAYS);
588         RNA_def_property_ui_text(prop, "Auto-Refresh", "");
589         
590         /* } */
591         
592         /* if type == multilayer { */
593         
594         prop = RNA_def_property(srna, "layer", PROP_INT, PROP_NONE);
595         RNA_def_property_int_sdna(prop, NULL, "layer");
596         RNA_def_property_ui_text(prop, "Layer", "");
597         
598         /* } */
599         
600         /* TODO: refresh on change */
601         
602 }
603
604 static void def_cmp_render_layers(StructRNA *srna)
605 {
606         PropertyRNA *prop;
607         
608         prop = RNA_def_property(srna, "scene", PROP_POINTER, PROP_NONE);
609         RNA_def_property_pointer_sdna(prop, NULL, "id");
610         RNA_def_property_struct_type(prop, "Scene");
611         RNA_def_property_flag(prop, PROP_EDITABLE);
612         RNA_def_property_ui_text(prop, "Scene", "");
613         
614         /* TODO: layers in menu */
615         prop = RNA_def_property(srna, "layer", PROP_INT, PROP_NONE);
616         RNA_def_property_int_sdna(prop, NULL, "custom1");
617         RNA_def_property_ui_text(prop, "Layer", "");
618         
619         /* TODO: comments indicate this might be a hack */
620         prop = RNA_def_property(srna, "re_render", PROP_BOOLEAN, PROP_NONE);
621         RNA_def_property_boolean_sdna(prop, NULL, "custom2", 1);
622         RNA_def_property_ui_text(prop, "Re-render", "");
623 }
624
625 static void def_cmp_output_file(StructRNA *srna)
626 {
627         PropertyRNA *prop;
628         
629         static EnumPropertyItem type_items[] = {
630                 {R_TARGA,   "TARGA",        "Targa",        ""},
631                 {R_RAWTGA,  "RAW_TARGA",    "Targa Raw",    ""},
632                 {R_PNG,     "PNG",          "PNG",          ""},
633                 {R_BMP,     "BMP",          "BMP",          ""},
634                 {R_JPEG90,  "JPEG",         "JPEG",         ""},
635                 {R_IRIS,    "IRIS",         "IRIS",         ""},
636                 {R_RADHDR,  "RADIANCE_HDR", "Radiance HDR", ""},
637                 {R_CINEON,  "CINEON",       "Cineon",       ""},
638                 {R_DPX,     "DPX",          "DPX",          ""},
639                 {R_OPENEXR, "OPENEXR",      "OpenEXR",      ""},
640                 {0, NULL, NULL, NULL}
641         };
642         
643         static EnumPropertyItem openexr_codec_items[] = {
644                 {0, "NONE",  "None",           ""},
645                 {1, "PXR24", "Pxr24 (lossy)",  ""},
646                 {2, "ZIP",   "ZIP (lossless)", ""},
647                 {3, "PIZ",   "PIX (lossless)", ""},
648                 {4, "RLE",   "RLE (lossless)", ""},
649                 {0, NULL, NULL, NULL}
650         };
651         
652         RNA_def_struct_sdna_from(srna, "NodeImageFile", "storage");
653         
654         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
655         RNA_def_property_string_sdna(prop, NULL, "name");
656         RNA_def_property_ui_text(prop, "Name", "");
657         
658         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
659         RNA_def_property_enum_sdna(prop, NULL, "imtype");
660         RNA_def_property_enum_items(prop, type_items);
661         RNA_def_property_ui_text(prop, "Type", "");
662         
663         /* TODO: openexr only { */
664         
665         prop = RNA_def_property(srna, "half", PROP_BOOLEAN, PROP_NONE);
666         RNA_def_property_boolean_sdna(prop, NULL, "subimtype", R_OPENEXR_HALF);
667         RNA_def_property_ui_text(prop, "Half", "");
668         
669         prop = RNA_def_property(srna, "codec", PROP_ENUM, PROP_NONE);
670         RNA_def_property_enum_sdna(prop, NULL, "codec");
671         RNA_def_property_enum_items(prop, openexr_codec_items);
672         RNA_def_property_ui_text(prop, "Codec", "");
673         
674         /* } else { */
675         
676         prop = RNA_def_property(srna, "quality", PROP_INT, PROP_NONE);
677         RNA_def_property_int_sdna(prop, NULL, "quality");
678         RNA_def_property_ui_text(prop, "Quality", "");
679         
680         /* } */
681         
682         prop = RNA_def_property(srna, "start", PROP_INT, PROP_NONE);
683         RNA_def_property_int_sdna(prop, NULL, "sfra");
684         RNA_def_property_ui_text(prop, "Start Frame", "");
685         
686         prop = RNA_def_property(srna, "end", PROP_INT, PROP_NONE);
687         RNA_def_property_int_sdna(prop, NULL, "efra");
688         RNA_def_property_ui_text(prop, "End Frame", "");
689 }
690
691 static void def_cmp_dilate_erode(StructRNA *srna)
692 {
693         PropertyRNA *prop;
694         
695         prop = RNA_def_property(srna, "distance", PROP_INT, PROP_NONE);
696         RNA_def_property_int_sdna(prop, NULL, "custom2");
697         RNA_def_property_ui_text(prop, "Distance", "Distance to grow/shrink (number of iterations)");
698 }
699
700 static void def_cmp_scale(StructRNA *srna)
701 {
702         PropertyRNA *prop;
703         
704         static EnumPropertyItem space_items[] = {
705                 {0, "RELATIVE",   "Relative",   ""},
706                 {1, "ABSOLUTE",   "Absolute",   ""},
707                 {2, "SCENE_SIZE", "Scene Size", ""},
708                 {0, NULL, NULL, NULL}
709         };
710         
711         prop = RNA_def_property(srna, "space", PROP_ENUM, PROP_NONE);
712         RNA_def_property_enum_sdna(prop, NULL, "custom1");
713         RNA_def_property_enum_items(prop, space_items);
714         RNA_def_property_ui_text(prop, "Space", "Coordinate space to scale relative to");
715 }
716
717 static void def_cmp_diff_matte(StructRNA *srna)
718 {
719         PropertyRNA *prop;
720         
721         static EnumPropertyItem color_space_items[] = {
722                 {1, "RGB", "RGB",   ""},
723                 {2, "HSV", "HSV",   ""},
724                 {3, "YUV", "YUV",   ""},
725                 {4, "YCC", "YCbCr", ""},
726                 {0, NULL, NULL, NULL}
727         };
728         
729         prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
730         RNA_def_property_enum_sdna(prop, NULL, "custom1");
731         RNA_def_property_enum_items(prop, color_space_items);
732         RNA_def_property_ui_text(prop, "Color Space", "");
733         
734         RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
735         
736         /* TODO: nicer wrapping for tolerances */
737         
738         prop = RNA_def_property(srna, "tolerance1", PROP_FLOAT, PROP_NONE);
739         RNA_def_property_float_sdna(prop, NULL, "t1");
740         RNA_def_property_ui_text(prop, "Channel 1 Tolerance", "");
741         
742         prop = RNA_def_property(srna, "tolerance2", PROP_FLOAT, PROP_NONE);
743         RNA_def_property_float_sdna(prop, NULL, "t2");
744         RNA_def_property_ui_text(prop, "Channel 2 Tolerance", "");
745         
746         prop = RNA_def_property(srna, "tolerance3", PROP_FLOAT, PROP_NONE);
747         RNA_def_property_float_sdna(prop, NULL, "t3");
748         RNA_def_property_ui_text(prop, "Channel 3 Tolerance", "");
749         
750         prop = RNA_def_property(srna, "falloff", PROP_FLOAT, PROP_NONE);
751         RNA_def_property_float_sdna(prop, NULL, "fstrength");
752         RNA_def_property_ui_text(prop, "Falloff", "");
753 }
754
755 static void def_cmp_color_spill(StructRNA *srna)
756 {
757         PropertyRNA *prop;
758         
759         static EnumPropertyItem channel_items[] = {
760                 {1, "R", "Red",   ""},
761                 {2, "G", "Green", ""},
762                 {3, "B", "Blue",  ""},
763                 {0, NULL, NULL, NULL}
764         };
765         
766         prop = RNA_def_property(srna, "channel", PROP_ENUM, PROP_NONE);
767         RNA_def_property_enum_sdna(prop, NULL, "custom1");
768         RNA_def_property_enum_items(prop, channel_items);
769         RNA_def_property_ui_text(prop, "Channel", "");
770         
771         RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
772         
773         prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
774         RNA_def_property_float_sdna(prop, NULL, "t1");
775         RNA_def_property_ui_text(prop, "Amount", "How much the selected channel is affected by");
776 }
777
778 static void def_cmp_chroma(StructRNA *srna)
779 {
780         PropertyRNA *prop;
781         
782         RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
783         
784         prop = RNA_def_property(srna, "acceptance", PROP_FLOAT, PROP_NONE);
785         RNA_def_property_float_sdna(prop, NULL, "t1");
786         RNA_def_property_ui_text(prop, "Acceptance", "Tolerance for a color to be considered a keying color");
787         
788         prop = RNA_def_property(srna, "cutoff", PROP_FLOAT, PROP_NONE);
789         RNA_def_property_float_sdna(prop, NULL, "t2");
790         RNA_def_property_ui_text(prop, "Cutoff", "Tolerance below which colors will be considered as exact matches");
791
792         prop = RNA_def_property(srna, "lift", PROP_FLOAT, PROP_NONE);
793         RNA_def_property_float_sdna(prop, NULL, "fsize");
794         RNA_def_property_ui_text(prop, "Lift", "Alpha lift");
795         
796         prop = RNA_def_property(srna, "gain", PROP_FLOAT, PROP_NONE);
797         RNA_def_property_float_sdna(prop, NULL, "fstrength");
798         RNA_def_property_ui_text(prop, "Gain", "Alpha gain");
799         
800         prop = RNA_def_property(srna, "shadow_adjust", PROP_FLOAT, PROP_NONE);
801         RNA_def_property_float_sdna(prop, NULL, "t3");
802         RNA_def_property_ui_text(prop, "Shadow Adjust", "Adjusts the brightness of any shadows captured");
803         
804         /* TODO: 
805                 if(c->t2 > c->t1)
806                         c->t2=c->t1;
807         */
808 }
809
810 static void def_cmp_channel_matte(StructRNA *srna)
811 {
812         PropertyRNA *prop;
813         
814         static EnumPropertyItem color_space_items[] = {
815                 {1, "RGB", "RGB",   ""},
816                 {2, "HSV", "HSV",   ""},
817                 {3, "YUV", "YUV",   ""},
818                 {4, "YCC", "YCbCr", ""},
819                 {0, NULL, NULL, NULL}
820         };
821         
822         prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
823         RNA_def_property_enum_sdna(prop, NULL, "custom1");
824         RNA_def_property_enum_items(prop, color_space_items);
825         RNA_def_property_ui_text(prop, "Color Space", "");
826         
827         /* TODO: channel must be 1, 2 or 3 */
828         prop = RNA_def_property(srna, "channel", PROP_INT, PROP_NONE);
829         RNA_def_property_int_sdna(prop, NULL, "custom2");
830         RNA_def_property_ui_text(prop, "Channel", "");
831         
832         RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
833         
834         prop = RNA_def_property(srna, "high", PROP_FLOAT, PROP_NONE);
835         RNA_def_property_float_sdna(prop, NULL, "t1");
836         RNA_def_property_ui_text(prop, "High", "Values higher than this setting are 100% opaque");
837         
838         prop = RNA_def_property(srna, "low", PROP_FLOAT, PROP_NONE);
839         RNA_def_property_float_sdna(prop, NULL, "t2");
840         RNA_def_property_ui_text(prop, "Low", "Values lower than this setting are 100% keyed");
841         
842         /* TODO:
843                 if(c->t2 > c->t1)
844                         c->t2=c->t1;
845         */
846 }
847
848 static void def_cmp_flip(StructRNA *srna)
849 {
850         PropertyRNA *prop;
851         
852         static EnumPropertyItem axis_items[] = {
853                 {0, "X",  "X",     ""},
854                 {1, "Y",  "Y",     ""},
855                 {2, "XY", "X & Y", ""},
856                 {0, NULL, NULL, NULL}
857         };
858         
859         prop = RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE);
860         RNA_def_property_enum_sdna(prop, NULL, "custom1");
861         RNA_def_property_enum_items(prop, axis_items);
862         RNA_def_property_ui_text(prop, "Axis", "");
863 }
864
865 static void def_cmp_splitviewer(StructRNA *srna)
866 {
867         PropertyRNA *prop;
868         
869         static EnumPropertyItem axis_items[] = {
870                 {0, "X",  "X",     ""},
871                 {1, "Y",  "Y",     ""},
872                 {0, NULL, NULL, NULL}
873         };
874         
875         prop = RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE);
876         RNA_def_property_enum_sdna(prop, NULL, "custom2");
877         RNA_def_property_enum_items(prop, axis_items);
878         RNA_def_property_ui_text(prop, "Axis", "");
879         
880         /* TODO: percentage */
881         prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
882         RNA_def_property_float_sdna(prop, NULL, "custom1");
883         RNA_def_property_ui_text(prop, "Factor", "");
884 }
885
886 static void def_cmp_id_mask(StructRNA *srna)
887 {
888         PropertyRNA *prop;
889         
890         prop = RNA_def_property(srna, "index", PROP_INT, PROP_NONE);
891         RNA_def_property_int_sdna(prop, NULL, "custom1");
892         RNA_def_property_ui_text(prop, "Index", "Pass index number to convert to alpha");
893 }
894
895 static void def_cmp_map_uv(StructRNA *srna)
896 {
897         PropertyRNA *prop;
898         
899         /* TODO: percentage */
900         prop = RNA_def_property(srna, "alpha", PROP_INT, PROP_NONE);
901         RNA_def_property_int_sdna(prop, NULL, "custom1");
902         RNA_def_property_ui_text(prop, "Alpha", "");
903 }
904
905 static void def_cmp_defocus(StructRNA *srna)
906 {
907         PropertyRNA *prop;
908         
909         static EnumPropertyItem bokeh_items[] = {
910                 {8, "OCTAGON",  "Octagonal",  "8 sides"},
911                 {7, "HEPTAGON", "Heptagonal", "7 sides"},
912                 {6, "HEXAGON",  "Hexagonal",  "6 sides"},
913                 {5, "PENTAGON", "Pentagonal", "5 sides"},
914                 {4, "SQUARE",   "Square",     "4 sides"},
915                 {3, "TRIANGLE", "Triangular", "3 sides"},
916                 {0, "CIRCLE",   "Circular",   ""},
917                 {0, NULL, NULL, NULL}
918         };
919         
920         RNA_def_struct_sdna_from(srna, "NodeDefocus", "storage");
921         
922         prop = RNA_def_property(srna, "bokeh", PROP_ENUM, PROP_NONE);
923         RNA_def_property_enum_sdna(prop, NULL, "bktype");
924         RNA_def_property_enum_items(prop, bokeh_items);
925         RNA_def_property_ui_text(prop, "Bokeh Type", "");
926
927         /* TODO: angle in degrees */            
928         prop = RNA_def_property(srna, "angle", PROP_INT, PROP_NONE);
929         RNA_def_property_int_sdna(prop, NULL, "rotation");
930         RNA_def_property_ui_text(prop, "Angle", "Bokeh shape rotation offset in degrees");
931         
932         prop = RNA_def_property(srna, "gamma_correction", PROP_BOOLEAN, PROP_NONE);
933         RNA_def_property_boolean_sdna(prop, NULL, "gamco", 1);
934         RNA_def_property_ui_text(prop, "Gamma Correction", "Enable gamma correction before and after main process");
935
936         /* TODO */
937         prop = RNA_def_property(srna, "f_stop", PROP_FLOAT, PROP_NONE);
938         RNA_def_property_float_sdna(prop, NULL, "fstop");
939         RNA_def_property_ui_text(prop, "fStop", "Amount of focal blur, 128=infinity=perfect focus, half the value doubles the blur radius");
940         
941         prop = RNA_def_property(srna, "max_blur", PROP_FLOAT, PROP_NONE);
942         RNA_def_property_float_sdna(prop, NULL, "maxblur");
943         RNA_def_property_ui_text(prop, "Max Blur", "blur limit, maximum CoC radius, 0=no limit");
944         
945         prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_NONE);
946         RNA_def_property_float_sdna(prop, NULL, "bthresh");
947         RNA_def_property_ui_text(prop, "Threshold", "CoC radius threshold, prevents background bleed on in-focus midground, 0=off");
948         
949         prop = RNA_def_property(srna, "preview", PROP_BOOLEAN, PROP_NONE);
950         RNA_def_property_boolean_sdna(prop, NULL, "preview", 1);
951         RNA_def_property_ui_text(prop, "Preview", "Enable sampling mode, useful for preview when using low samplecounts");
952         
953         prop = RNA_def_property(srna, "samples", PROP_INT, PROP_NONE);
954         RNA_def_property_int_sdna(prop, NULL, "samples");
955         RNA_def_property_ui_text(prop, "Samples", "Number of samples (16=grainy, higher=less noise)");
956         
957         prop = RNA_def_property(srna, "use_zbuffer", PROP_BOOLEAN, PROP_NONE);
958         RNA_def_property_boolean_sdna(prop, NULL, "no_zbuf", 1);
959         RNA_def_property_ui_text(prop, "Use Z-Buffer", "Disable when using an image as input instead of actual zbuffer (auto enabled if node not image based, eg. time node)");
960         
961         prop = RNA_def_property(srna, "z_scale", PROP_FLOAT, PROP_NONE);
962         RNA_def_property_float_sdna(prop, NULL, "scale");
963         RNA_def_property_ui_text(prop, "Z-Scale", "Scales the Z input when not using a zbuffer, controls maximum blur designated by the color white or input value 1");
964 }
965
966 static void def_cmp_luma_matte(StructRNA *srna)
967 {
968         PropertyRNA *prop;
969         
970         RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
971         
972         prop = RNA_def_property(srna, "high", PROP_FLOAT, PROP_NONE);
973         RNA_def_property_float_sdna(prop, NULL, "t1");
974         RNA_def_property_ui_text(prop, "High", "Values higher than this setting are 100% opaque");
975         
976         prop = RNA_def_property(srna, "low", PROP_FLOAT, PROP_NONE);
977         RNA_def_property_float_sdna(prop, NULL, "t2");
978         RNA_def_property_ui_text(prop, "Low", "Values lower than this setting are 100% keyed");
979         
980         /* TODO: keep low less than high */
981         
982 }
983
984 static void def_cmp_invert(StructRNA *srna)
985 {
986         PropertyRNA *prop;
987         
988         prop = RNA_def_property(srna, "rgb", PROP_BOOLEAN, PROP_NONE);
989         RNA_def_property_boolean_sdna(prop, NULL, "custom1", CMP_CHAN_RGB);
990         RNA_def_property_ui_text(prop, "RGB", "");
991         
992         prop = RNA_def_property(srna, "alpha", PROP_BOOLEAN, PROP_NONE);
993         RNA_def_property_boolean_sdna(prop, NULL, "custom1", CMP_CHAN_A);
994         RNA_def_property_ui_text(prop, "Alpha", "");
995 }
996
997 static void def_cmp_crop(StructRNA *srna)
998 {
999         PropertyRNA *prop;
1000         
1001         prop = RNA_def_property(srna, "crop_size", PROP_BOOLEAN, PROP_NONE);
1002         RNA_def_property_boolean_sdna(prop, NULL, "custom1", 1);
1003         RNA_def_property_ui_text(prop, "Crop Image Size", "Whether to crop the size of the input image");
1004         
1005         RNA_def_struct_sdna_from(srna, "NodeTwoXYs", "storage");
1006
1007         prop = RNA_def_property(srna, "x1", PROP_INT, PROP_NONE);
1008         RNA_def_property_int_sdna(prop, NULL, "x1");
1009         RNA_def_property_ui_text(prop, "X1", "");
1010         
1011         prop = RNA_def_property(srna, "x2", PROP_INT, PROP_NONE);
1012         RNA_def_property_int_sdna(prop, NULL, "x2");
1013         RNA_def_property_ui_text(prop, "X2", "");
1014         
1015         prop = RNA_def_property(srna, "y1", PROP_INT, PROP_NONE);
1016         RNA_def_property_int_sdna(prop, NULL, "y1");
1017         RNA_def_property_ui_text(prop, "Y1", "");
1018         
1019         prop = RNA_def_property(srna, "y2", PROP_INT, PROP_NONE);
1020         RNA_def_property_int_sdna(prop, NULL, "y2");
1021         RNA_def_property_ui_text(prop, "Y2", "");
1022 }
1023
1024 static void def_cmp_dblur(StructRNA *srna)
1025 {
1026         PropertyRNA *prop;
1027         
1028         RNA_def_struct_sdna_from(srna, "NodeDBlurData", "storage");
1029         
1030         prop = RNA_def_property(srna, "iterations", PROP_INT, PROP_NONE);
1031         RNA_def_property_int_sdna(prop, NULL, "iter");
1032         RNA_def_property_ui_text(prop, "Iterations", "");
1033         
1034         prop = RNA_def_property(srna, "wrap", PROP_BOOLEAN, PROP_NONE);
1035         RNA_def_property_boolean_sdna(prop, NULL, "wrap", 1);
1036         RNA_def_property_ui_text(prop, "Wrap", "");
1037         
1038         prop = RNA_def_property(srna, "center_x", PROP_FLOAT, PROP_NONE);
1039         RNA_def_property_float_sdna(prop, NULL, "center_x");
1040         RNA_def_property_ui_text(prop, "Center X", "");
1041         
1042         prop = RNA_def_property(srna, "center_y", PROP_FLOAT, PROP_NONE);
1043         RNA_def_property_float_sdna(prop, NULL, "center_y");
1044         RNA_def_property_ui_text(prop, "Center Y", "");
1045         
1046         prop = RNA_def_property(srna, "distance", PROP_FLOAT, PROP_NONE);
1047         RNA_def_property_float_sdna(prop, NULL, "distance");
1048         RNA_def_property_ui_text(prop, "Distance", "");
1049         
1050         prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_NONE);
1051         RNA_def_property_float_sdna(prop, NULL, "angle");
1052         RNA_def_property_ui_text(prop, "Angle", "");
1053         
1054         prop = RNA_def_property(srna, "spin", PROP_FLOAT, PROP_NONE);
1055         RNA_def_property_float_sdna(prop, NULL, "spin");
1056         RNA_def_property_ui_text(prop, "Spin", "");
1057         
1058         prop = RNA_def_property(srna, "zoom", PROP_FLOAT, PROP_NONE);
1059         RNA_def_property_float_sdna(prop, NULL, "zoom");
1060         RNA_def_property_ui_text(prop, "Zoom", "");
1061 }
1062
1063 static void def_cmp_bilateral_blur(StructRNA *srna)
1064 {
1065         PropertyRNA *prop;
1066         
1067         RNA_def_struct_sdna_from(srna, "NodeBilateralBlurData", "storage");
1068         
1069         prop = RNA_def_property(srna, "iterations", PROP_INT, PROP_NONE);
1070         RNA_def_property_int_sdna(prop, NULL, "iter");
1071         RNA_def_property_ui_text(prop, "Iterations", "");
1072         
1073         prop = RNA_def_property(srna, "sigma_color", PROP_FLOAT, PROP_NONE);
1074         RNA_def_property_float_sdna(prop, NULL, "sigma_color");
1075         RNA_def_property_ui_text(prop, "Color Sigma", "");
1076         
1077         prop = RNA_def_property(srna, "sigma_space", PROP_FLOAT, PROP_NONE);
1078         RNA_def_property_float_sdna(prop, NULL, "sigma_space");
1079         RNA_def_property_ui_text(prop, "Space Sigma", "");
1080         
1081 }
1082
1083 static void def_cmp_premul_key(StructRNA *srna)
1084 {
1085         PropertyRNA *prop;
1086         
1087         static EnumPropertyItem type_items[] = {
1088                 {0, "KEY_TO_PREMUL", "Key to Premul", ""},
1089                 {1, "PREMUL_TO_KEY", "Premul to Key", ""},
1090                 {0, NULL, NULL, NULL}
1091         };
1092         
1093         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1094         RNA_def_property_enum_sdna(prop, NULL, "custom1");
1095         RNA_def_property_enum_items(prop, type_items);
1096         RNA_def_property_ui_text(prop, "Blend Type", "Conversion between premultiplied alpha and key alpha");
1097         
1098 }
1099
1100 static void def_cmp_glare(StructRNA *srna)
1101 {
1102         PropertyRNA *prop;
1103         
1104         static EnumPropertyItem type_items[] = {
1105                 {3, "GHOSTS",      "Ghosts",      ""},
1106                 {2, "STREAKS",     "Streaks",     ""},
1107                 {1, "FOG_GLOW",    "Fog Glow",    ""},
1108                 {0, "SIMPLE_STAR", "Simple Star", ""},
1109                 {0, NULL, NULL, NULL}
1110         };
1111         
1112         static EnumPropertyItem quality_items[] = {
1113                 {0, "HIGH",   "High",   ""},
1114                 {1, "MEDIUM", "Medium", ""},
1115                 {2, "LOW",    "Low",    ""},
1116                 {0, NULL, NULL, NULL}
1117         };
1118         
1119         RNA_def_struct_sdna_from(srna, "NodeGlare", "storage");
1120         
1121         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1122         RNA_def_property_enum_sdna(prop, NULL, "type");
1123         RNA_def_property_enum_items(prop, type_items);
1124         RNA_def_property_ui_text(prop, "Type", "");
1125         
1126         prop = RNA_def_property(srna, "quality", PROP_ENUM, PROP_NONE);
1127         RNA_def_property_enum_sdna(prop, NULL, "quality");
1128         RNA_def_property_enum_items(prop, type_items);
1129         RNA_def_property_ui_text(prop, "Quality", "If not set to high quality, the effect will be applied to a low-res copy of the source image");
1130         
1131         prop = RNA_def_property(srna, "iterations", PROP_INT, PROP_NONE);
1132         RNA_def_property_int_sdna(prop, NULL, "iter");
1133         RNA_def_property_ui_text(prop, "Iterations", "");
1134         
1135         prop = RNA_def_property(srna, "color_modulation", PROP_FLOAT, PROP_NONE);
1136         RNA_def_property_float_sdna(prop, NULL, "colmod");
1137         RNA_def_property_ui_text(prop, "Color Modulation", "");
1138         
1139         prop = RNA_def_property(srna, "mix", PROP_FLOAT, PROP_NONE);
1140         RNA_def_property_float_sdna(prop, NULL, "mix");
1141         RNA_def_property_ui_text(prop, "Mix", "-1 is original image only, 0 is exact 50/50 mix, 1 is processed image only");
1142         
1143         prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_NONE);
1144         RNA_def_property_float_sdna(prop, NULL, "threshold");
1145         RNA_def_property_ui_text(prop, "Threshold", "The glare filter will only be applied to pixels brighter than this value");
1146         
1147         prop = RNA_def_property(srna, "streaks", PROP_INT, PROP_NONE);
1148         RNA_def_property_int_sdna(prop, NULL, "angle");
1149         RNA_def_property_ui_text(prop, "Streaks", "Total number of streaks");
1150         
1151         prop = RNA_def_property(srna, "angle_offset", PROP_FLOAT, PROP_NONE);
1152         RNA_def_property_float_sdna(prop, NULL, "angle_ofs");
1153         RNA_def_property_ui_text(prop, "Angle Offset", "Streak angle offset in degrees");
1154         
1155         prop = RNA_def_property(srna, "fade", PROP_FLOAT, PROP_NONE);
1156         RNA_def_property_float_sdna(prop, NULL, "fade");
1157         RNA_def_property_ui_text(prop, "Fade", "Streak fade-out factor");
1158         
1159         prop = RNA_def_property(srna, "rotate_45", PROP_BOOLEAN, PROP_NONE);
1160         RNA_def_property_boolean_sdna(prop, NULL, "angle", 1);
1161         RNA_def_property_ui_text(prop, "Rotate 45", "Simple star filter: add 45 degree rotation offset");
1162         
1163         prop = RNA_def_property(srna, "size", PROP_INT, PROP_NONE);
1164         RNA_def_property_int_sdna(prop, NULL, "size");
1165         RNA_def_property_ui_text(prop, "Size", "Glow/glare size (not actual size; relative to initial size of bright area of pixels)");
1166         
1167         /* TODO */
1168 }
1169
1170 static void def_cmp_tonemap(StructRNA *srna)
1171 {
1172         PropertyRNA *prop;
1173         
1174         static EnumPropertyItem type_items[] = {
1175                 {1, "RD_PHOTORECEPTOR", "R/D Photoreceptor", ""},
1176                 {0, "RH_SIMPLE",        "Rh Simple",         ""},
1177                 {0, NULL, NULL, NULL}
1178         };
1179         
1180         RNA_def_struct_sdna_from(srna, "NodeTonemap", "storage");
1181         
1182         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1183         RNA_def_property_enum_sdna(prop, NULL, "type");
1184         RNA_def_property_enum_items(prop, type_items);
1185         RNA_def_property_ui_text(prop, "Type", "");
1186         
1187         /* TODO: if type==0 { */
1188         
1189         prop = RNA_def_property(srna, "key", PROP_FLOAT, PROP_NONE);
1190         RNA_def_property_float_sdna(prop, NULL, "key");
1191         RNA_def_property_ui_text(prop, "Key", "The value the average luminance is mapped to");
1192         
1193         prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
1194         RNA_def_property_float_sdna(prop, NULL, "offset");
1195         RNA_def_property_ui_text(prop, "Offset", "Normally always 1, but can be used as an extra control to alter the brightness curve");
1196         
1197         prop = RNA_def_property(srna, "gamma", PROP_FLOAT, PROP_NONE);
1198         RNA_def_property_float_sdna(prop, NULL, "gamma");
1199         RNA_def_property_ui_text(prop, "Gamma", "If not used, set to 1");
1200         
1201         /* TODO: } else { */
1202         
1203         prop = RNA_def_property(srna, "intensity", PROP_FLOAT, PROP_NONE);
1204         RNA_def_property_float_sdna(prop, NULL, "f");
1205         RNA_def_property_ui_text(prop, "Intensity", "If less than zero, darkens image; otherwise, makes it brighter");
1206         
1207         prop = RNA_def_property(srna, "contrast", PROP_FLOAT, PROP_NONE);
1208         RNA_def_property_float_sdna(prop, NULL, "m");
1209         RNA_def_property_ui_text(prop, "Contrast", "Set to 0 to use estimate from input image");
1210         
1211         prop = RNA_def_property(srna, "adaptation", PROP_FLOAT, PROP_NONE);
1212         RNA_def_property_float_sdna(prop, NULL, "a");
1213         RNA_def_property_ui_text(prop, "Adaptation", "If 0, global; if 1, based on pixel intensity");
1214         
1215         prop = RNA_def_property(srna, "correction", PROP_FLOAT, PROP_NONE);
1216         RNA_def_property_float_sdna(prop, NULL, "c");
1217         RNA_def_property_ui_text(prop, "Color Correction", "If 0, same for all channels; if 1, each independent");
1218 }
1219
1220 static void def_cmp_lensdist(StructRNA *srna)
1221 {
1222         PropertyRNA *prop;
1223         
1224         RNA_def_struct_sdna_from(srna, "NodeLensDist", "storage");
1225         
1226         prop = RNA_def_property(srna, "projector", PROP_BOOLEAN, PROP_NONE);
1227         RNA_def_property_boolean_sdna(prop, NULL, "proj", 1);
1228         RNA_def_property_ui_text(prop, "Projector", "Enable/disable projector mode. Effect is applied in horizontal direction only.");
1229         
1230         /* TODO: if proj mode is off { */
1231         
1232         prop = RNA_def_property(srna, "jitter", PROP_BOOLEAN, PROP_NONE);
1233         RNA_def_property_boolean_sdna(prop, NULL, "jit", 1);
1234         RNA_def_property_ui_text(prop, "Jitter", "Enable/disable jittering; faster, but also noisier");
1235         
1236         prop = RNA_def_property(srna, "fit", PROP_BOOLEAN, PROP_NONE);
1237         RNA_def_property_boolean_sdna(prop, NULL, "fit", 1);
1238         RNA_def_property_ui_text(prop, "Fit", "For positive distortion factor only: scale image such that black areas are not visible");
1239 }
1240         
1241
1242
1243 /* -- Texture Nodes --------------------------------------------------------- */
1244
1245 static void def_tex_output(StructRNA *srna)
1246 {
1247         PropertyRNA *prop;
1248
1249         RNA_def_struct_sdna_from(srna, "TexNodeOutput", "storage");
1250         
1251         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1252         RNA_def_property_string_sdna(prop, NULL, "name");
1253         RNA_def_property_ui_text(prop, "Name", "");
1254 }
1255
1256 static void def_tex_image(StructRNA *srna)
1257 {
1258         PropertyRNA *prop;
1259
1260         prop = RNA_def_property(srna, "settings", PROP_POINTER, PROP_NONE);
1261         RNA_def_property_pointer_sdna(prop, NULL, "storage");
1262         RNA_def_property_struct_type(prop, "ImageUser");
1263         RNA_def_property_ui_text(prop, "Settings", "");
1264 }
1265
1266 static void def_tex_bricks(StructRNA *srna)
1267 {
1268         PropertyRNA *prop;
1269
1270         prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
1271         RNA_def_property_float_sdna(prop, NULL, "custom3");
1272         RNA_def_property_ui_text(prop, "Offset Amount", "");
1273         
1274         prop = RNA_def_property(srna, "offset_frequency", PROP_INT, PROP_NONE);
1275         RNA_def_property_int_sdna(prop, NULL, "custom1");
1276         RNA_def_property_ui_text(prop, "Offset Frequency", "Offset every N rows");
1277         
1278         prop = RNA_def_property(srna, "squash", PROP_FLOAT, PROP_NONE);
1279         RNA_def_property_float_sdna(prop, NULL, "custom4");
1280         RNA_def_property_ui_text(prop, "Squash Amount", "");
1281         
1282         prop = RNA_def_property(srna, "squash_frequency", PROP_INT, PROP_NONE);
1283         RNA_def_property_int_sdna(prop, NULL, "custom2");
1284         RNA_def_property_ui_text(prop, "Squash Frequency", "Squash every N rows");
1285 }
1286
1287 /* -------------------------------------------------------------------------- */
1288
1289 static void rna_def_shader_node(BlenderRNA *brna)
1290 {
1291         StructRNA *srna;
1292         PropertyRNA *prop;
1293         EnumPropertyItem *node_type_items;
1294         
1295         node_type_items = alloc_node_type_items(Category_ShaderNode);
1296
1297         srna = RNA_def_struct(brna, "ShaderNode", "Node");
1298         RNA_def_struct_ui_text(srna, "Shader Node", "Material shader node.");
1299         RNA_def_struct_sdna(srna, "bNode");
1300
1301         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1302         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1303         RNA_def_property_enum_items(prop, node_type_items);
1304         RNA_def_property_ui_text(prop, "Type", "");
1305 }
1306
1307 static void rna_def_compositor_node(BlenderRNA *brna)
1308 {
1309         StructRNA *srna;
1310         PropertyRNA *prop;
1311         EnumPropertyItem *node_type_items;
1312         
1313         node_type_items = alloc_node_type_items(Category_CompositorNode);
1314         
1315         srna = RNA_def_struct(brna, "CompositorNode", "Node");
1316         RNA_def_struct_ui_text(srna, "Compositor Node", "");
1317         RNA_def_struct_sdna(srna, "bNode");
1318
1319         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1320         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1321         RNA_def_property_enum_items(prop, node_type_items);
1322         RNA_def_property_ui_text(prop, "Type", "");
1323 }
1324
1325 static void rna_def_texture_node(BlenderRNA *brna)
1326 {
1327         StructRNA *srna;
1328         PropertyRNA *prop;
1329         EnumPropertyItem *node_type_items;
1330         
1331         node_type_items = alloc_node_type_items(Category_TextureNode);
1332         
1333         srna = RNA_def_struct(brna, "TextureNode", "Node");
1334         RNA_def_struct_ui_text(srna, "Texture Node", "");
1335         RNA_def_struct_sdna(srna, "bNode");
1336
1337         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1338         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1339         RNA_def_property_enum_items(prop, node_type_items);
1340         RNA_def_property_ui_text(prop, "Type", "");
1341 }
1342
1343 /* -------------------------------------------------------------------------- */
1344
1345 static void rna_def_node(BlenderRNA *brna)
1346 {
1347         StructRNA *srna;
1348         PropertyRNA *prop;
1349         
1350         srna = RNA_def_struct(brna, "Node", NULL);
1351         RNA_def_struct_ui_text(srna, "Node", "Node in a node tree.");
1352         RNA_def_struct_sdna(srna, "bNode");
1353         RNA_def_struct_refine_func(srna, "rna_Node_refine");
1354         
1355         prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_VECTOR);
1356         RNA_def_property_float_sdna(prop, NULL, "locx");
1357         RNA_def_property_array(prop, 2);
1358         RNA_def_property_range(prop, -10000.0f, 10000.0f);
1359         RNA_def_property_ui_text(prop, "Location", "");
1360         
1361         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1362         RNA_def_property_ui_text(prop, "Name", "Node name.");
1363         RNA_def_struct_name_property(srna, prop);
1364 }
1365
1366 static void rna_def_nodetree(BlenderRNA *brna)
1367 {
1368         StructRNA *srna;
1369         PropertyRNA *prop;
1370         
1371         srna = RNA_def_struct(brna, "NodeTree", "ID");
1372         RNA_def_struct_ui_text(srna, "Node Tree", "Node tree consisting of linked nodes used for materials, textures and compositing.");
1373         RNA_def_struct_sdna(srna, "bNodeTree");
1374         RNA_def_struct_ui_icon(srna, ICON_NODE);
1375
1376         prop = RNA_def_property(srna, "nodes", PROP_COLLECTION, PROP_NONE);
1377         RNA_def_property_collection_sdna(prop, NULL, "nodes", NULL);
1378         RNA_def_property_struct_type(prop, "Node");
1379         RNA_def_property_ui_text(prop, "Nodes", "");
1380 }
1381
1382 static void define_specific_node(BlenderRNA *brna, int id, void (*func)(StructRNA*))
1383 {
1384         StructRNA *srna = def_node(brna, id);
1385         
1386         if(func)
1387                 func(srna);
1388 }
1389
1390 void RNA_def_nodetree(BlenderRNA *brna)
1391 {
1392         init();
1393         rna_def_nodetree(brna);
1394         rna_def_node(brna);
1395         rna_def_shader_node(brna);
1396         rna_def_compositor_node(brna);
1397         rna_def_texture_node(brna);
1398         
1399         #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
1400                 define_specific_node(brna, ID, DefFunc);
1401                 
1402         #include "rna_nodetree_types.h"
1403         
1404         #undef DefNode
1405 }
1406
1407 #endif
1408