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