Cleanup: Use full name for scene_layer in makesrna
[blender.git] / source / blender / makesrna / intern / rna_brush.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation (2008), Juho Veps�l�inen
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_brush.c
24  *  \ingroup RNA
25  */
26
27 #include <stdlib.h>
28 #include <assert.h>
29
30 #include "DNA_brush_types.h"
31 #include "DNA_texture_types.h"
32 #include "DNA_scene_types.h"
33 #include "DNA_object_types.h"
34
35 #include "BLI_math.h"
36
37 #include "RNA_define.h"
38 #include "RNA_enum_types.h"
39
40 #include "rna_internal.h"
41
42 #include "IMB_imbuf.h"
43
44 #include "WM_types.h"
45
46 static const EnumPropertyItem prop_direction_items[] = {
47         {0, "ADD", 0, "Add", "Add effect of brush"},
48         {BRUSH_DIR_IN, "SUBTRACT", 0, "Subtract", "Subtract effect of brush"},
49         {0, NULL, 0, NULL, NULL}
50 };
51
52 static const EnumPropertyItem sculpt_stroke_method_items[] = {
53         {0, "DOTS", 0, "Dots", "Apply paint on each mouse move step"},
54         {BRUSH_DRAG_DOT, "DRAG_DOT", 0, "Drag Dot", "Allows a single dot to be carefully positioned"},
55         {BRUSH_SPACE, "SPACE", 0, "Space", "Limit brush application to the distance specified by spacing"},
56         {BRUSH_AIRBRUSH, "AIRBRUSH", 0, "Airbrush", "Keep applying paint effect while holding mouse (spray)"},
57         {BRUSH_ANCHORED, "ANCHORED", 0, "Anchored", "Keep the brush anchored to the initial location"},
58         {BRUSH_LINE, "LINE", 0, "Line", "Draw a line with dabs separated according to spacing"},
59         {BRUSH_CURVE, "CURVE", 0, "Curve",
60                       "Define the stroke curve with a bezier curve (dabs are separated according to spacing)"},
61         {0, NULL, 0, NULL, NULL}
62 };
63
64
65 const EnumPropertyItem rna_enum_brush_sculpt_tool_items[] = {
66         {SCULPT_TOOL_BLOB, "BLOB", ICON_BRUSH_BLOB, "Blob", ""},
67         {SCULPT_TOOL_CLAY, "CLAY", ICON_BRUSH_CLAY, "Clay", ""},
68         {SCULPT_TOOL_CLAY_STRIPS, "CLAY_STRIPS", ICON_BRUSH_CLAY_STRIPS, "Clay Strips", ""},
69         {SCULPT_TOOL_CREASE, "CREASE", ICON_BRUSH_CREASE, "Crease", ""},
70         {SCULPT_TOOL_DRAW, "DRAW", ICON_BRUSH_SCULPT_DRAW, "Draw", ""},
71         {SCULPT_TOOL_FILL, "FILL", ICON_BRUSH_FILL, "Fill", ""},
72         {SCULPT_TOOL_FLATTEN, "FLATTEN", ICON_BRUSH_FLATTEN, "Flatten", ""},
73         {SCULPT_TOOL_GRAB, "GRAB", ICON_BRUSH_GRAB, "Grab", ""},
74         {SCULPT_TOOL_INFLATE, "INFLATE", ICON_BRUSH_INFLATE, "Inflate", ""},
75         {SCULPT_TOOL_LAYER, "LAYER", ICON_BRUSH_LAYER, "Layer", ""},
76         {SCULPT_TOOL_MASK, "MASK", ICON_BRUSH_MASK, "Mask", ""},
77         {SCULPT_TOOL_NUDGE, "NUDGE", ICON_BRUSH_NUDGE, "Nudge", ""},
78         {SCULPT_TOOL_PINCH, "PINCH", ICON_BRUSH_PINCH, "Pinch", ""},
79         {SCULPT_TOOL_ROTATE, "ROTATE", ICON_BRUSH_ROTATE, "Rotate", ""},
80         {SCULPT_TOOL_SCRAPE, "SCRAPE", ICON_BRUSH_SCRAPE, "Scrape", ""},
81         {SCULPT_TOOL_SIMPLIFY, "SIMPLIFY", ICON_BRUSH_SUBTRACT /* icon TODO */, "Simplify", ""},
82         {SCULPT_TOOL_SMOOTH, "SMOOTH", ICON_BRUSH_SMOOTH, "Smooth", ""},
83         {SCULPT_TOOL_SNAKE_HOOK, "SNAKE_HOOK", ICON_BRUSH_SNAKE_HOOK, "Snake Hook", ""},
84         {SCULPT_TOOL_THUMB, "THUMB", ICON_BRUSH_THUMB, "Thumb", ""},
85         {0, NULL, 0, NULL, NULL}
86 };
87
88
89 const EnumPropertyItem rna_enum_brush_vertex_tool_items[] = {
90         {PAINT_BLEND_MIX, "MIX", ICON_BRUSH_MIX, "Mix", "Use mix blending mode while painting"},
91         {PAINT_BLEND_ADD, "ADD", ICON_BRUSH_ADD, "Add", "Use add blending mode while painting"},
92         {PAINT_BLEND_SUB, "SUB", ICON_BRUSH_SUBTRACT, "Subtract", "Use subtract blending mode while painting"},
93         {PAINT_BLEND_MUL, "MUL", ICON_BRUSH_MULTIPLY, "Multiply", "Use multiply blending mode while painting"},
94         {PAINT_BLEND_BLUR, "BLUR", ICON_BRUSH_BLUR, "Blur", "Blur the color with surrounding values"},
95         {PAINT_BLEND_LIGHTEN, "LIGHTEN", ICON_BRUSH_LIGHTEN, "Lighten", "Use lighten blending mode while painting"},
96         {PAINT_BLEND_DARKEN, "DARKEN", ICON_BRUSH_DARKEN, "Darken", "Use darken blending mode while painting"},
97         {PAINT_BLEND_AVERAGE, "AVERAGE", ICON_BRUSH_BLUR, "Average", "Use average blending mode while painting"},
98         {PAINT_BLEND_SMEAR, "SMEAR", ICON_BRUSH_BLUR, "Smear", "Use smear blending mode while painting"},
99         {PAINT_BLEND_COLORDODGE, "COLORDODGE", ICON_BRUSH_BLUR, "Color Dodge", "Use color dodge blending mode while painting" },
100         {PAINT_BLEND_DIFFERENCE, "DIFFERENCE", ICON_BRUSH_BLUR, "Difference", "Use difference blending mode while painting"},
101         {PAINT_BLEND_SCREEN, "SCREEN", ICON_BRUSH_BLUR, "Screen", "Use screen blending mode while painting"},
102         {PAINT_BLEND_HARDLIGHT, "HARDLIGHT", ICON_BRUSH_BLUR, "Hardlight", "Use hardlight blending mode while painting"},
103         {PAINT_BLEND_OVERLAY, "OVERLAY", ICON_BRUSH_BLUR, "Overlay", "Use overlay blending mode while painting"},
104         {PAINT_BLEND_SOFTLIGHT, "SOFTLIGHT", ICON_BRUSH_BLUR, "Softlight", "Use softlight blending mode while painting"},
105         {PAINT_BLEND_EXCLUSION, "EXCLUSION", ICON_BRUSH_BLUR, "Exclusion", "Use exclusion blending mode while painting"},
106         {PAINT_BLEND_LUMINOCITY, "LUMINOCITY", ICON_BRUSH_BLUR, "Luminocity", "Use luminocity blending mode while painting"},
107         {PAINT_BLEND_SATURATION, "SATURATION", ICON_BRUSH_BLUR, "Saturation", "Use saturation blending mode while painting"},
108         {PAINT_BLEND_HUE, "HUE", ICON_BRUSH_BLUR, "Hue", "Use hue blending mode while painting"},
109         {PAINT_BLEND_ALPHA_SUB, "ERASE_ALPHA", 0, "Erase Alpha", "Erase alpha while painting"},
110         {PAINT_BLEND_ALPHA_ADD, "ADD_ALPHA", 0, "Add Alpha", "Add alpha while painting"},
111
112         {0, NULL, 0, NULL, NULL}
113 };
114         
115 const EnumPropertyItem rna_enum_brush_image_tool_items[] = {
116         {PAINT_TOOL_DRAW, "DRAW", ICON_BRUSH_TEXDRAW, "Draw", ""},
117         {PAINT_TOOL_SOFTEN, "SOFTEN", ICON_BRUSH_SOFTEN, "Soften", ""},
118         {PAINT_TOOL_SMEAR, "SMEAR", ICON_BRUSH_SMEAR, "Smear", ""},
119         {PAINT_TOOL_CLONE, "CLONE", ICON_BRUSH_CLONE, "Clone", ""},
120         {PAINT_TOOL_FILL, "FILL", ICON_BRUSH_TEXFILL, "Fill", ""},
121         {PAINT_TOOL_MASK, "MASK", ICON_BRUSH_TEXMASK, "Mask", ""},
122         {0, NULL, 0, NULL, NULL}
123 };
124
125 #ifdef RNA_RUNTIME
126
127 #include "MEM_guardedalloc.h"
128
129 #include "RNA_access.h"
130
131 #include "BKE_texture.h"
132 #include "BKE_brush.h"
133 #include "BKE_icons.h"
134 #include "BKE_paint.h"
135
136 #include "WM_api.h"
137
138 static int rna_SculptToolCapabilities_has_accumulate_get(PointerRNA *ptr)
139 {
140         Brush *br = (Brush *)ptr->data;
141         return SCULPT_TOOL_HAS_ACCUMULATE(br->sculpt_tool);
142 }
143
144 static int rna_SculptToolCapabilities_has_auto_smooth_get(PointerRNA *ptr)
145 {
146         Brush *br = (Brush *)ptr->data;
147         return !ELEM(br->sculpt_tool, SCULPT_TOOL_MASK, SCULPT_TOOL_SMOOTH);
148 }
149
150 static int rna_SculptToolCapabilities_has_height_get(PointerRNA *ptr)
151 {
152         Brush *br = (Brush *)ptr->data;
153         return br->sculpt_tool == SCULPT_TOOL_LAYER;
154 }
155
156 static int rna_SculptToolCapabilities_has_jitter_get(PointerRNA *ptr)
157 {
158         Brush *br = (Brush *)ptr->data;
159         return (!(br->flag & BRUSH_ANCHORED) &&
160                 !(br->flag & BRUSH_DRAG_DOT) &&
161                 !ELEM(br->sculpt_tool,
162                       SCULPT_TOOL_GRAB, SCULPT_TOOL_ROTATE,
163                       SCULPT_TOOL_SNAKE_HOOK, SCULPT_TOOL_THUMB));
164 }
165
166 static int rna_SculptToolCapabilities_has_normal_weight_get(PointerRNA *ptr)
167 {
168         Brush *br = (Brush *)ptr->data;
169         return SCULPT_TOOL_HAS_NORMAL_WEIGHT(br->sculpt_tool);
170 }
171
172 static int rna_SculptToolCapabilities_has_rake_factor_get(PointerRNA *ptr)
173 {
174         Brush *br = (Brush *)ptr->data;
175         return SCULPT_TOOL_HAS_RAKE(br->sculpt_tool);
176 }
177
178 static int rna_BrushCapabilities_has_overlay_get(PointerRNA *ptr)
179 {
180         Brush *br = (Brush *)ptr->data;
181         return ELEM(br->mtex.brush_map_mode,
182                     MTEX_MAP_MODE_VIEW,
183                     MTEX_MAP_MODE_TILED,
184                     MTEX_MAP_MODE_STENCIL);
185 }
186
187 static int rna_SculptToolCapabilities_has_persistence_get(PointerRNA *ptr)
188 {
189         Brush *br = (Brush *)ptr->data;
190         return br->sculpt_tool == SCULPT_TOOL_LAYER;
191 }
192
193 static int rna_SculptToolCapabilities_has_pinch_factor_get(PointerRNA *ptr)
194 {
195         Brush *br = (Brush *)ptr->data;
196         return ELEM(br->sculpt_tool, SCULPT_TOOL_BLOB, SCULPT_TOOL_CREASE, SCULPT_TOOL_SNAKE_HOOK);
197 }
198
199 static int rna_SculptToolCapabilities_has_plane_offset_get(PointerRNA *ptr)
200 {
201         Brush *br = (Brush *)ptr->data;
202         return ELEM(br->sculpt_tool, SCULPT_TOOL_CLAY, SCULPT_TOOL_CLAY_STRIPS,
203                     SCULPT_TOOL_FILL, SCULPT_TOOL_FLATTEN, SCULPT_TOOL_SCRAPE);
204 }
205
206 static int rna_SculptToolCapabilities_has_random_texture_angle_get(PointerRNA *ptr)
207 {
208         Brush *br = (Brush *)ptr->data;
209         return (!ELEM(br->sculpt_tool,
210                       SCULPT_TOOL_GRAB, SCULPT_TOOL_ROTATE,
211                       SCULPT_TOOL_SNAKE_HOOK, SCULPT_TOOL_THUMB));
212 }
213
214 static int rna_TextureCapabilities_has_random_texture_angle_get(PointerRNA *ptr)
215 {
216         MTex *mtex = (MTex *)ptr->data;
217         return ELEM(mtex->brush_map_mode,
218                      MTEX_MAP_MODE_VIEW,
219                      MTEX_MAP_MODE_AREA,
220                      MTEX_MAP_MODE_RANDOM);
221 }
222
223
224 static int rna_BrushCapabilities_has_random_texture_angle_get(PointerRNA *ptr)
225 {
226         Brush *br = (Brush *)ptr->data;
227         return !(br->flag & BRUSH_ANCHORED);
228 }
229
230 static int rna_SculptToolCapabilities_has_sculpt_plane_get(PointerRNA *ptr)
231 {
232         Brush *br = (Brush *)ptr->data;
233         return !ELEM(br->sculpt_tool, SCULPT_TOOL_INFLATE,
234                      SCULPT_TOOL_MASK, SCULPT_TOOL_PINCH,
235                      SCULPT_TOOL_SMOOTH);
236 }
237
238 static int rna_SculptToolCapabilities_has_secondary_color_get(PointerRNA *ptr)
239 {
240         Brush *br = (Brush *)ptr->data;
241         return BKE_brush_sculpt_has_secondary_color(br);
242 }
243
244 static int rna_SculptToolCapabilities_has_smooth_stroke_get(PointerRNA *ptr)
245 {
246         Brush *br = (Brush *)ptr->data;
247         return (!(br->flag & BRUSH_ANCHORED) &&
248                 !(br->flag & BRUSH_DRAG_DOT) &&
249                 !(br->flag & BRUSH_LINE) &&
250                 !(br->flag & BRUSH_CURVE) &&
251                 !ELEM(br->sculpt_tool,
252                        SCULPT_TOOL_GRAB, SCULPT_TOOL_ROTATE,
253                        SCULPT_TOOL_SNAKE_HOOK, SCULPT_TOOL_THUMB));
254 }
255
256 static int rna_BrushCapabilities_has_smooth_stroke_get(PointerRNA *ptr)
257 {
258         Brush *br = (Brush *)ptr->data;
259         return (!(br->flag & BRUSH_ANCHORED) &&
260                 !(br->flag & BRUSH_DRAG_DOT) &&
261                 !(br->flag & BRUSH_LINE) &&
262                 !(br->flag & BRUSH_CURVE));
263 }
264
265 static int rna_SculptToolCapabilities_has_space_attenuation_get(PointerRNA *ptr)
266 {
267         Brush *br = (Brush *)ptr->data;
268         return ((br->flag & (BRUSH_SPACE | BRUSH_LINE | BRUSH_CURVE)) &&
269                 !ELEM(br->sculpt_tool, SCULPT_TOOL_GRAB, SCULPT_TOOL_ROTATE,
270                        SCULPT_TOOL_SMOOTH, SCULPT_TOOL_SNAKE_HOOK));
271 }
272
273 static int rna_ImapaintToolCapabilities_has_space_attenuation_get(PointerRNA *ptr)
274 {
275         Brush *br = (Brush *)ptr->data;
276         return (br->flag & (BRUSH_SPACE | BRUSH_LINE | BRUSH_CURVE)) &&
277                 br->imagepaint_tool != PAINT_TOOL_FILL;
278 }
279
280 static int rna_BrushCapabilities_has_spacing_get(PointerRNA *ptr)
281 {
282         Brush *br = (Brush *)ptr->data;
283         return (!(br->flag & BRUSH_ANCHORED));
284 }
285
286 static int rna_SculptToolCapabilities_has_strength_pressure_get(PointerRNA *ptr)
287 {
288         Brush *br = (Brush *)ptr->data;
289         return !ELEM(br->sculpt_tool, SCULPT_TOOL_GRAB, SCULPT_TOOL_SNAKE_HOOK);
290 }
291
292 static int rna_TextureCapabilities_has_texture_angle_get(PointerRNA *ptr)
293 {
294         MTex *mtex = (MTex *)ptr->data;
295         return mtex->brush_map_mode != MTEX_MAP_MODE_3D;
296 }
297
298 static int rna_SculptToolCapabilities_has_gravity_get(PointerRNA *ptr)
299 {
300         Brush *br = (Brush *)ptr->data;
301         return !ELEM(br->sculpt_tool, SCULPT_TOOL_MASK, SCULPT_TOOL_SMOOTH);
302 }
303
304 static int rna_TextureCapabilities_has_texture_angle_source_get(PointerRNA *ptr)
305 {
306         MTex *mtex = (MTex *)ptr->data;
307         return ELEM(mtex->brush_map_mode,
308                     MTEX_MAP_MODE_VIEW,
309                     MTEX_MAP_MODE_AREA,
310                     MTEX_MAP_MODE_RANDOM);
311 }
312
313 static int rna_ImapaintToolCapabilities_has_accumulate_get(PointerRNA *ptr)
314 {
315         /* only support for draw tool */
316         Brush *br = (Brush *)ptr->data;
317
318         return ((br->flag & BRUSH_AIRBRUSH) ||
319                 (br->flag & BRUSH_DRAG_DOT) ||
320                 (br->flag & BRUSH_ANCHORED) ||
321                 (br->imagepaint_tool == PAINT_TOOL_SOFTEN) ||
322                 (br->imagepaint_tool == PAINT_TOOL_SMEAR) ||
323                 (br->imagepaint_tool == PAINT_TOOL_FILL) ||
324                 (br->mtex.tex && !ELEM(br->mtex.brush_map_mode, MTEX_MAP_MODE_TILED, MTEX_MAP_MODE_STENCIL, MTEX_MAP_MODE_3D))
325                 ) ? false : true;
326 }
327
328 static int rna_ImapaintToolCapabilities_has_radius_get(PointerRNA *ptr)
329 {
330         /* only support for draw tool */
331         Brush *br = (Brush *)ptr->data;
332
333         return (br->imagepaint_tool != PAINT_TOOL_FILL);
334 }
335
336
337 static PointerRNA rna_Sculpt_tool_capabilities_get(PointerRNA *ptr)
338 {
339         return rna_pointer_inherit_refine(ptr, &RNA_SculptToolCapabilities, ptr->id.data);
340 }
341
342 static PointerRNA rna_Imapaint_tool_capabilities_get(PointerRNA *ptr)
343 {
344         return rna_pointer_inherit_refine(ptr, &RNA_ImapaintToolCapabilities, ptr->id.data);
345 }
346
347 static PointerRNA rna_Brush_capabilities_get(PointerRNA *ptr)
348 {
349         return rna_pointer_inherit_refine(ptr, &RNA_BrushCapabilities, ptr->id.data);
350 }
351
352 static void rna_Brush_reset_icon(Brush *br, const char *UNUSED(type))
353 {
354         ID *id = &br->id;
355
356         if (br->flag & BRUSH_CUSTOM_ICON)
357                 return;
358
359         if (id->icon_id >= BIFICONID_LAST) {
360                 BKE_icon_id_delete(id);
361                 BKE_previewimg_id_free(id);
362         }
363
364         id->icon_id = 0;
365 }
366
367 static void rna_Brush_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
368 {
369         Brush *br = (Brush *)ptr->data;
370         WM_main_add_notifier(NC_BRUSH | NA_EDITED, br);
371         /*WM_main_add_notifier(NC_SPACE|ND_SPACE_VIEW3D, NULL); */
372 }
373
374 static void rna_Brush_main_tex_update(bContext *C, PointerRNA *ptr)
375 {
376         Main *bmain = CTX_data_main(C);
377         Scene *scene = CTX_data_scene(C);
378         SceneLayer *scene_layer = CTX_data_scene_layer(C);
379         Brush *br = (Brush *)ptr->data;
380         BKE_paint_invalidate_overlay_tex(scene, scene_layer, br->mtex.tex);
381         rna_Brush_update(bmain, scene, ptr);
382 }
383
384 static void rna_Brush_secondary_tex_update(bContext *C, PointerRNA *ptr)
385 {
386         Main *bmain = CTX_data_main(C);
387         Scene *scene = CTX_data_scene(C);
388         SceneLayer *scene_layer = CTX_data_scene_layer(C);
389         Brush *br = (Brush *)ptr->data;
390         BKE_paint_invalidate_overlay_tex(scene, scene_layer, br->mask_mtex.tex);
391         rna_Brush_update(bmain, scene, ptr);
392 }
393
394 static void rna_Brush_size_update(Main *bmain, Scene *scene, PointerRNA *ptr)
395 {
396         BKE_paint_invalidate_overlay_all();
397         rna_Brush_update(bmain, scene, ptr);
398 }
399
400 static void rna_Brush_sculpt_tool_update(Main *bmain, Scene *scene, PointerRNA *ptr)
401 {
402         Brush *br = (Brush *)ptr->data;
403         rna_Brush_reset_icon(br, "sculpt");
404         rna_Brush_update(bmain, scene, ptr);
405 }
406  
407 static void rna_Brush_vertex_tool_update(Main *bmain, Scene *scene, PointerRNA *ptr)
408 {
409         Brush *br = (Brush *)ptr->data;
410         rna_Brush_reset_icon(br, "vertex_paint");
411         rna_Brush_update(bmain, scene, ptr);
412 }
413  
414 static void rna_Brush_imagepaint_tool_update(Main *bmain, Scene *scene, PointerRNA *ptr)
415 {
416         Brush *br = (Brush *)ptr->data;
417         rna_Brush_reset_icon(br, "image_paint");
418         rna_Brush_update(bmain, scene, ptr);
419 }
420
421 static void rna_Brush_stroke_update(Main *bmain, Scene *scene, PointerRNA *ptr)
422 {
423         WM_main_add_notifier(NC_SCENE | ND_TOOLSETTINGS, scene);
424         rna_Brush_update(bmain, scene, ptr);
425 }
426
427 static void rna_Brush_icon_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
428 {
429         Brush *br = (Brush *)ptr->data;
430
431         if (br->icon_imbuf) {
432                 IMB_freeImBuf(br->icon_imbuf);
433                 br->icon_imbuf = NULL;
434         }
435
436         br->id.icon_id = 0;
437
438         if (br->flag & BRUSH_CUSTOM_ICON) {
439                 BKE_previewimg_id_ensure(&br->id);
440                 BKE_icon_changed(BKE_icon_id_ensure(&br->id));
441         }
442
443         WM_main_add_notifier(NC_BRUSH | NA_EDITED, br);
444 }
445
446 static void rna_TextureSlot_brush_angle_update(bContext *C, PointerRNA *ptr)
447 {
448         Scene *scene = CTX_data_scene(C);
449         MTex *mtex = ptr->data;
450         /* skip invalidation of overlay for stencil mode */
451         if (mtex->mapping != MTEX_MAP_MODE_STENCIL) {
452                 SceneLayer *scene_layer = CTX_data_scene_layer(C);
453                 BKE_paint_invalidate_overlay_tex(scene, scene_layer, mtex->tex);
454         }
455
456         rna_TextureSlot_update(C, ptr);
457 }
458
459 static void rna_Brush_set_size(PointerRNA *ptr, int value)
460 {
461         Brush *brush = ptr->data;
462
463         /* scale unprojected radius so it stays consistent with brush size */
464         BKE_brush_scale_unprojected_radius(&brush->unprojected_radius,
465                                            value, brush->size);
466         brush->size = value;
467 }
468
469 static void rna_Brush_use_gradient_set(PointerRNA *ptr, int value)
470 {
471         Brush *br = (Brush *)ptr->data;
472
473         if (value) br->flag |= BRUSH_USE_GRADIENT;
474         else br->flag &= ~BRUSH_USE_GRADIENT;
475
476         if ((br->flag & BRUSH_USE_GRADIENT) && br->gradient == NULL)
477                 br->gradient = add_colorband(true);
478 }
479
480 static void rna_Brush_set_unprojected_radius(PointerRNA *ptr, float value)
481 {
482         Brush *brush = ptr->data;
483
484         /* scale brush size so it stays consistent with unprojected_radius */
485         BKE_brush_scale_size(&brush->size, value, brush->unprojected_radius);
486         brush->unprojected_radius = value;
487 }
488
489 static const EnumPropertyItem *rna_Brush_direction_itemf(bContext *C, PointerRNA *ptr,
490                                                    PropertyRNA *UNUSED(prop), bool *UNUSED(r_free))
491 {
492         ePaintMode mode = BKE_paintmode_get_active_from_context(C);
493
494         static const EnumPropertyItem prop_default_items[] = {
495                 {0, NULL, 0, NULL, NULL}
496         };
497
498         /* sculpt mode */
499         static const EnumPropertyItem prop_flatten_contrast_items[] = {
500                 {0, "FLATTEN", 0, "Flatten", "Add effect of brush"},
501                 {BRUSH_DIR_IN, "CONTRAST", 0, "Contrast", "Subtract effect of brush"},
502                 {0, NULL, 0, NULL, NULL}
503         };
504
505         static const EnumPropertyItem prop_fill_deepen_items[] = {
506                 {0, "FILL", 0, "Fill", "Add effect of brush"},
507                 {BRUSH_DIR_IN, "DEEPEN", 0, "Deepen", "Subtract effect of brush"},
508                 {0, NULL, 0, NULL, NULL}
509         };
510
511         static const EnumPropertyItem prop_scrape_peaks_items[] = {
512                 {0, "SCRAPE", 0, "Scrape", "Add effect of brush"},
513                 {BRUSH_DIR_IN, "PEAKS", 0, "Peaks", "Subtract effect of brush"},
514                 {0, NULL, 0, NULL, NULL}
515         };
516
517         static const EnumPropertyItem prop_pinch_magnify_items[] = {
518                 {0, "PINCH", 0, "Pinch", "Add effect of brush"},
519                 {BRUSH_DIR_IN, "MAGNIFY", 0, "Magnify", "Subtract effect of brush"},
520                 {0, NULL, 0, NULL, NULL}
521         };
522
523         static const EnumPropertyItem prop_inflate_deflate_items[] = {
524                 {0, "INFLATE", 0, "Inflate", "Add effect of brush"},
525                 {BRUSH_DIR_IN, "DEFLATE", 0, "Deflate", "Subtract effect of brush"},
526                 {0, NULL, 0, NULL, NULL}
527         };
528
529         /* texture paint mode */
530         static const EnumPropertyItem prop_soften_sharpen_items[] = {
531                 {0, "SOFTEN", 0, "Soften", "Blur effect of brush"},
532                 {BRUSH_DIR_IN, "SHARPEN", 0, "Sharpen", "Sharpen effect of brush"},
533                 {0, NULL, 0, NULL, NULL}
534         };
535
536         Brush *me = (Brush *)(ptr->data);
537
538         switch (mode) {
539                 case ePaintSculpt:
540                         switch (me->sculpt_tool) {
541                                 case SCULPT_TOOL_DRAW:
542                                 case SCULPT_TOOL_CREASE:
543                                 case SCULPT_TOOL_BLOB:
544                                 case SCULPT_TOOL_LAYER:
545                                 case SCULPT_TOOL_CLAY:
546                                 case SCULPT_TOOL_CLAY_STRIPS:
547                                         return prop_direction_items;
548
549                                 case SCULPT_TOOL_MASK:
550                                         switch ((BrushMaskTool)me->mask_tool) {
551                                                 case BRUSH_MASK_DRAW:
552                                                         return prop_direction_items;
553
554                                                 case BRUSH_MASK_SMOOTH:
555                                                         return prop_default_items;
556
557                                                 default:
558                                                         return prop_default_items;
559                                         }
560
561                                 case SCULPT_TOOL_FLATTEN:
562                                         return prop_flatten_contrast_items;
563
564                                 case SCULPT_TOOL_FILL:
565                                         return prop_fill_deepen_items;
566
567                                 case SCULPT_TOOL_SCRAPE:
568                                         return prop_scrape_peaks_items;
569
570                                 case SCULPT_TOOL_PINCH:
571                                         return prop_pinch_magnify_items;
572
573                                 case SCULPT_TOOL_INFLATE:
574                                         return prop_inflate_deflate_items;
575
576                                 default:
577                                         return prop_default_items;
578                         }
579
580                 case ePaintTexture2D:
581                 case ePaintTextureProjective:
582                         switch (me->imagepaint_tool) {
583                                 case PAINT_TOOL_SOFTEN:
584                                         return prop_soften_sharpen_items;
585
586                                 default:
587                                         return prop_default_items;
588                         }
589
590                 default:
591                         return prop_default_items;
592         }
593 }
594
595 static const EnumPropertyItem *rna_Brush_stroke_itemf(bContext *C, PointerRNA *UNUSED(ptr),
596                                                 PropertyRNA *UNUSED(prop), bool *UNUSED(r_free))
597 {
598         ePaintMode mode = BKE_paintmode_get_active_from_context(C);
599
600         static const EnumPropertyItem brush_stroke_method_items[] = {
601                 {0, "DOTS", 0, "Dots", "Apply paint on each mouse move step"},
602                 {BRUSH_SPACE, "SPACE", 0, "Space", "Limit brush application to the distance specified by spacing"},
603                 {BRUSH_AIRBRUSH, "AIRBRUSH", 0, "Airbrush", "Keep applying paint effect while holding mouse (spray)"},
604                 {BRUSH_LINE, "LINE", 0, "Line", "Drag a line with dabs separated according to spacing"},
605                 {BRUSH_CURVE, "CURVE", 0, "Curve", "Define the stroke curve with a bezier curve. Dabs are separated according to spacing"},
606                 {0, NULL, 0, NULL, NULL}
607         };
608
609         switch (mode) {
610                 case ePaintSculpt:
611                 case ePaintTexture2D:
612                 case ePaintTextureProjective:
613                         return sculpt_stroke_method_items;
614
615                 default:
616                         return brush_stroke_method_items;
617         }
618 }
619 #else
620
621 static void rna_def_brush_texture_slot(BlenderRNA *brna)
622 {
623         StructRNA *srna;
624         PropertyRNA *prop;
625
626         static const EnumPropertyItem prop_map_mode_items[] = {
627                 {MTEX_MAP_MODE_VIEW, "VIEW_PLANE", 0, "View Plane", ""},
628                 {MTEX_MAP_MODE_AREA, "AREA_PLANE", 0, "Area Plane", ""},
629                 {MTEX_MAP_MODE_TILED, "TILED", 0, "Tiled", ""},
630                 {MTEX_MAP_MODE_3D, "3D", 0, "3D", ""},
631                 {MTEX_MAP_MODE_RANDOM, "RANDOM", 0, "Random", ""},
632                 {MTEX_MAP_MODE_STENCIL, "STENCIL", 0, "Stencil", ""},
633                 {0, NULL, 0, NULL, NULL}
634         };
635
636         static const EnumPropertyItem prop_tex_paint_map_mode_items[] = {
637                 {MTEX_MAP_MODE_VIEW, "VIEW_PLANE", 0, "View Plane", ""},
638                 {MTEX_MAP_MODE_TILED, "TILED", 0, "Tiled", ""},
639                 {MTEX_MAP_MODE_3D, "3D", 0, "3D", ""},
640                 {MTEX_MAP_MODE_RANDOM, "RANDOM", 0, "Random", ""},
641                 {MTEX_MAP_MODE_STENCIL, "STENCIL", 0, "Stencil", ""},
642                 {0, NULL, 0, NULL, NULL}
643         };
644
645         static const EnumPropertyItem prop_mask_paint_map_mode_items[] = {
646                 {MTEX_MAP_MODE_VIEW, "VIEW_PLANE", 0, "View Plane", ""},
647                 {MTEX_MAP_MODE_TILED, "TILED", 0, "Tiled", ""},
648                 {MTEX_MAP_MODE_RANDOM, "RANDOM", 0, "Random", ""},
649                 {MTEX_MAP_MODE_STENCIL, "STENCIL", 0, "Stencil", ""},
650                 {0, NULL, 0, NULL, NULL}
651         };
652
653 #define TEXTURE_CAPABILITY(prop_name_, ui_name_)                          \
654         prop = RNA_def_property(srna, #prop_name_,                          \
655                                 PROP_BOOLEAN, PROP_NONE);                   \
656         RNA_def_property_clear_flag(prop, PROP_EDITABLE);                   \
657         RNA_def_property_boolean_funcs(prop, "rna_TextureCapabilities_"      \
658                                        #prop_name_ "_get", NULL);           \
659         RNA_def_property_ui_text(prop, ui_name_, NULL)
660         
661         
662         srna = RNA_def_struct(brna, "BrushTextureSlot", "TextureSlot");
663         RNA_def_struct_sdna(srna, "MTex");
664         RNA_def_struct_ui_text(srna, "Brush Texture Slot", "Texture slot for textures in a Brush data-block");
665
666         prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
667         RNA_def_property_float_sdna(prop, NULL, "rot");
668         RNA_def_property_range(prop, 0, M_PI * 2);
669         RNA_def_property_ui_text(prop, "Angle", "Brush texture rotation");
670         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
671         RNA_def_property_update(prop, 0, "rna_TextureSlot_brush_angle_update");
672
673         prop = RNA_def_property(srna, "map_mode", PROP_ENUM, PROP_NONE);
674         RNA_def_property_enum_sdna(prop, NULL, "brush_map_mode");
675         RNA_def_property_enum_items(prop, prop_map_mode_items);
676         RNA_def_property_ui_text(prop, "Mode", "");
677         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
678         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
679
680         prop = RNA_def_property(srna, "tex_paint_map_mode", PROP_ENUM, PROP_NONE);
681         RNA_def_property_enum_sdna(prop, NULL, "brush_map_mode");
682         RNA_def_property_enum_items(prop, prop_tex_paint_map_mode_items);
683         RNA_def_property_ui_text(prop, "Mode", "");
684         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
685         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
686
687         prop = RNA_def_property(srna, "mask_map_mode", PROP_ENUM, PROP_NONE);
688         RNA_def_property_enum_sdna(prop, NULL, "brush_map_mode");
689         RNA_def_property_enum_items(prop, prop_mask_paint_map_mode_items);
690         RNA_def_property_ui_text(prop, "Mode", "");
691         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
692         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
693
694         prop = RNA_def_property(srna, "use_rake", PROP_BOOLEAN, PROP_NONE);
695         RNA_def_property_boolean_sdna(prop, NULL, "brush_angle_mode", MTEX_ANGLE_RAKE);
696         RNA_def_property_ui_text(prop, "Rake", "");
697         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
698         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
699
700         prop = RNA_def_property(srna, "use_random", PROP_BOOLEAN, PROP_NONE);
701         RNA_def_property_boolean_sdna(prop, NULL, "brush_angle_mode", MTEX_ANGLE_RANDOM);
702         RNA_def_property_ui_text(prop, "Random", "");
703         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
704         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
705
706         prop = RNA_def_property(srna, "random_angle", PROP_FLOAT, PROP_ANGLE);
707         RNA_def_property_range(prop, 0, M_PI * 2);
708         RNA_def_property_ui_text(prop, "Random Angle", "Brush texture random angle");
709         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
710         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
711         
712         TEXTURE_CAPABILITY(has_texture_angle_source, "Has Texture Angle Source");
713         TEXTURE_CAPABILITY(has_random_texture_angle, "Has Random Texture Angle");
714         TEXTURE_CAPABILITY(has_texture_angle, "Has Texture Angle Source");      
715 }
716
717 static void rna_def_sculpt_capabilities(BlenderRNA *brna)
718 {
719         StructRNA *srna;
720         PropertyRNA *prop;
721
722         srna = RNA_def_struct(brna, "SculptToolCapabilities", NULL);
723         RNA_def_struct_sdna(srna, "Brush");
724         RNA_def_struct_nested(brna, srna, "Brush");
725         RNA_def_struct_ui_text(srna, "Sculpt Capabilities",
726                                "Read-only indications of which brush operations "
727                                "are supported by the current sculpt tool");
728
729 #define SCULPT_TOOL_CAPABILITY(prop_name_, ui_name_)                      \
730         prop = RNA_def_property(srna, #prop_name_,                          \
731                                 PROP_BOOLEAN, PROP_NONE);                   \
732         RNA_def_property_clear_flag(prop, PROP_EDITABLE);                   \
733         RNA_def_property_boolean_funcs(prop, "rna_SculptToolCapabilities_"      \
734                                        #prop_name_ "_get", NULL);           \
735         RNA_def_property_ui_text(prop, ui_name_, NULL)
736
737         SCULPT_TOOL_CAPABILITY(has_accumulate, "Has Accumulate");
738         SCULPT_TOOL_CAPABILITY(has_auto_smooth, "Has Auto Smooth");
739         SCULPT_TOOL_CAPABILITY(has_height, "Has Height");
740         SCULPT_TOOL_CAPABILITY(has_jitter, "Has Jitter");
741         SCULPT_TOOL_CAPABILITY(has_normal_weight, "Has Crease/Pinch Factor");
742         SCULPT_TOOL_CAPABILITY(has_rake_factor, "Has Rake Factor");
743         SCULPT_TOOL_CAPABILITY(has_persistence, "Has Persistence");
744         SCULPT_TOOL_CAPABILITY(has_pinch_factor, "Has Pinch Factor");
745         SCULPT_TOOL_CAPABILITY(has_plane_offset, "Has Plane Offset");
746         SCULPT_TOOL_CAPABILITY(has_random_texture_angle, "Has Random Texture Angle");
747         SCULPT_TOOL_CAPABILITY(has_sculpt_plane, "Has Sculpt Plane");
748         SCULPT_TOOL_CAPABILITY(has_secondary_color, "Has Secondary Color");
749         SCULPT_TOOL_CAPABILITY(has_smooth_stroke, "Has Smooth Stroke");
750         SCULPT_TOOL_CAPABILITY(has_space_attenuation, "Has Space Attenuation");
751         SCULPT_TOOL_CAPABILITY(has_strength_pressure, "Has Strength Pressure");
752         SCULPT_TOOL_CAPABILITY(has_gravity, "Has Gravity");
753
754 #undef SCULPT_CAPABILITY
755 }
756
757 static void rna_def_brush_capabilities(BlenderRNA *brna)
758 {
759         StructRNA *srna;
760         PropertyRNA *prop;
761
762         srna = RNA_def_struct(brna, "BrushCapabilities", NULL);
763         RNA_def_struct_sdna(srna, "Brush");
764         RNA_def_struct_nested(brna, srna, "Brush");
765         RNA_def_struct_ui_text(srna, "Brush Capabilities",
766                                "Read-only indications of which brush operations "
767                                "are supported by the current brush");
768
769 #define BRUSH_CAPABILITY(prop_name_, ui_name_)                          \
770         prop = RNA_def_property(srna, #prop_name_,                          \
771                                 PROP_BOOLEAN, PROP_NONE);                   \
772         RNA_def_property_clear_flag(prop, PROP_EDITABLE);                   \
773         RNA_def_property_boolean_funcs(prop, "rna_BrushCapabilities_"      \
774                                        #prop_name_ "_get", NULL);           \
775         RNA_def_property_ui_text(prop, ui_name_, NULL)
776
777         BRUSH_CAPABILITY(has_overlay, "Has Overlay");
778         BRUSH_CAPABILITY(has_random_texture_angle, "Has Random Texture Angle");
779         BRUSH_CAPABILITY(has_spacing, "Has Spacing");
780         BRUSH_CAPABILITY(has_smooth_stroke, "Has Smooth Stroke");
781
782
783 #undef BRUSH_CAPABILITY
784 }
785
786 static void rna_def_image_paint_capabilities(BlenderRNA *brna)
787 {
788         StructRNA *srna;
789         PropertyRNA *prop;
790
791         srna = RNA_def_struct(brna, "ImapaintToolCapabilities", NULL);
792         RNA_def_struct_sdna(srna, "Brush");
793         RNA_def_struct_nested(brna, srna, "Brush");
794         RNA_def_struct_ui_text(srna, "Image Paint Capabilities",
795                                "Read-only indications of which brush operations "
796                                "are supported by the current image paint brush");
797
798 #define IMAPAINT_TOOL_CAPABILITY(prop_name_, ui_name_)                       \
799         prop = RNA_def_property(srna, #prop_name_,                               \
800                                 PROP_BOOLEAN, PROP_NONE);                        \
801         RNA_def_property_clear_flag(prop, PROP_EDITABLE);                        \
802         RNA_def_property_boolean_funcs(prop, "rna_ImapaintToolCapabilities_"     \
803                                        #prop_name_ "_get", NULL);                \
804         RNA_def_property_ui_text(prop, ui_name_, NULL)
805
806         IMAPAINT_TOOL_CAPABILITY(has_accumulate, "Has Accumulate");
807         IMAPAINT_TOOL_CAPABILITY(has_space_attenuation, "Has Space Attenuation");
808         IMAPAINT_TOOL_CAPABILITY(has_radius, "Has Radius");
809
810 #undef IMAPAINT_TOOL_CAPABILITY
811 }
812
813 static void rna_def_brush(BlenderRNA *brna)
814 {
815         StructRNA *srna;
816         PropertyRNA *prop;
817         
818         static const EnumPropertyItem prop_blend_items[] = {
819                 {IMB_BLEND_MIX, "MIX", 0, "Mix", "Use mix blending mode while painting"},
820                 {IMB_BLEND_ADD, "ADD", 0, "Add", "Use add blending mode while painting"},
821                 {IMB_BLEND_SUB, "SUB", 0, "Subtract", "Use subtract blending mode while painting"},
822                 {IMB_BLEND_MUL, "MUL", 0, "Multiply", "Use multiply blending mode while painting"},
823                 {IMB_BLEND_LIGHTEN, "LIGHTEN", 0, "Lighten", "Use lighten blending mode while painting"},
824                 {IMB_BLEND_DARKEN, "DARKEN", 0, "Darken", "Use darken blending mode while painting"},
825                 {IMB_BLEND_ERASE_ALPHA, "ERASE_ALPHA", 0, "Erase Alpha", "Erase alpha while painting"},
826                 {IMB_BLEND_ADD_ALPHA, "ADD_ALPHA", 0, "Add Alpha", "Add alpha while painting"},
827                 {IMB_BLEND_OVERLAY, "OVERLAY", 0, "Overlay", "Use overlay blending mode while painting"},
828                 {IMB_BLEND_HARDLIGHT, "HARDLIGHT", 0, "Hard light", "Use hard light blending mode while painting"},
829                 {IMB_BLEND_COLORBURN, "COLORBURN", 0, "Color burn", "Use color burn blending mode while painting"},
830                 {IMB_BLEND_LINEARBURN, "LINEARBURN", 0, "Linear burn", "Use linear burn blending mode while painting"},
831                 {IMB_BLEND_COLORDODGE, "COLORDODGE", 0, "Color dodge", "Use color dodge blending mode while painting"},
832                 {IMB_BLEND_SCREEN, "SCREEN", 0, "Screen", "Use screen blending mode while painting"},
833                 {IMB_BLEND_SOFTLIGHT, "SOFTLIGHT", 0, "Soft light", "Use softlight blending mode while painting"},
834                 {IMB_BLEND_PINLIGHT, "PINLIGHT", 0, "Pin light", "Use pinlight blending mode while painting"},
835                 {IMB_BLEND_VIVIDLIGHT, "VIVIDLIGHT", 0, "Vivid light", "Use vividlight blending mode while painting"},
836                 {IMB_BLEND_LINEARLIGHT, "LINEARLIGHT", 0, "Linear light", "Use linearlight blending mode while painting"},
837                 {IMB_BLEND_DIFFERENCE, "DIFFERENCE", 0, "Difference", "Use difference blending mode while painting"},
838                 {IMB_BLEND_EXCLUSION, "EXCLUSION", 0, "Exclusion", "Use exclusion blending mode while painting"},
839                 {IMB_BLEND_HUE, "HUE", 0, "Hue", "Use hue blending mode while painting"},
840                 {IMB_BLEND_SATURATION, "SATURATION", 0, "Saturation", "Use saturation blending mode while painting"},
841                 {IMB_BLEND_LUMINOSITY, "LUMINOSITY", 0, "Luminosity", "Use luminosity blending mode while painting"},
842                 {IMB_BLEND_COLOR, "COLOR", 0, "Color", "Use color blending mode while painting"},
843                 {0, NULL, 0, NULL, NULL}
844         };
845         
846         static const EnumPropertyItem brush_sculpt_plane_items[] = {
847                 {SCULPT_DISP_DIR_AREA, "AREA", 0, "Area Plane", ""},
848                 {SCULPT_DISP_DIR_VIEW, "VIEW", 0, "View Plane", ""},
849                 {SCULPT_DISP_DIR_X, "X", 0, "X Plane", ""},
850                 {SCULPT_DISP_DIR_Y, "Y", 0, "Y Plane", ""},
851                 {SCULPT_DISP_DIR_Z, "Z", 0, "Z Plane", ""},
852                 {0, NULL, 0, NULL, NULL}
853         };
854
855         static const EnumPropertyItem brush_mask_tool_items[] = {
856                 {BRUSH_MASK_DRAW, "DRAW", 0, "Draw", ""},
857                 {BRUSH_MASK_SMOOTH, "SMOOTH", 0, "Smooth", ""},
858                 {0, NULL, 0, NULL, NULL}
859         };
860
861         static const EnumPropertyItem brush_blur_mode_items[] = {
862                 {KERNEL_BOX, "BOX", 0, "Box", ""},
863                 {KERNEL_GAUSSIAN, "GAUSSIAN", 0, "Gaussian", ""},
864                 {0, NULL, 0, NULL, NULL}
865         };
866
867         static const EnumPropertyItem brush_gradient_items[] = {
868                 {BRUSH_GRADIENT_PRESSURE, "PRESSURE", 0, "Pressure", ""},
869                 {BRUSH_GRADIENT_SPACING_REPEAT, "SPACING_REPEAT", 0, "Repeat", ""},
870                 {BRUSH_GRADIENT_SPACING_CLAMP, "SPACING_CLAMP", 0, "Clamp", ""},
871                 {0, NULL, 0, NULL, NULL}
872         };
873
874         static const EnumPropertyItem brush_gradient_fill_items[] = {
875                 {BRUSH_GRADIENT_LINEAR, "LINEAR", 0, "Linear", ""},
876                 {BRUSH_GRADIENT_RADIAL, "RADIAL", 0, "Radial", ""},
877                 {0, NULL, 0, NULL, NULL}
878         };
879
880         static const EnumPropertyItem brush_mask_pressure_items[] = {
881                 {0, "NONE", 0, "Off", ""},
882                 {BRUSH_MASK_PRESSURE_RAMP, "RAMP", ICON_STYLUS_PRESSURE, "Ramp", ""},
883                 {BRUSH_MASK_PRESSURE_CUTOFF, "CUTOFF", ICON_STYLUS_PRESSURE, "Cutoff", ""},
884                 {0, NULL, 0, NULL, NULL}
885         };
886
887         srna = RNA_def_struct(brna, "Brush", "ID");
888         RNA_def_struct_ui_text(srna, "Brush", "Brush data-block for storing brush settings for painting and sculpting");
889         RNA_def_struct_ui_icon(srna, ICON_BRUSH_DATA);
890
891         /* enums */
892         prop = RNA_def_property(srna, "blend", PROP_ENUM, PROP_NONE);
893         RNA_def_property_enum_items(prop, prop_blend_items);
894         RNA_def_property_ui_text(prop, "Blending mode", "Brush blending mode");
895         RNA_def_property_update(prop, 0, "rna_Brush_update");
896
897         prop = RNA_def_property(srna, "sculpt_tool", PROP_ENUM, PROP_NONE);
898         RNA_def_property_enum_items(prop, rna_enum_brush_sculpt_tool_items);
899         RNA_def_property_ui_text(prop, "Sculpt Tool", "");
900         RNA_def_property_update(prop, 0, "rna_Brush_sculpt_tool_update");
901
902         prop = RNA_def_property(srna, "vertex_tool", PROP_ENUM, PROP_NONE);
903         RNA_def_property_enum_sdna(prop, NULL, "vertexpaint_tool");
904         RNA_def_property_enum_items(prop, rna_enum_brush_vertex_tool_items);
905         RNA_def_property_ui_text(prop, "Blending mode", "Brush blending mode");
906         RNA_def_property_update(prop, 0, "rna_Brush_vertex_tool_update");
907         
908         prop = RNA_def_property(srna, "image_tool", PROP_ENUM, PROP_NONE);
909         RNA_def_property_enum_sdna(prop, NULL, "imagepaint_tool");
910         RNA_def_property_enum_items(prop, rna_enum_brush_image_tool_items);
911         RNA_def_property_ui_text(prop, "Image Paint Tool", "");
912         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_Brush_imagepaint_tool_update");
913
914         prop = RNA_def_property(srna, "direction", PROP_ENUM, PROP_NONE);
915         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
916         RNA_def_property_enum_items(prop, prop_direction_items);
917         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Brush_direction_itemf");
918         RNA_def_property_ui_text(prop, "Direction", "");
919         RNA_def_property_update(prop, 0, "rna_Brush_update");
920
921         prop = RNA_def_property(srna, "stroke_method", PROP_ENUM, PROP_NONE);
922         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
923         RNA_def_property_enum_items(prop, sculpt_stroke_method_items);
924         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Brush_stroke_itemf");
925         RNA_def_property_ui_text(prop, "Stroke Method", "");
926         RNA_def_property_update(prop, 0, "rna_Brush_stroke_update");
927
928         prop = RNA_def_property(srna, "sculpt_plane", PROP_ENUM, PROP_NONE);
929         RNA_def_property_enum_items(prop, brush_sculpt_plane_items);
930         RNA_def_property_ui_text(prop, "Sculpt Plane", "");
931         RNA_def_property_update(prop, 0, "rna_Brush_update");
932
933         prop = RNA_def_property(srna, "mask_tool", PROP_ENUM, PROP_NONE);
934         RNA_def_property_enum_items(prop, brush_mask_tool_items);
935         RNA_def_property_ui_text(prop, "Mask Tool", "");
936         RNA_def_property_update(prop, 0, "rna_Brush_update");
937         
938         /* number values */
939         prop = RNA_def_property(srna, "size", PROP_INT, PROP_PIXEL);
940         RNA_def_property_int_funcs(prop, NULL, "rna_Brush_set_size", NULL);
941         RNA_def_property_range(prop, 1, MAX_BRUSH_PIXEL_RADIUS * 10);
942         RNA_def_property_ui_range(prop, 1, MAX_BRUSH_PIXEL_RADIUS, 1, -1);
943         RNA_def_property_ui_text(prop, "Radius", "Radius of the brush in pixels");
944         RNA_def_property_update(prop, 0, "rna_Brush_size_update");
945         
946         prop = RNA_def_property(srna, "unprojected_radius", PROP_FLOAT, PROP_DISTANCE);
947         RNA_def_property_float_funcs(prop, NULL, "rna_Brush_set_unprojected_radius", NULL);
948         RNA_def_property_range(prop, 0.001, FLT_MAX);
949         RNA_def_property_ui_range(prop, 0.001, 1, 0, -1);
950         RNA_def_property_ui_text(prop, "Unprojected Radius", "Radius of brush in Blender units");
951         RNA_def_property_update(prop, 0, "rna_Brush_size_update");
952
953         prop = RNA_def_property(srna, "jitter", PROP_FLOAT, PROP_NONE);
954         RNA_def_property_float_sdna(prop, NULL, "jitter");
955         RNA_def_property_range(prop, 0.0f, 1000.0f);
956         RNA_def_property_ui_range(prop, 0.0f, 2.0f, 0.1, 4);
957         RNA_def_property_ui_text(prop, "Jitter", "Jitter the position of the brush while painting");
958         RNA_def_property_update(prop, 0, "rna_Brush_update");
959
960         prop = RNA_def_property(srna, "jitter_absolute", PROP_INT, PROP_PIXEL);
961         RNA_def_property_int_sdna(prop, NULL, "jitter_absolute");
962         RNA_def_property_range(prop, 0, 1000000);
963         RNA_def_property_ui_text(prop, "Jitter", "Jitter the position of the brush in pixels while painting");
964         RNA_def_property_update(prop, 0, "rna_Brush_update");
965
966         prop = RNA_def_property(srna, "spacing", PROP_INT, PROP_PERCENTAGE);
967         RNA_def_property_int_sdna(prop, NULL, "spacing");
968         RNA_def_property_range(prop, 1, 1000);
969         RNA_def_property_ui_range(prop, 1, 500, 5, -1);
970         RNA_def_property_ui_text(prop, "Spacing", "Spacing between brush daubs as a percentage of brush diameter");
971         RNA_def_property_update(prop, 0, "rna_Brush_update");
972
973         prop = RNA_def_property(srna, "grad_spacing", PROP_INT, PROP_NONE);
974         RNA_def_property_int_sdna(prop, NULL, "gradient_spacing");
975         RNA_def_property_range(prop, 1, 10000);
976         RNA_def_property_ui_range(prop, 1, 10000, 5, -1);
977         RNA_def_property_ui_text(prop, "Gradient Spacing", "Spacing before brush gradient goes full circle");
978         RNA_def_property_update(prop, 0, "rna_Brush_update");
979
980         prop = RNA_def_property(srna, "smooth_stroke_radius", PROP_INT, PROP_NONE);
981         RNA_def_property_range(prop, 10, 200);
982         RNA_def_property_ui_text(prop, "Smooth Stroke Radius", "Minimum distance from last point before stroke continues");
983         RNA_def_property_update(prop, 0, "rna_Brush_update");
984
985         prop = RNA_def_property(srna, "smooth_stroke_factor", PROP_FLOAT, PROP_FACTOR);
986         RNA_def_property_range(prop, 0.5, 0.99);
987         RNA_def_property_ui_text(prop, "Smooth Stroke Factor", "Higher values give a smoother stroke");
988         RNA_def_property_update(prop, 0, "rna_Brush_update");
989         
990         prop = RNA_def_property(srna, "rate", PROP_FLOAT, PROP_NONE);
991         RNA_def_property_float_sdna(prop, NULL, "rate");
992         RNA_def_property_range(prop, 0.0001f, 10000.0f);
993         RNA_def_property_ui_range(prop, 0.01f, 1.0f, 1, 3);
994         RNA_def_property_ui_text(prop, "Rate", "Interval between paints for Airbrush");
995         RNA_def_property_update(prop, 0, "rna_Brush_update");
996         
997         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
998         RNA_def_property_range(prop, 0.0, 1.0);
999         RNA_def_property_float_sdna(prop, NULL, "rgb");
1000         RNA_def_property_ui_text(prop, "Color", "");
1001         RNA_def_property_update(prop, 0, "rna_Brush_update");
1002
1003         prop = RNA_def_property(srna, "secondary_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1004         RNA_def_property_range(prop, 0.0, 1.0);
1005         RNA_def_property_float_sdna(prop, NULL, "secondary_rgb");
1006         RNA_def_property_ui_text(prop, "Secondary Color", "");
1007         RNA_def_property_update(prop, 0, "rna_Brush_update");
1008
1009         prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_FACTOR);
1010         RNA_def_property_float_default(prop, 1.0f);
1011         RNA_def_property_range(prop, 0.0f, 1.0f);
1012         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
1013         RNA_def_property_ui_text(prop, "Weight", "Vertex weight when brush is applied");
1014         RNA_def_property_update(prop, 0, "rna_Brush_update");
1015
1016         prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_FACTOR);
1017         RNA_def_property_float_sdna(prop, NULL, "alpha");
1018         RNA_def_property_float_default(prop, 0.5f);
1019         RNA_def_property_range(prop, 0.0f, 10.0f);
1020         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
1021         RNA_def_property_ui_text(prop, "Strength", "How powerful the effect of the brush is when applied");
1022         RNA_def_property_update(prop, 0, "rna_Brush_update");
1023
1024         prop = RNA_def_property(srna, "plane_offset", PROP_FLOAT, PROP_DISTANCE);
1025         RNA_def_property_float_sdna(prop, NULL, "plane_offset");
1026         RNA_def_property_float_default(prop, 0);
1027         RNA_def_property_range(prop, -2.0f, 2.0f);
1028         RNA_def_property_ui_range(prop, -0.5f, 0.5f, 0.001, 3);
1029         RNA_def_property_ui_text(prop, "Plane Offset",
1030                                  "Adjust plane on which the brush acts towards or away from the object surface");
1031         RNA_def_property_update(prop, 0, "rna_Brush_update");
1032
1033         prop = RNA_def_property(srna, "plane_trim", PROP_FLOAT, PROP_DISTANCE);
1034         RNA_def_property_float_sdna(prop, NULL, "plane_trim");
1035         RNA_def_property_float_default(prop, 0.5f);
1036         RNA_def_property_range(prop, 0, 1.0f);
1037         RNA_def_property_ui_text(prop, "Plane Trim",
1038                                  "If a vertex is further away from offset plane than this, then it is not affected");
1039         RNA_def_property_update(prop, 0, "rna_Brush_update");
1040
1041         prop = RNA_def_property(srna, "height", PROP_FLOAT, PROP_DISTANCE);
1042         RNA_def_property_float_sdna(prop, NULL, "height");
1043         RNA_def_property_float_default(prop, 0.5f);
1044         RNA_def_property_range(prop, 0, 1.0f);
1045         RNA_def_property_ui_text(prop, "Brush Height", "Affectable height of brush (layer height for layer tool, i.e.)");
1046         RNA_def_property_update(prop, 0, "rna_Brush_update");
1047
1048         prop = RNA_def_property(srna, "texture_sample_bias", PROP_FLOAT, PROP_DISTANCE);
1049         RNA_def_property_float_sdna(prop, NULL, "texture_sample_bias");
1050         RNA_def_property_float_default(prop, 0);
1051         RNA_def_property_range(prop, -1, 1);
1052         RNA_def_property_ui_text(prop, "Texture Sample Bias", "Value added to texture samples");
1053         RNA_def_property_update(prop, 0, "rna_Brush_update");
1054
1055         prop = RNA_def_property(srna, "normal_weight", PROP_FLOAT, PROP_FACTOR);
1056         RNA_def_property_float_sdna(prop, NULL, "normal_weight");
1057         RNA_def_property_float_default(prop, 0);
1058         RNA_def_property_range(prop, 0.0f, 1.0f);
1059         RNA_def_property_ui_text(prop, "Normal Weight", "How much grab will pull vertexes out of surface during a grab");
1060         RNA_def_property_update(prop, 0, "rna_Brush_update");
1061
1062         prop = RNA_def_property(srna, "rake_factor", PROP_FLOAT, PROP_FACTOR);
1063         RNA_def_property_float_sdna(prop, NULL, "rake_factor");
1064         RNA_def_property_float_default(prop, 0);
1065         RNA_def_property_range(prop, 0.0f, 10.0f);
1066         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
1067         RNA_def_property_ui_text(prop, "Rake", "How much grab will follow cursor rotation");
1068         RNA_def_property_update(prop, 0, "rna_Brush_update");
1069
1070         prop = RNA_def_property(srna, "crease_pinch_factor", PROP_FLOAT, PROP_FACTOR);
1071         RNA_def_property_float_sdna(prop, NULL, "crease_pinch_factor");
1072         RNA_def_property_float_default(prop, 2.0f / 3.0f);
1073         RNA_def_property_range(prop, 0.0f, 1.0f);
1074         RNA_def_property_ui_text(prop, "Crease Brush Pinch Factor", "How much the crease brush pinches");
1075         RNA_def_property_update(prop, 0, "rna_Brush_update");
1076
1077         prop = RNA_def_property(srna, "auto_smooth_factor", PROP_FLOAT, PROP_FACTOR);
1078         RNA_def_property_float_sdna(prop, NULL, "autosmooth_factor");
1079         RNA_def_property_float_default(prop, 0);
1080         RNA_def_property_range(prop, 0.0f, 1.0f);
1081         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
1082         RNA_def_property_ui_text(prop, "Autosmooth", "Amount of smoothing to automatically apply to each stroke");
1083         RNA_def_property_update(prop, 0, "rna_Brush_update");
1084
1085         prop = RNA_def_property(srna, "stencil_pos", PROP_FLOAT, PROP_XYZ);
1086         RNA_def_property_float_sdna(prop, NULL, "stencil_pos");
1087         RNA_def_property_array(prop, 2);
1088         RNA_def_property_ui_text(prop, "Stencil Position", "Position of stencil in viewport");
1089         RNA_def_property_update(prop, 0, "rna_Brush_update");
1090
1091         prop = RNA_def_property(srna, "stencil_dimension", PROP_FLOAT, PROP_XYZ);
1092         RNA_def_property_float_sdna(prop, NULL, "stencil_dimension");
1093         RNA_def_property_array(prop, 2);
1094         RNA_def_property_ui_text(prop, "Stencil Dimensions", "Dimensions of stencil in viewport");
1095         RNA_def_property_update(prop, 0, "rna_Brush_update");
1096
1097         prop = RNA_def_property(srna, "mask_stencil_pos", PROP_FLOAT, PROP_XYZ);
1098         RNA_def_property_float_sdna(prop, NULL, "mask_stencil_pos");
1099         RNA_def_property_array(prop, 2);
1100         RNA_def_property_ui_text(prop, "Mask Stencil Position", "Position of mask stencil in viewport");
1101         RNA_def_property_update(prop, 0, "rna_Brush_update");
1102
1103         prop = RNA_def_property(srna, "mask_stencil_dimension", PROP_FLOAT, PROP_XYZ);
1104         RNA_def_property_float_sdna(prop, NULL, "mask_stencil_dimension");
1105         RNA_def_property_array(prop, 2);
1106         RNA_def_property_ui_text(prop, "Mask Stencil Dimensions", "Dimensions of mask stencil in viewport");
1107         RNA_def_property_update(prop, 0, "rna_Brush_update");
1108
1109         prop = RNA_def_property(srna, "sharp_threshold", PROP_FLOAT, PROP_NONE);
1110         RNA_def_property_range(prop, 0.0, 100.0);
1111         RNA_def_property_ui_range(prop, 0.0, 1.0, 1, 3);
1112         RNA_def_property_float_sdna(prop, NULL, "sharp_threshold");
1113         RNA_def_property_ui_text(prop, "Sharp Threshold", "Threshold below which, no sharpening is done");
1114         RNA_def_property_update(prop, 0, "rna_Brush_update");
1115
1116         prop = RNA_def_property(srna, "fill_threshold", PROP_FLOAT, PROP_NONE);
1117         RNA_def_property_range(prop, 0.0, 100.0);
1118         RNA_def_property_ui_range(prop, 0.0, 1.0, 1, 3);
1119         RNA_def_property_float_sdna(prop, NULL, "fill_threshold");
1120         RNA_def_property_ui_text(prop, "Fill Threshold", "Threshold above which filling is not propagated");
1121         RNA_def_property_update(prop, 0, "rna_Brush_update");
1122
1123         prop = RNA_def_property(srna, "blur_kernel_radius", PROP_INT, PROP_NONE);
1124         RNA_def_property_int_sdna(prop, NULL, "blur_kernel_radius");
1125         RNA_def_property_range(prop, 1, 10000);
1126         RNA_def_property_ui_range(prop, 1, 50, 1, -1);
1127         RNA_def_property_ui_text(prop, "Kernel Radius", "Radius of kernel used for soften and sharpen in pixels");
1128         RNA_def_property_update(prop, 0, "rna_Brush_update");
1129
1130         prop = RNA_def_property(srna, "blur_mode", PROP_ENUM, PROP_NONE);
1131         RNA_def_property_enum_items(prop, brush_blur_mode_items);
1132         RNA_def_property_ui_text(prop, "Blur Mode", "");
1133         RNA_def_property_update(prop, 0, "rna_Brush_update");
1134
1135         prop = RNA_def_property(srna, "falloff_angle", PROP_FLOAT, PROP_ANGLE);
1136         RNA_def_property_float_sdna(prop, NULL, "falloff_angle");
1137         RNA_def_property_range(prop, 0, M_PI / 2);
1138         RNA_def_property_ui_text(prop, "Falloff Angle",
1139                                  "Paint most on faces pointing towards the view according to this angle");
1140         RNA_def_property_update(prop, 0, "rna_Brush_update");
1141
1142         /* flag */
1143         /* This is an enum but its unlikely we add other shapes, so expose as a boolean. */
1144         prop = RNA_def_property(srna, "use_projected", PROP_BOOLEAN, PROP_NONE);
1145         RNA_def_property_boolean_sdna(prop, NULL, "falloff_shape", BRUSH_AIRBRUSH);
1146         RNA_def_property_ui_text(prop, "2D Falloff", "Apply brush influence in 2D circle instead of a sphere");
1147         RNA_def_property_update(prop, 0, "rna_Brush_update");
1148
1149         prop = RNA_def_property(srna, "use_airbrush", PROP_BOOLEAN, PROP_NONE);
1150         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_AIRBRUSH);
1151         RNA_def_property_ui_text(prop, "Airbrush", "Keep applying paint effect while holding mouse (spray)");
1152         RNA_def_property_update(prop, 0, "rna_Brush_update");
1153         
1154         prop = RNA_def_property(srna, "use_original_normal", PROP_BOOLEAN, PROP_NONE);
1155         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_ORIGINAL_NORMAL);
1156         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, true);
1157         RNA_def_property_ui_text(prop, "Original Normal",
1158                                  "When locked keep using normal of surface where stroke was initiated");
1159         RNA_def_property_update(prop, 0, "rna_Brush_update");
1160                 
1161         prop = RNA_def_property(srna, "use_pressure_strength", PROP_BOOLEAN, PROP_NONE);
1162         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_ALPHA_PRESSURE);
1163         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1164         RNA_def_property_ui_text(prop, "Strength Pressure", "Enable tablet pressure sensitivity for strength");
1165         RNA_def_property_update(prop, 0, "rna_Brush_update");
1166         
1167         prop = RNA_def_property(srna, "use_offset_pressure", PROP_BOOLEAN, PROP_NONE);
1168         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_OFFSET_PRESSURE);
1169         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1170         RNA_def_property_ui_text(prop, "Plane Offset Pressure", "Enable tablet pressure sensitivity for offset");
1171         RNA_def_property_update(prop, 0, "rna_Brush_update");
1172
1173         prop = RNA_def_property(srna, "use_pressure_size", PROP_BOOLEAN, PROP_NONE);
1174         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_SIZE_PRESSURE);
1175         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1176         RNA_def_property_ui_text(prop, "Size Pressure", "Enable tablet pressure sensitivity for size");
1177         RNA_def_property_update(prop, 0, "rna_Brush_update");
1178
1179         prop = RNA_def_property(srna, "use_gradient", PROP_BOOLEAN, PROP_NONE);
1180         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_USE_GRADIENT);
1181         RNA_def_property_boolean_funcs(prop, NULL, "rna_Brush_use_gradient_set");
1182         RNA_def_property_ui_text(prop, "Use Gradient", "Use Gradient by utilizing a sampling method");
1183         RNA_def_property_update(prop, 0, "rna_Brush_update");
1184
1185         prop = RNA_def_property(srna, "use_pressure_jitter", PROP_BOOLEAN, PROP_NONE);
1186         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_JITTER_PRESSURE);
1187         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1188         RNA_def_property_ui_text(prop, "Jitter Pressure", "Enable tablet pressure sensitivity for jitter");
1189         RNA_def_property_update(prop, 0, "rna_Brush_update");
1190
1191         prop = RNA_def_property(srna, "use_pressure_spacing", PROP_BOOLEAN, PROP_NONE);
1192         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_SPACING_PRESSURE);
1193         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1194         RNA_def_property_ui_text(prop, "Spacing Pressure", "Enable tablet pressure sensitivity for spacing");
1195         RNA_def_property_update(prop, 0, "rna_Brush_update");
1196
1197         prop = RNA_def_property(srna, "use_pressure_masking", PROP_ENUM, PROP_NONE);
1198         RNA_def_property_enum_sdna(prop, NULL, "mask_pressure");
1199         RNA_def_property_enum_items(prop, brush_mask_pressure_items);
1200         RNA_def_property_ui_text(prop, "Mask Pressure Mode", "Pen pressure makes texture influence smaller");
1201         RNA_def_property_update(prop, 0, "rna_Brush_update");
1202
1203         prop = RNA_def_property(srna, "use_inverse_smooth_pressure", PROP_BOOLEAN, PROP_NONE);
1204         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_INVERSE_SMOOTH_PRESSURE);
1205         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1206         RNA_def_property_ui_text(prop, "Inverse Smooth Pressure", "Lighter pressure causes more smoothing to be applied");
1207         RNA_def_property_update(prop, 0, "rna_Brush_update");
1208         
1209         prop = RNA_def_property(srna, "use_relative_jitter", PROP_BOOLEAN, PROP_NONE);
1210         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BRUSH_ABSOLUTE_JITTER);
1211         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, true);
1212         RNA_def_property_ui_text(prop, "Absolute Jitter", "Jittering happens in screen space, not relative to brush size");
1213         RNA_def_property_update(prop, 0, "rna_Brush_update");
1214
1215         prop = RNA_def_property(srna, "use_plane_trim", PROP_BOOLEAN, PROP_NONE);
1216         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_PLANE_TRIM);
1217         RNA_def_property_ui_text(prop, "Use Plane Trim", "Enable Plane Trim");
1218         RNA_def_property_update(prop, 0, "rna_Brush_update");
1219
1220         prop = RNA_def_property(srna, "use_frontface", PROP_BOOLEAN, PROP_NONE);
1221         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_FRONTFACE);
1222         RNA_def_property_ui_text(prop, "Use Front-Face", "Brush only affects vertexes that face the viewer");
1223         RNA_def_property_update(prop, 0, "rna_Brush_update");
1224
1225         prop = RNA_def_property(srna, "use_frontface_falloff", PROP_BOOLEAN, PROP_NONE);
1226         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_FRONTFACE_FALLOFF);
1227         RNA_def_property_ui_text(prop, "Use Front-Face Falloff", "Blend brush influence by how much they face the front");
1228         RNA_def_property_update(prop, 0, "rna_Brush_update");
1229
1230         prop = RNA_def_property(srna, "use_anchor", PROP_BOOLEAN, PROP_NONE);
1231         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_ANCHORED);
1232         RNA_def_property_ui_text(prop, "Anchored", "Keep the brush anchored to the initial location");
1233         RNA_def_property_update(prop, 0, "rna_Brush_update");
1234
1235         prop = RNA_def_property(srna, "use_space", PROP_BOOLEAN, PROP_NONE);
1236         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_SPACE);
1237         RNA_def_property_ui_text(prop, "Space", "Limit brush application to the distance specified by spacing");
1238         RNA_def_property_update(prop, 0, "rna_Brush_update");
1239
1240         prop = RNA_def_property(srna, "use_line", PROP_BOOLEAN, PROP_NONE);
1241         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_LINE);
1242         RNA_def_property_ui_text(prop, "Line", "Draw a line with dabs separated according to spacing");
1243         RNA_def_property_update(prop, 0, "rna_Brush_update");
1244
1245         prop = RNA_def_property(srna, "use_curve", PROP_BOOLEAN, PROP_NONE);
1246         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_CURVE);
1247         RNA_def_property_ui_text(prop, "Curve", "Define the stroke curve with a bezier curve. Dabs are separated according to spacing");
1248         RNA_def_property_update(prop, 0, "rna_Brush_update");
1249
1250         prop = RNA_def_property(srna, "use_smooth_stroke", PROP_BOOLEAN, PROP_NONE);
1251         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_SMOOTH_STROKE);
1252         RNA_def_property_ui_text(prop, "Smooth Stroke", "Brush lags behind mouse and follows a smoother path");
1253         RNA_def_property_update(prop, 0, "rna_Brush_update");
1254
1255         prop = RNA_def_property(srna, "use_persistent", PROP_BOOLEAN, PROP_NONE);
1256         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_PERSISTENT);
1257         RNA_def_property_ui_text(prop, "Persistent", "Sculpt on a persistent layer of the mesh");
1258         RNA_def_property_update(prop, 0, "rna_Brush_update");
1259
1260         prop = RNA_def_property(srna, "use_accumulate", PROP_BOOLEAN, PROP_NONE);
1261         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_ACCUMULATE);
1262         RNA_def_property_ui_text(prop, "Accumulate", "Accumulate stroke daubs on top of each other");
1263         RNA_def_property_update(prop, 0, "rna_Brush_update");
1264         
1265         prop = RNA_def_property(srna, "use_space_attenuation", PROP_BOOLEAN, PROP_NONE);
1266         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_SPACE_ATTEN);
1267         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, true);
1268         RNA_def_property_ui_text(prop, "Use Automatic Strength Adjustment",
1269                                  "Automatically adjust strength to give consistent results for different spacings");
1270         RNA_def_property_update(prop, 0, "rna_Brush_update");
1271
1272         /* adaptive space is not implemented yet */
1273         prop = RNA_def_property(srna, "use_adaptive_space", PROP_BOOLEAN, PROP_NONE);
1274         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_ADAPTIVE_SPACE);
1275         RNA_def_property_ui_text(prop, "Adaptive Spacing",
1276                                  "Space daubs according to surface orientation instead of screen space");
1277         RNA_def_property_update(prop, 0, "rna_Brush_update");
1278
1279         prop = RNA_def_property(srna, "use_locked_size", PROP_BOOLEAN, PROP_NONE);
1280         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_LOCK_SIZE);
1281         RNA_def_property_ui_text(prop, "Use Blender Units",
1282                                  "When locked brush stays same size relative to object; when unlocked brush size is "
1283                                  "given in pixels");
1284         RNA_def_property_update(prop, 0, "rna_Brush_update");
1285
1286         prop = RNA_def_property(srna, "use_edge_to_edge", PROP_BOOLEAN, PROP_NONE);
1287         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_EDGE_TO_EDGE);
1288         RNA_def_property_ui_text(prop, "Edge-to-edge", "Drag anchor brush from edge-to-edge");
1289         RNA_def_property_update(prop, 0, "rna_Brush_update");
1290
1291         prop = RNA_def_property(srna, "use_restore_mesh", PROP_BOOLEAN, PROP_NONE);
1292         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_DRAG_DOT);
1293         RNA_def_property_ui_text(prop, "Restore Mesh", "Allow a single dot to be carefully positioned");
1294         RNA_def_property_update(prop, 0, "rna_Brush_update");
1295
1296         /* only for projection paint & vertex paint, TODO, other paint modes */
1297         prop = RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
1298         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BRUSH_LOCK_ALPHA);
1299         RNA_def_property_ui_text(prop, "Alpha", "When this is disabled, lock alpha while painting");
1300         RNA_def_property_update(prop, 0, "rna_Brush_update");
1301
1302         prop = RNA_def_property(srna, "curve", PROP_POINTER, PROP_NONE);
1303         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1304         RNA_def_property_ui_text(prop, "Curve", "Editable falloff curve");
1305         RNA_def_property_update(prop, 0, "rna_Brush_update");
1306
1307         prop = RNA_def_property(srna, "paint_curve", PROP_POINTER, PROP_NONE);
1308         RNA_def_property_flag(prop, PROP_EDITABLE);
1309         RNA_def_property_ui_text(prop, "Paint Curve", "Active Paint Curve");
1310         RNA_def_property_update(prop, 0, "rna_Brush_update");
1311
1312         prop = RNA_def_property(srna, "gradient", PROP_POINTER, PROP_NEVER_NULL);
1313         RNA_def_property_pointer_sdna(prop, NULL, "gradient");
1314         RNA_def_property_struct_type(prop, "ColorRamp");
1315         RNA_def_property_ui_text(prop, "Gradient", "");
1316         RNA_def_property_update(prop, 0, "rna_Brush_update");
1317
1318         /* gradient source */
1319         prop = RNA_def_property(srna, "gradient_stroke_mode", PROP_ENUM, PROP_NONE);
1320         RNA_def_property_enum_items(prop, brush_gradient_items);
1321         RNA_def_property_ui_text(prop, "Gradient Stroke Mode", "");
1322         RNA_def_property_update(prop, 0, "rna_Brush_update");
1323
1324         prop = RNA_def_property(srna, "gradient_fill_mode", PROP_ENUM, PROP_NONE);
1325         RNA_def_property_enum_items(prop, brush_gradient_fill_items);
1326         RNA_def_property_ui_text(prop, "Gradient Fill Mode", "");
1327         RNA_def_property_update(prop, 0, "rna_Brush_update");
1328
1329         /* overlay flags */
1330         prop = RNA_def_property(srna, "use_primary_overlay", PROP_BOOLEAN, PROP_NONE);
1331         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_PRIMARY);
1332         RNA_def_property_ui_text(prop, "Use Texture Overlay", "Show texture in viewport");
1333         RNA_def_property_update(prop, 0, "rna_Brush_update");
1334
1335         prop = RNA_def_property(srna, "use_secondary_overlay", PROP_BOOLEAN, PROP_NONE);
1336         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_SECONDARY);
1337         RNA_def_property_ui_text(prop, "Use Texture Overlay", "Show texture in viewport");
1338         RNA_def_property_update(prop, 0, "rna_Brush_update");
1339
1340         prop = RNA_def_property(srna, "use_cursor_overlay", PROP_BOOLEAN, PROP_NONE);
1341         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_CURSOR);
1342         RNA_def_property_ui_text(prop, "Use Cursor Overlay", "Show cursor in viewport");
1343         RNA_def_property_update(prop, 0, "rna_Brush_update");
1344
1345         prop = RNA_def_property(srna, "use_cursor_overlay_override", PROP_BOOLEAN, PROP_NONE);
1346         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_CURSOR_OVERRIDE_ON_STROKE);
1347         RNA_def_property_ui_text(prop, "Override Overlay", "Don't show overlay during a stroke");
1348         RNA_def_property_update(prop, 0, "rna_Brush_update");
1349
1350         prop = RNA_def_property(srna, "use_primary_overlay_override", PROP_BOOLEAN, PROP_NONE);
1351         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_PRIMARY_OVERRIDE_ON_STROKE);
1352         RNA_def_property_ui_text(prop, "Override Overlay", "Don't show overlay during a stroke");
1353         RNA_def_property_update(prop, 0, "rna_Brush_update");
1354
1355         prop = RNA_def_property(srna, "use_secondary_overlay_override", PROP_BOOLEAN, PROP_NONE);
1356         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_SECONDARY_OVERRIDE_ON_STROKE);
1357         RNA_def_property_ui_text(prop, "Override Overlay", "Don't show overlay during a stroke");
1358         RNA_def_property_update(prop, 0, "rna_Brush_update");
1359
1360         /* paint mode flags */
1361         prop = RNA_def_property(srna, "use_paint_sculpt", PROP_BOOLEAN, PROP_NONE);
1362         RNA_def_property_boolean_sdna(prop, NULL, "ob_mode", OB_MODE_SCULPT);
1363         RNA_def_property_ui_text(prop, "Use Sculpt", "Use this brush in sculpt mode");
1364
1365         prop = RNA_def_property(srna, "use_paint_vertex", PROP_BOOLEAN, PROP_NONE);
1366         RNA_def_property_boolean_sdna(prop, NULL, "ob_mode", OB_MODE_VERTEX_PAINT);
1367         RNA_def_property_ui_text(prop, "Use Vertex", "Use this brush in vertex paint mode");
1368
1369         prop = RNA_def_property(srna, "use_paint_weight", PROP_BOOLEAN, PROP_NONE);
1370         RNA_def_property_boolean_sdna(prop, NULL, "ob_mode", OB_MODE_WEIGHT_PAINT);
1371         RNA_def_property_ui_text(prop, "Use Weight", "Use this brush in weight paint mode");
1372
1373         prop = RNA_def_property(srna, "use_paint_image", PROP_BOOLEAN, PROP_NONE);
1374         RNA_def_property_boolean_sdna(prop, NULL, "ob_mode", OB_MODE_TEXTURE_PAINT);
1375         RNA_def_property_ui_text(prop, "Use Texture", "Use this brush in texture paint mode");
1376
1377         /* texture */
1378         prop = RNA_def_property(srna, "texture_slot", PROP_POINTER, PROP_NONE);
1379         RNA_def_property_struct_type(prop, "BrushTextureSlot");
1380         RNA_def_property_pointer_sdna(prop, NULL, "mtex");
1381         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1382         RNA_def_property_ui_text(prop, "Texture Slot", "");
1383         
1384         prop = RNA_def_property(srna, "texture", PROP_POINTER, PROP_NONE);
1385         RNA_def_property_pointer_sdna(prop, NULL, "mtex.tex");
1386         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_CONTEXT_UPDATE);
1387         RNA_def_property_ui_text(prop, "Texture", "");
1388         RNA_def_property_update(prop, NC_TEXTURE, "rna_Brush_main_tex_update");
1389
1390         prop = RNA_def_property(srna, "mask_texture_slot", PROP_POINTER, PROP_NONE);
1391         RNA_def_property_struct_type(prop, "BrushTextureSlot");
1392         RNA_def_property_pointer_sdna(prop, NULL, "mask_mtex");
1393         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1394         RNA_def_property_ui_text(prop, "Mask Texture Slot", "");
1395
1396         prop = RNA_def_property(srna, "mask_texture", PROP_POINTER, PROP_NONE);
1397         RNA_def_property_pointer_sdna(prop, NULL, "mask_mtex.tex");
1398         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_CONTEXT_UPDATE);
1399         RNA_def_property_ui_text(prop, "Mask Texture", "");
1400         RNA_def_property_update(prop, NC_TEXTURE, "rna_Brush_secondary_tex_update");
1401
1402         prop = RNA_def_property(srna, "texture_overlay_alpha", PROP_INT, PROP_PERCENTAGE);
1403         RNA_def_property_int_sdna(prop, NULL, "texture_overlay_alpha");
1404         RNA_def_property_range(prop, 0, 100);
1405         RNA_def_property_ui_text(prop, "Texture Overlay Alpha", "");
1406         RNA_def_property_update(prop, 0, "rna_Brush_update");
1407
1408         prop = RNA_def_property(srna, "mask_overlay_alpha", PROP_INT, PROP_PERCENTAGE);
1409         RNA_def_property_int_sdna(prop, NULL, "mask_overlay_alpha");
1410         RNA_def_property_range(prop, 0, 100);
1411         RNA_def_property_ui_text(prop, "Mask Texture Overlay Alpha", "");
1412         RNA_def_property_update(prop, 0, "rna_Brush_update");
1413
1414         prop = RNA_def_property(srna, "cursor_overlay_alpha", PROP_INT, PROP_PERCENTAGE);
1415         RNA_def_property_int_sdna(prop, NULL, "cursor_overlay_alpha");
1416         RNA_def_property_range(prop, 0, 100);
1417         RNA_def_property_ui_text(prop, "Mask Texture Overlay Alpha", "");
1418         RNA_def_property_update(prop, 0, "rna_Brush_update");
1419
1420         prop = RNA_def_property(srna, "cursor_color_add", PROP_FLOAT, PROP_COLOR);
1421         RNA_def_property_float_sdna(prop, NULL, "add_col");
1422         RNA_def_property_array(prop, 3);
1423         RNA_def_property_ui_text(prop, "Add Color", "Color of cursor when adding");
1424         RNA_def_property_update(prop, 0, "rna_Brush_update");
1425
1426         prop = RNA_def_property(srna, "cursor_color_subtract", PROP_FLOAT, PROP_COLOR);
1427         RNA_def_property_float_sdna(prop, NULL, "sub_col");
1428         RNA_def_property_array(prop, 3);
1429         RNA_def_property_ui_text(prop, "Subtract Color", "Color of cursor when subtracting");
1430         RNA_def_property_update(prop, 0, "rna_Brush_update");
1431
1432         prop = RNA_def_property(srna, "use_custom_icon", PROP_BOOLEAN, PROP_NONE);
1433         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_CUSTOM_ICON);
1434         RNA_def_property_ui_text(prop, "Custom Icon", "Set the brush icon from an image file");
1435         RNA_def_property_update(prop, 0, "rna_Brush_icon_update");
1436
1437         prop = RNA_def_property(srna, "icon_filepath", PROP_STRING, PROP_FILEPATH);
1438         RNA_def_property_string_sdna(prop, NULL, "icon_filepath");
1439         RNA_def_property_ui_text(prop, "Brush Icon Filepath", "File path to brush icon");
1440         RNA_def_property_update(prop, 0, "rna_Brush_icon_update");
1441
1442         /* clone tool */
1443         prop = RNA_def_property(srna, "clone_image", PROP_POINTER, PROP_NONE);
1444         RNA_def_property_pointer_sdna(prop, NULL, "clone.image");
1445         RNA_def_property_flag(prop, PROP_EDITABLE);
1446         RNA_def_property_ui_text(prop, "Clone Image", "Image for clone tool");
1447         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_Brush_update");
1448         
1449         prop = RNA_def_property(srna, "clone_alpha", PROP_FLOAT, PROP_NONE);
1450         RNA_def_property_float_sdna(prop, NULL, "clone.alpha");
1451         RNA_def_property_range(prop, 0.0f, 1.0f);
1452         RNA_def_property_ui_text(prop, "Clone Alpha", "Opacity of clone image display");
1453         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_Brush_update");
1454
1455         prop = RNA_def_property(srna, "clone_offset", PROP_FLOAT, PROP_XYZ);
1456         RNA_def_property_float_sdna(prop, NULL, "clone.offset");
1457         RNA_def_property_ui_text(prop, "Clone Offset", "");
1458         RNA_def_property_ui_range(prop, -1.0f, 1.0f, 10.0f, 3);
1459         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_Brush_update");
1460
1461         prop = RNA_def_property(srna, "brush_capabilities", PROP_POINTER, PROP_NONE);
1462         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1463         RNA_def_property_struct_type(prop, "BrushCapabilities");
1464         RNA_def_property_pointer_funcs(prop, "rna_Brush_capabilities_get", NULL, NULL, NULL);
1465         RNA_def_property_ui_text(prop, "Brush Capabilities", "Brush's capabilities");
1466
1467         /* brush capabilities (mode-dependent) */
1468         prop = RNA_def_property(srna, "sculpt_capabilities", PROP_POINTER, PROP_NONE);
1469         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1470         RNA_def_property_struct_type(prop, "SculptToolCapabilities");
1471         RNA_def_property_pointer_funcs(prop, "rna_Sculpt_tool_capabilities_get", NULL, NULL, NULL);
1472         RNA_def_property_ui_text(prop, "Sculpt Capabilities", "Brush's capabilities in sculpt mode");
1473
1474         prop = RNA_def_property(srna, "image_paint_capabilities", PROP_POINTER, PROP_NONE);
1475         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1476         RNA_def_property_struct_type(prop, "ImapaintToolCapabilities");
1477         RNA_def_property_pointer_funcs(prop, "rna_Imapaint_tool_capabilities_get", NULL, NULL, NULL);
1478         RNA_def_property_ui_text(prop, "Image Painting Capabilities", "Brush's capabilities in image paint mode");
1479 }
1480
1481
1482 /* A brush stroke is a list of changes to the brush that
1483  * can occur during a stroke
1484  *
1485  *  o 3D location of the brush
1486  *  o 2D mouse location
1487  *  o Tablet pressure
1488  *  o Direction flip
1489  *  o Tool switch
1490  *  o Time
1491  */
1492 static void rna_def_operator_stroke_element(BlenderRNA *brna)
1493 {
1494         StructRNA *srna;
1495         PropertyRNA *prop;
1496
1497         srna = RNA_def_struct(brna, "OperatorStrokeElement", "PropertyGroup");
1498         RNA_def_struct_ui_text(srna, "Operator Stroke Element", "");
1499
1500         prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_XYZ);
1501         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1502         RNA_def_property_array(prop, 3);
1503         RNA_def_property_ui_text(prop, "Location", "");
1504
1505         prop = RNA_def_property(srna, "mouse", PROP_FLOAT, PROP_XYZ);
1506         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1507         RNA_def_property_array(prop, 2);
1508         RNA_def_property_ui_text(prop, "Mouse", "");
1509
1510         prop = RNA_def_property(srna, "pressure", PROP_FLOAT, PROP_NONE);
1511         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1512         RNA_def_property_range(prop, 0.0f, 1.0f);
1513         RNA_def_property_ui_text(prop, "Pressure", "Tablet pressure");
1514
1515         prop = RNA_def_property(srna, "size", PROP_FLOAT, PROP_NONE);
1516         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1517         RNA_def_property_range(prop, 0.0f, FLT_MAX);
1518         RNA_def_property_ui_text(prop, "Brush Size", "Brush Size in screen space");
1519
1520         prop = RNA_def_property(srna, "pen_flip", PROP_BOOLEAN, PROP_NONE);
1521         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1522         RNA_def_property_ui_text(prop, "Flip", "");
1523
1524         /* used in uv painting */
1525         prop = RNA_def_property(srna, "time", PROP_FLOAT, PROP_UNSIGNED);
1526         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1527         RNA_def_property_ui_text(prop, "Time", "");
1528         
1529         /* used for Grease Pencil sketching sessions */
1530         prop = RNA_def_property(srna, "is_start", PROP_BOOLEAN, PROP_NONE);
1531         RNA_def_property_flag(prop, PROP_IDPROPERTY);
1532         RNA_def_property_ui_text(prop, "Is Stroke Start", "");
1533
1534         /* XXX: Tool (this will be for pressing a modifier key for a different brush,
1535          *      e.g. switching to a Smooth brush in the middle of the stroke */
1536
1537         /* XXX: i don't think blender currently supports the ability to properly do a remappable modifier
1538          *      in the middle of a stroke */
1539 }
1540
1541 void RNA_def_brush(BlenderRNA *brna)
1542 {
1543         rna_def_brush(brna);
1544         rna_def_brush_capabilities(brna);
1545         rna_def_sculpt_capabilities(brna);
1546         rna_def_image_paint_capabilities(brna);
1547         rna_def_brush_texture_slot(brna);
1548         rna_def_operator_stroke_element(brna);
1549 }
1550
1551 #endif