GPencil: Changes in Fill and new 3D Cursor View Plane
[blender.git] / source / blender / makesrna / intern / rna_brush.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup RNA
19  */
20
21 #include <stdlib.h>
22 #include <assert.h>
23
24 #include "DNA_brush_types.h"
25 #include "DNA_texture_types.h"
26 #include "DNA_scene_types.h"
27 #include "DNA_object_types.h"
28 #include "DNA_workspace_types.h"
29 #include "DNA_gpencil_types.h"
30
31 #include "BLI_math.h"
32
33 #include "RNA_define.h"
34 #include "RNA_enum_types.h"
35
36 #include "rna_internal.h"
37
38 #include "IMB_imbuf.h"
39
40 #include "WM_types.h"
41
42 static const EnumPropertyItem prop_direction_items[] = {
43         {0, "ADD", ICON_ADD, "Add", "Add effect of brush"},
44         {BRUSH_DIR_IN, "SUBTRACT", ICON_REMOVE, "Subtract", "Subtract effect of brush"},
45         {0, NULL, 0, NULL, NULL},
46 };
47
48 static const EnumPropertyItem sculpt_stroke_method_items[] = {
49         {0, "DOTS", 0, "Dots", "Apply paint on each mouse move step"},
50         {BRUSH_DRAG_DOT, "DRAG_DOT", 0, "Drag Dot", "Allows a single dot to be carefully positioned"},
51         {BRUSH_SPACE, "SPACE", 0, "Space", "Limit brush application to the distance specified by spacing"},
52         {BRUSH_AIRBRUSH, "AIRBRUSH", 0, "Airbrush", "Keep applying paint effect while holding mouse (spray)"},
53         {BRUSH_ANCHORED, "ANCHORED", 0, "Anchored", "Keep the brush anchored to the initial location"},
54         {BRUSH_LINE, "LINE", 0, "Line", "Draw a line with dabs separated according to spacing"},
55         {BRUSH_CURVE, "CURVE", 0, "Curve",
56                       "Define the stroke curve with a bezier curve (dabs are separated according to spacing)"},
57         {0, NULL, 0, NULL, NULL},
58 };
59
60
61 const EnumPropertyItem rna_enum_brush_sculpt_tool_items[] = {
62         {SCULPT_TOOL_DRAW, "DRAW", ICON_BRUSH_SCULPT_DRAW, "Draw", ""},
63         {SCULPT_TOOL_CLAY, "CLAY", ICON_BRUSH_CLAY, "Clay", ""},
64         {SCULPT_TOOL_CLAY_STRIPS, "CLAY_STRIPS", ICON_BRUSH_CLAY_STRIPS, "Clay Strips", ""},
65         {SCULPT_TOOL_LAYER, "LAYER", ICON_BRUSH_LAYER, "Layer", ""},
66         {SCULPT_TOOL_INFLATE, "INFLATE", ICON_BRUSH_INFLATE, "Inflate", ""},
67         {SCULPT_TOOL_BLOB, "BLOB", ICON_BRUSH_BLOB, "Blob", ""},
68         {SCULPT_TOOL_CREASE, "CREASE", ICON_BRUSH_CREASE, "Crease", ""},
69         {0, "", 0, NULL, NULL},
70         {SCULPT_TOOL_SMOOTH, "SMOOTH", ICON_BRUSH_SMOOTH, "Smooth", ""},
71         {SCULPT_TOOL_FLATTEN, "FLATTEN", ICON_BRUSH_FLATTEN, "Flatten", ""},
72         {SCULPT_TOOL_FILL, "FILL", ICON_BRUSH_FILL, "Fill", ""},
73         {SCULPT_TOOL_SCRAPE, "SCRAPE", ICON_BRUSH_SCRAPE, "Scrape", ""},
74         {SCULPT_TOOL_PINCH, "PINCH", ICON_BRUSH_PINCH, "Pinch", ""},
75         {0, "", 0, NULL, NULL},
76         {SCULPT_TOOL_GRAB, "GRAB", ICON_BRUSH_GRAB, "Grab", ""},
77         {SCULPT_TOOL_SNAKE_HOOK, "SNAKE_HOOK", ICON_BRUSH_SNAKE_HOOK, "Snake Hook", ""},
78         {SCULPT_TOOL_THUMB, "THUMB", ICON_BRUSH_THUMB, "Thumb", ""},
79         {SCULPT_TOOL_NUDGE, "NUDGE", ICON_BRUSH_NUDGE, "Nudge", ""},
80         {SCULPT_TOOL_ROTATE, "ROTATE", ICON_BRUSH_ROTATE, "Rotate", ""},
81         {0, "", 0, NULL, NULL},
82         {SCULPT_TOOL_MASK, "MASK", ICON_BRUSH_MASK, "Mask", ""},
83         {SCULPT_TOOL_SIMPLIFY, "SIMPLIFY", ICON_BRUSH_SUBTRACT /* icon TODO */, "Simplify", ""},
84         {0, NULL, 0, NULL, NULL},
85 };
86
87 const EnumPropertyItem rna_enum_brush_vertex_tool_items[] = {
88         {VPAINT_TOOL_DRAW, "DRAW", ICON_BRUSH_MIX, "Draw", ""},
89         {VPAINT_TOOL_BLUR, "BLUR", ICON_BRUSH_BLUR, "Blur", ""},
90         {VPAINT_TOOL_AVERAGE, "AVERAGE", ICON_BRUSH_BLUR, "Average", ""},
91         {VPAINT_TOOL_SMEAR, "SMEAR", ICON_BRUSH_BLUR, "Smear", ""},
92         {0, NULL, 0, NULL, NULL},
93 };
94
95 const EnumPropertyItem rna_enum_brush_weight_tool_items[] = {
96         {WPAINT_TOOL_DRAW, "DRAW", ICON_BRUSH_MIX, "Draw", ""},
97         {WPAINT_TOOL_BLUR, "BLUR", ICON_BRUSH_BLUR, "Blur", ""},
98         {WPAINT_TOOL_AVERAGE, "AVERAGE", ICON_BRUSH_BLUR, "Average", ""},
99         {WPAINT_TOOL_SMEAR, "SMEAR", ICON_BRUSH_BLUR, "Smear", ""},
100         {0, NULL, 0, NULL, NULL},
101 };
102
103 const EnumPropertyItem rna_enum_brush_image_tool_items[] = {
104         {PAINT_TOOL_DRAW, "DRAW", ICON_BRUSH_TEXDRAW, "Draw", ""},
105         {PAINT_TOOL_SOFTEN, "SOFTEN", ICON_BRUSH_SOFTEN, "Soften", ""},
106         {PAINT_TOOL_SMEAR, "SMEAR", ICON_BRUSH_SMEAR, "Smear", ""},
107         {PAINT_TOOL_CLONE, "CLONE", ICON_BRUSH_CLONE, "Clone", ""},
108         {PAINT_TOOL_FILL, "FILL", ICON_BRUSH_TEXFILL, "Fill", ""},
109         {PAINT_TOOL_MASK, "MASK", ICON_BRUSH_TEXMASK, "Mask", ""},
110         {0, NULL, 0, NULL, NULL},
111 };
112
113 const EnumPropertyItem rna_enum_brush_gpencil_types_items[] = {
114         {GPAINT_TOOL_DRAW, "DRAW", ICON_STROKE, "Draw", "The brush is of type used for drawing strokes"},
115         {GPAINT_TOOL_FILL, "FILL", ICON_COLOR, "Fill", "The brush is of type used for filling areas"},
116         {GPAINT_TOOL_ERASE, "ERASE", ICON_PANEL_CLOSE, "Erase", "The brush is used for erasing strokes"},
117         {0, NULL, 0, NULL, NULL},
118 };
119
120 #ifndef RNA_RUNTIME
121 static EnumPropertyItem rna_enum_gpencil_brush_eraser_modes_items[] = {
122         {GP_BRUSH_ERASER_SOFT, "SOFT", 0, "Soft", "Use soft eraser"},
123         {GP_BRUSH_ERASER_HARD, "HARD", 0, "Hard", "Use hard eraser"},
124         {GP_BRUSH_ERASER_STROKE, "STROKE", 0, "Stroke", "Use stroke eraser"},
125         {0, NULL, 0, NULL, NULL},
126 };
127
128 static EnumPropertyItem rna_enum_gpencil_fill_draw_modes_items[] = {
129         {GP_FILL_DMODE_BOTH, "BOTH", 0, "Default", "Use both visible strokes and edit lines as fill boundary limits"},
130         {GP_FILL_DMODE_STROKE, "STROKE", 0, "Strokes", "Use visible strokes as fill boundary limits"},
131         {GP_FILL_DMODE_CONTROL, "CONTROL", 0, "Edit Lines", "Use edit lines as fill boundary limits"},
132         {0, NULL, 0, NULL, NULL}
133 };
134
135 static EnumPropertyItem rna_enum_gpencil_brush_icons_items[] = {
136         {GP_BRUSH_ICON_PENCIL, "PENCIL", ICON_GPBRUSH_PENCIL, "Pencil", ""},
137         {GP_BRUSH_ICON_PEN, "PEN", ICON_GPBRUSH_PEN, "Pen", ""},
138         {GP_BRUSH_ICON_INK, "INK", ICON_GPBRUSH_INK, "Ink", ""},
139         {GP_BRUSH_ICON_INKNOISE, "INKNOISE", ICON_GPBRUSH_INKNOISE, "Ink Noise", ""},
140         {GP_BRUSH_ICON_BLOCK, "BLOCK", ICON_GPBRUSH_BLOCK, "Block", ""},
141         {GP_BRUSH_ICON_MARKER, "MARKER", ICON_GPBRUSH_MARKER, "Marker", ""},
142         {GP_BRUSH_ICON_FILL, "FILL", ICON_GPBRUSH_FILL, "Fill", ""},
143         {GP_BRUSH_ICON_ERASE_SOFT, "SOFT", ICON_GPBRUSH_ERASE_SOFT, "Eraser Soft", ""},
144         {GP_BRUSH_ICON_ERASE_HARD, "HARD", ICON_GPBRUSH_ERASE_HARD, "Eraser Hard", ""},
145         {GP_BRUSH_ICON_ERASE_STROKE, "STROKE", ICON_GPBRUSH_ERASE_STROKE, "Eraser Stroke", ""},
146         {0, NULL, 0, NULL, NULL},
147 };
148 #endif
149
150
151 #ifdef RNA_RUNTIME
152
153 #include "MEM_guardedalloc.h"
154
155 #include "RNA_access.h"
156
157 #include "BKE_colorband.h"
158 #include "BKE_brush.h"
159 #include "BKE_icons.h"
160 #include "BKE_gpencil.h"
161 #include "BKE_paint.h"
162
163 #include "WM_api.h"
164
165 static bool rna_BrushCapabilitiesSculpt_has_accumulate_get(PointerRNA *ptr)
166 {
167         Brush *br = (Brush *)ptr->data;
168         return SCULPT_TOOL_HAS_ACCUMULATE(br->sculpt_tool);
169 }
170
171 static bool rna_BrushCapabilitiesSculpt_has_topology_rake_get(PointerRNA *ptr)
172 {
173         Brush *br = (Brush *)ptr->data;
174         return SCULPT_TOOL_HAS_TOPOLOGY_RAKE(br->sculpt_tool);
175 }
176
177 static bool rna_BrushCapabilitiesSculpt_has_auto_smooth_get(PointerRNA *ptr)
178 {
179         Brush *br = (Brush *)ptr->data;
180         return !ELEM(br->sculpt_tool, SCULPT_TOOL_MASK, SCULPT_TOOL_SMOOTH);
181 }
182
183 static bool rna_BrushCapabilitiesSculpt_has_height_get(PointerRNA *ptr)
184 {
185         Brush *br = (Brush *)ptr->data;
186         return br->sculpt_tool == SCULPT_TOOL_LAYER;
187 }
188
189 static bool rna_BrushCapabilitiesSculpt_has_jitter_get(PointerRNA *ptr)
190 {
191         Brush *br = (Brush *)ptr->data;
192         return (!(br->flag & BRUSH_ANCHORED) &&
193                 !(br->flag & BRUSH_DRAG_DOT) &&
194                 !ELEM(br->sculpt_tool,
195                       SCULPT_TOOL_GRAB, SCULPT_TOOL_ROTATE,
196                       SCULPT_TOOL_SNAKE_HOOK, SCULPT_TOOL_THUMB));
197 }
198
199 static bool rna_BrushCapabilitiesSculpt_has_normal_weight_get(PointerRNA *ptr)
200 {
201         Brush *br = (Brush *)ptr->data;
202         return SCULPT_TOOL_HAS_NORMAL_WEIGHT(br->sculpt_tool);
203 }
204
205 static bool rna_BrushCapabilitiesSculpt_has_rake_factor_get(PointerRNA *ptr)
206 {
207         Brush *br = (Brush *)ptr->data;
208         return SCULPT_TOOL_HAS_RAKE(br->sculpt_tool);
209 }
210
211 static bool rna_BrushCapabilities_has_overlay_get(PointerRNA *ptr)
212 {
213         Brush *br = (Brush *)ptr->data;
214         return ELEM(br->mtex.brush_map_mode,
215                     MTEX_MAP_MODE_VIEW,
216                     MTEX_MAP_MODE_TILED,
217                     MTEX_MAP_MODE_STENCIL);
218 }
219
220 static bool rna_BrushCapabilitiesSculpt_has_persistence_get(PointerRNA *ptr)
221 {
222         Brush *br = (Brush *)ptr->data;
223         return br->sculpt_tool == SCULPT_TOOL_LAYER;
224 }
225
226 static bool rna_BrushCapabilitiesSculpt_has_pinch_factor_get(PointerRNA *ptr)
227 {
228         Brush *br = (Brush *)ptr->data;
229         return ELEM(br->sculpt_tool, SCULPT_TOOL_BLOB, SCULPT_TOOL_CREASE, SCULPT_TOOL_SNAKE_HOOK);
230 }
231
232 static bool rna_BrushCapabilitiesSculpt_has_plane_offset_get(PointerRNA *ptr)
233 {
234         Brush *br = (Brush *)ptr->data;
235         return ELEM(br->sculpt_tool, SCULPT_TOOL_CLAY, SCULPT_TOOL_CLAY_STRIPS,
236                     SCULPT_TOOL_FILL, SCULPT_TOOL_FLATTEN, SCULPT_TOOL_SCRAPE);
237 }
238
239 static bool rna_BrushCapabilitiesSculpt_has_random_texture_angle_get(PointerRNA *ptr)
240 {
241         Brush *br = (Brush *)ptr->data;
242         return (!ELEM(br->sculpt_tool,
243                       SCULPT_TOOL_GRAB, SCULPT_TOOL_ROTATE,
244                       SCULPT_TOOL_SNAKE_HOOK, SCULPT_TOOL_THUMB));
245 }
246
247 static bool rna_TextureCapabilities_has_random_texture_angle_get(PointerRNA *ptr)
248 {
249         MTex *mtex = (MTex *)ptr->data;
250         return ELEM(mtex->brush_map_mode,
251                      MTEX_MAP_MODE_VIEW,
252                      MTEX_MAP_MODE_AREA,
253                      MTEX_MAP_MODE_RANDOM);
254 }
255
256
257 static bool rna_BrushCapabilities_has_random_texture_angle_get(PointerRNA *ptr)
258 {
259         Brush *br = (Brush *)ptr->data;
260         return !(br->flag & BRUSH_ANCHORED);
261 }
262
263 static bool rna_BrushCapabilitiesSculpt_has_sculpt_plane_get(PointerRNA *ptr)
264 {
265         Brush *br = (Brush *)ptr->data;
266         return !ELEM(br->sculpt_tool, SCULPT_TOOL_INFLATE,
267                      SCULPT_TOOL_MASK, SCULPT_TOOL_PINCH,
268                      SCULPT_TOOL_SMOOTH);
269 }
270
271 static bool rna_BrushCapabilitiesSculpt_has_secondary_color_get(PointerRNA *ptr)
272 {
273         Brush *br = (Brush *)ptr->data;
274         return BKE_brush_sculpt_has_secondary_color(br);
275 }
276
277 static bool rna_BrushCapabilitiesSculpt_has_smooth_stroke_get(PointerRNA *ptr)
278 {
279         Brush *br = (Brush *)ptr->data;
280         return (!(br->flag & BRUSH_ANCHORED) &&
281                 !(br->flag & BRUSH_DRAG_DOT) &&
282                 !(br->flag & BRUSH_LINE) &&
283                 !(br->flag & BRUSH_CURVE) &&
284                 !ELEM(br->sculpt_tool,
285                        SCULPT_TOOL_GRAB, SCULPT_TOOL_ROTATE,
286                        SCULPT_TOOL_SNAKE_HOOK, SCULPT_TOOL_THUMB));
287 }
288
289 static bool rna_BrushCapabilities_has_smooth_stroke_get(PointerRNA *ptr)
290 {
291         Brush *br = (Brush *)ptr->data;
292         return (!(br->flag & BRUSH_ANCHORED) &&
293                 !(br->flag & BRUSH_DRAG_DOT) &&
294                 !(br->flag & BRUSH_LINE) &&
295                 !(br->flag & BRUSH_CURVE));
296 }
297
298 static bool rna_BrushCapabilitiesSculpt_has_space_attenuation_get(PointerRNA *ptr)
299 {
300         Brush *br = (Brush *)ptr->data;
301         return ((br->flag & (BRUSH_SPACE | BRUSH_LINE | BRUSH_CURVE)) &&
302                 !ELEM(br->sculpt_tool, SCULPT_TOOL_GRAB, SCULPT_TOOL_ROTATE,
303                        SCULPT_TOOL_SMOOTH, SCULPT_TOOL_SNAKE_HOOK));
304 }
305
306 static bool rna_BrushCapabilitiesImagePaint_has_space_attenuation_get(PointerRNA *ptr)
307 {
308         Brush *br = (Brush *)ptr->data;
309         return (br->flag & (BRUSH_SPACE | BRUSH_LINE | BRUSH_CURVE)) &&
310                 br->imagepaint_tool != PAINT_TOOL_FILL;
311 }
312
313 static bool rna_BrushCapabilitiesImagePaint_has_color_get(PointerRNA *ptr)
314 {
315         Brush *br = (Brush *)ptr->data;
316         return ELEM(br->imagepaint_tool, PAINT_TOOL_DRAW, PAINT_TOOL_FILL);
317 }
318
319 static bool rna_BrushCapabilitiesVertexPaint_has_color_get(PointerRNA *ptr)
320 {
321         Brush *br = (Brush *)ptr->data;
322         return ELEM(br->vertexpaint_tool, VPAINT_TOOL_DRAW);
323 }
324
325 static bool rna_BrushCapabilitiesWeightPaint_has_weight_get(PointerRNA *ptr)
326 {
327         Brush *br = (Brush *)ptr->data;
328         return ELEM(br->weightpaint_tool, WPAINT_TOOL_DRAW);
329 }
330
331 static bool rna_BrushCapabilities_has_spacing_get(PointerRNA *ptr)
332 {
333         Brush *br = (Brush *)ptr->data;
334         return (!(br->flag & BRUSH_ANCHORED));
335 }
336
337 static bool rna_BrushCapabilitiesSculpt_has_strength_pressure_get(PointerRNA *ptr)
338 {
339         Brush *br = (Brush *)ptr->data;
340         return !ELEM(br->sculpt_tool, SCULPT_TOOL_GRAB, SCULPT_TOOL_SNAKE_HOOK);
341 }
342
343 static bool rna_TextureCapabilities_has_texture_angle_get(PointerRNA *ptr)
344 {
345         MTex *mtex = (MTex *)ptr->data;
346         return mtex->brush_map_mode != MTEX_MAP_MODE_3D;
347 }
348
349 static bool rna_BrushCapabilitiesSculpt_has_gravity_get(PointerRNA *ptr)
350 {
351         Brush *br = (Brush *)ptr->data;
352         return !ELEM(br->sculpt_tool, SCULPT_TOOL_MASK, SCULPT_TOOL_SMOOTH);
353 }
354
355 static bool rna_TextureCapabilities_has_texture_angle_source_get(PointerRNA *ptr)
356 {
357         MTex *mtex = (MTex *)ptr->data;
358         return ELEM(mtex->brush_map_mode,
359                     MTEX_MAP_MODE_VIEW,
360                     MTEX_MAP_MODE_AREA,
361                     MTEX_MAP_MODE_RANDOM);
362 }
363
364 static bool rna_BrushCapabilitiesImagePaint_has_accumulate_get(PointerRNA *ptr)
365 {
366         /* only support for draw tool */
367         Brush *br = (Brush *)ptr->data;
368
369         return ((br->flag & BRUSH_AIRBRUSH) ||
370                 (br->flag & BRUSH_DRAG_DOT) ||
371                 (br->flag & BRUSH_ANCHORED) ||
372                 (br->imagepaint_tool == PAINT_TOOL_SOFTEN) ||
373                 (br->imagepaint_tool == PAINT_TOOL_SMEAR) ||
374                 (br->imagepaint_tool == PAINT_TOOL_FILL) ||
375                 (br->mtex.tex && !ELEM(br->mtex.brush_map_mode, MTEX_MAP_MODE_TILED, MTEX_MAP_MODE_STENCIL, MTEX_MAP_MODE_3D))
376                 ) ? false : true;
377 }
378
379 static bool rna_BrushCapabilitiesImagePaint_has_radius_get(PointerRNA *ptr)
380 {
381         /* only support for draw tool */
382         Brush *br = (Brush *)ptr->data;
383
384         return (br->imagepaint_tool != PAINT_TOOL_FILL);
385 }
386
387
388 static PointerRNA rna_Sculpt_tool_capabilities_get(PointerRNA *ptr)
389 {
390         return rna_pointer_inherit_refine(ptr, &RNA_BrushCapabilitiesSculpt, ptr->id.data);
391 }
392
393 static PointerRNA rna_Imapaint_tool_capabilities_get(PointerRNA *ptr)
394 {
395         return rna_pointer_inherit_refine(ptr, &RNA_BrushCapabilitiesImagePaint, ptr->id.data);
396 }
397
398 static PointerRNA rna_Vertexpaint_tool_capabilities_get(PointerRNA *ptr)
399 {
400         return rna_pointer_inherit_refine(ptr, &RNA_BrushCapabilitiesVertexPaint, ptr->id.data);
401 }
402
403 static PointerRNA rna_Weightpaint_tool_capabilities_get(PointerRNA *ptr)
404 {
405         return rna_pointer_inherit_refine(ptr, &RNA_BrushCapabilitiesWeightPaint, ptr->id.data);
406 }
407
408 static PointerRNA rna_Brush_capabilities_get(PointerRNA *ptr)
409 {
410         return rna_pointer_inherit_refine(ptr, &RNA_BrushCapabilities, ptr->id.data);
411 }
412
413 static void rna_Brush_reset_icon(Brush *br)
414 {
415         ID *id = &br->id;
416
417         if (br->flag & BRUSH_CUSTOM_ICON)
418                 return;
419
420         if (id->icon_id >= BIFICONID_LAST) {
421                 BKE_icon_id_delete(id);
422                 BKE_previewimg_id_free(id);
423         }
424
425         id->icon_id = 0;
426 }
427
428 static void rna_Brush_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
429 {
430         Brush *br = (Brush *)ptr->data;
431         WM_main_add_notifier(NC_BRUSH | NA_EDITED, br);
432         /*WM_main_add_notifier(NC_SPACE|ND_SPACE_VIEW3D, NULL); */
433 }
434
435 static void rna_Brush_material_update(bContext *C, PointerRNA *ptr)
436 {
437         Main *bmain = CTX_data_main(C);
438         ViewLayer *view_layer = CTX_data_view_layer(C);
439         Object *ob = OBACT(view_layer);
440         Brush *br = (Brush *)ptr->id.data;
441         int index;
442
443         /* set material slot to same material */
444         if ((ob) && (ob->type == OB_GPENCIL) && (br->gpencil_settings != NULL)) {
445                 BrushGpencilSettings *gpencil_settings = br->gpencil_settings;
446                 if (gpencil_settings->material != NULL) {
447
448                         index = BKE_gpencil_get_material_index(ob, gpencil_settings->material);
449                         if ((index > 0) && (ob->actcol != index)) {
450                                 ob->actcol = index;
451                                 /* update other brushes to keep all synchro */
452                                 BKE_brush_update_material(bmain, gpencil_settings->material, br);
453                         }
454
455                 }
456                 WM_main_add_notifier(NC_SPACE | ND_SPACE_PROPERTIES, NULL);
457         }
458 }
459
460 static void rna_Brush_main_tex_update(bContext *C, PointerRNA *ptr)
461 {
462         Main *bmain = CTX_data_main(C);
463         Scene *scene = CTX_data_scene(C);
464         ViewLayer *view_layer = CTX_data_view_layer(C);
465         Brush *br = (Brush *)ptr->data;
466         BKE_paint_invalidate_overlay_tex(scene, view_layer, br->mtex.tex);
467         rna_Brush_update(bmain, scene, ptr);
468 }
469
470 static void rna_Brush_secondary_tex_update(bContext *C, PointerRNA *ptr)
471 {
472         Main *bmain = CTX_data_main(C);
473         Scene *scene = CTX_data_scene(C);
474         ViewLayer *view_layer = CTX_data_view_layer(C);
475         Brush *br = (Brush *)ptr->data;
476         BKE_paint_invalidate_overlay_tex(scene, view_layer, br->mask_mtex.tex);
477         rna_Brush_update(bmain, scene, ptr);
478 }
479
480 static void rna_Brush_size_update(Main *bmain, Scene *scene, PointerRNA *ptr)
481 {
482         BKE_paint_invalidate_overlay_all();
483         rna_Brush_update(bmain, scene, ptr);
484 }
485
486 static void rna_Brush_update_and_reset_icon(Main *bmain, Scene *scene, PointerRNA *ptr)
487 {
488         Brush *br = ptr->data;
489         rna_Brush_reset_icon(br);
490         rna_Brush_update(bmain, scene, ptr);
491 }
492
493 static void rna_Brush_stroke_update(Main *bmain, Scene *scene, PointerRNA *ptr)
494 {
495         WM_main_add_notifier(NC_SCENE | ND_TOOLSETTINGS, scene);
496         rna_Brush_update(bmain, scene, ptr);
497 }
498
499 static void rna_Brush_icon_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
500 {
501         Brush *br = (Brush *)ptr->data;
502
503         if (br->icon_imbuf) {
504                 IMB_freeImBuf(br->icon_imbuf);
505                 br->icon_imbuf = NULL;
506         }
507
508         br->id.icon_id = 0;
509
510         if (br->flag & BRUSH_CUSTOM_ICON) {
511                 BKE_icon_changed(BKE_icon_id_ensure(&br->id));
512         }
513
514         WM_main_add_notifier(NC_BRUSH | NA_EDITED, br);
515 }
516
517 static void rna_TextureSlot_brush_angle_update(bContext *C, PointerRNA *ptr)
518 {
519         Scene *scene = CTX_data_scene(C);
520         MTex *mtex = ptr->data;
521         /* skip invalidation of overlay for stencil mode */
522         if (mtex->mapping != MTEX_MAP_MODE_STENCIL) {
523                 ViewLayer *view_layer = CTX_data_view_layer(C);
524                 BKE_paint_invalidate_overlay_tex(scene, view_layer, mtex->tex);
525         }
526
527         rna_TextureSlot_update(C, ptr);
528 }
529
530 static void rna_Brush_set_size(PointerRNA *ptr, int value)
531 {
532         Brush *brush = ptr->data;
533
534         /* scale unprojected radius so it stays consistent with brush size */
535         BKE_brush_scale_unprojected_radius(&brush->unprojected_radius,
536                                            value, brush->size);
537         brush->size = value;
538 }
539
540 static void rna_Brush_use_gradient_set(PointerRNA *ptr, bool value)
541 {
542         Brush *br = (Brush *)ptr->data;
543
544         if (value) br->flag |= BRUSH_USE_GRADIENT;
545         else br->flag &= ~BRUSH_USE_GRADIENT;
546
547         if ((br->flag & BRUSH_USE_GRADIENT) && br->gradient == NULL)
548                 br->gradient = BKE_colorband_add(true);
549 }
550
551 static void rna_Brush_set_unprojected_radius(PointerRNA *ptr, float value)
552 {
553         Brush *brush = ptr->data;
554
555         /* scale brush size so it stays consistent with unprojected_radius */
556         BKE_brush_scale_size(&brush->size, value, brush->unprojected_radius);
557         brush->unprojected_radius = value;
558 }
559
560 static const EnumPropertyItem *rna_Brush_direction_itemf(
561         bContext *C, PointerRNA *ptr,
562         PropertyRNA *UNUSED(prop), bool *UNUSED(r_free))
563 {
564         ePaintMode mode = BKE_paintmode_get_active_from_context(C);
565
566         static const EnumPropertyItem prop_default_items[] = {
567                 {0, NULL, 0, NULL, NULL},
568         };
569
570         /* sculpt mode */
571         static const EnumPropertyItem prop_flatten_contrast_items[] = {
572                 {BRUSH_DIR_IN, "CONTRAST", ICON_ADD, "Contrast", "Subtract effect of brush"},
573                 {0, "FLATTEN", ICON_REMOVE, "Flatten", "Add effect of brush"},
574                 {0, NULL, 0, NULL, NULL},
575         };
576
577         static const EnumPropertyItem prop_fill_deepen_items[] = {
578                 {0, "FILL", ICON_ADD, "Fill", "Add effect of brush"},
579                 {BRUSH_DIR_IN, "DEEPEN", ICON_REMOVE, "Deepen", "Subtract effect of brush"},
580                 {0, NULL, 0, NULL, NULL},
581         };
582
583         static const EnumPropertyItem prop_scrape_peaks_items[] = {
584                 {0, "SCRAPE", ICON_ADD, "Scrape", "Add effect of brush"},
585                 {BRUSH_DIR_IN, "PEAKS", ICON_REMOVE, "Peaks", "Subtract effect of brush"},
586                 {0, NULL, 0, NULL, NULL},
587         };
588
589         static const EnumPropertyItem prop_pinch_magnify_items[] = {
590                 {BRUSH_DIR_IN, "MAGNIFY", ICON_ADD, "Magnify", "Subtract effect of brush"},
591                 {0, "PINCH", ICON_REMOVE, "Pinch", "Add effect of brush"},
592                 {0, NULL, 0, NULL, NULL},
593         };
594
595         static const EnumPropertyItem prop_inflate_deflate_items[] = {
596                 {0, "INFLATE", ICON_ADD, "Inflate", "Add effect of brush"},
597                 {BRUSH_DIR_IN, "DEFLATE", ICON_REMOVE, "Deflate", "Subtract effect of brush"},
598                 {0, NULL, 0, NULL, NULL},
599         };
600
601         /* texture paint mode */
602         static const EnumPropertyItem prop_soften_sharpen_items[] = {
603                 {BRUSH_DIR_IN, "SHARPEN", ICON_ADD, "Sharpen", "Sharpen effect of brush"},
604                 {0, "SOFTEN", ICON_REMOVE, "Soften", "Blur effect of brush"},
605                 {0, NULL, 0, NULL, NULL},
606         };
607
608         Brush *me = (Brush *)(ptr->data);
609
610         switch (mode) {
611                 case PAINT_MODE_SCULPT:
612                         switch (me->sculpt_tool) {
613                                 case SCULPT_TOOL_DRAW:
614                                 case SCULPT_TOOL_CREASE:
615                                 case SCULPT_TOOL_BLOB:
616                                 case SCULPT_TOOL_LAYER:
617                                 case SCULPT_TOOL_CLAY:
618                                 case SCULPT_TOOL_CLAY_STRIPS:
619                                         return prop_direction_items;
620
621                                 case SCULPT_TOOL_MASK:
622                                         switch ((BrushMaskTool)me->mask_tool) {
623                                                 case BRUSH_MASK_DRAW:
624                                                         return prop_direction_items;
625
626                                                 case BRUSH_MASK_SMOOTH:
627                                                         return prop_default_items;
628
629                                                 default:
630                                                         return prop_default_items;
631                                         }
632
633                                 case SCULPT_TOOL_FLATTEN:
634                                         return prop_flatten_contrast_items;
635
636                                 case SCULPT_TOOL_FILL:
637                                         return prop_fill_deepen_items;
638
639                                 case SCULPT_TOOL_SCRAPE:
640                                         return prop_scrape_peaks_items;
641
642                                 case SCULPT_TOOL_PINCH:
643                                         return prop_pinch_magnify_items;
644
645                                 case SCULPT_TOOL_INFLATE:
646                                         return prop_inflate_deflate_items;
647
648                                 default:
649                                         return prop_default_items;
650                         }
651
652                 case PAINT_MODE_TEXTURE_2D:
653                 case PAINT_MODE_TEXTURE_3D:
654                         switch (me->imagepaint_tool) {
655                                 case PAINT_TOOL_SOFTEN:
656                                         return prop_soften_sharpen_items;
657
658                                 default:
659                                         return prop_default_items;
660                         }
661
662                 default:
663                         return prop_default_items;
664         }
665 }
666
667 static const EnumPropertyItem *rna_Brush_stroke_itemf(
668         bContext *C, PointerRNA *UNUSED(ptr),
669         PropertyRNA *UNUSED(prop), bool *UNUSED(r_free))
670 {
671         ePaintMode mode = BKE_paintmode_get_active_from_context(C);
672
673         static const EnumPropertyItem brush_stroke_method_items[] = {
674                 {0, "DOTS", 0, "Dots", "Apply paint on each mouse move step"},
675                 {BRUSH_SPACE, "SPACE", 0, "Space", "Limit brush application to the distance specified by spacing"},
676                 {BRUSH_AIRBRUSH, "AIRBRUSH", 0, "Airbrush", "Keep applying paint effect while holding mouse (spray)"},
677                 {BRUSH_LINE, "LINE", 0, "Line", "Drag a line with dabs separated according to spacing"},
678                 {BRUSH_CURVE, "CURVE", 0, "Curve", "Define the stroke curve with a bezier curve. Dabs are separated according to spacing"},
679                 {0, NULL, 0, NULL, NULL},
680         };
681
682         switch (mode) {
683                 case PAINT_MODE_SCULPT:
684                 case PAINT_MODE_TEXTURE_2D:
685                 case PAINT_MODE_TEXTURE_3D:
686                         return sculpt_stroke_method_items;
687
688                 default:
689                         return brush_stroke_method_items;
690         }
691 }
692
693 /* Grease Pencil Drawing Brushes Settings */
694 static char *rna_BrushGpencilSettings_path(PointerRNA *UNUSED(ptr))
695 {
696         return BLI_strdup("tool_settings.gpencil_paint.brush.gpencil_settings");
697 }
698
699 static void rna_BrushGpencilSettings_default_eraser_update(Main *bmain, Scene *scene, PointerRNA *UNUSED(ptr))
700 {
701         ToolSettings *ts = scene->toolsettings;
702         Paint *paint = &ts->gp_paint->paint;
703         Brush *brush_cur = paint->brush;
704
705         /* disable default eraser in all brushes */
706         for (Brush *brush = bmain->brushes.first; brush; brush = brush->id.next) {
707                 if ((brush != brush_cur) &&
708                     (brush->ob_mode == OB_MODE_PAINT_GPENCIL) &&
709                     (brush->gpencil_tool == GPAINT_TOOL_ERASE))
710                 {
711                         brush->gpencil_settings->flag &= ~GP_BRUSH_DEFAULT_ERASER;
712                 }
713         }
714 }
715
716 static void rna_BrushGpencilSettings_eraser_mode_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *UNUSED(ptr))
717 {
718         ToolSettings *ts = scene->toolsettings;
719         Paint *paint = &ts->gp_paint->paint;
720         Brush *brush = paint->brush;
721
722         /* set eraser icon */
723         if ((brush) && (brush->gpencil_tool == GPAINT_TOOL_ERASE)) {
724                 switch (brush->gpencil_settings->eraser_mode) {
725                         case GP_BRUSH_ERASER_SOFT:
726                                 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_ERASE_SOFT;
727                                 break;
728                         case GP_BRUSH_ERASER_HARD:
729                                 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_ERASE_HARD;
730                                 break;
731                         case GP_BRUSH_ERASER_STROKE:
732                                 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_ERASE_STROKE;
733                                 break;
734                         default:
735                                 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_ERASE_SOFT;
736                                 break;
737                 }
738         }
739 }
740
741 static bool rna_BrushGpencilSettings_material_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
742 {
743         Material *ma = (Material *)value.data;
744
745         /* GP materials only */
746         return (ma->gp_style != NULL);
747 }
748
749 #else
750
751 static void rna_def_brush_texture_slot(BlenderRNA *brna)
752 {
753         StructRNA *srna;
754         PropertyRNA *prop;
755
756         static const EnumPropertyItem prop_map_mode_items[] = {
757                 {MTEX_MAP_MODE_VIEW, "VIEW_PLANE", 0, "View Plane", ""},
758                 {MTEX_MAP_MODE_AREA, "AREA_PLANE", 0, "Area Plane", ""},
759                 {MTEX_MAP_MODE_TILED, "TILED", 0, "Tiled", ""},
760                 {MTEX_MAP_MODE_3D, "3D", 0, "3D", ""},
761                 {MTEX_MAP_MODE_RANDOM, "RANDOM", 0, "Random", ""},
762                 {MTEX_MAP_MODE_STENCIL, "STENCIL", 0, "Stencil", ""},
763                 {0, NULL, 0, NULL, NULL},
764         };
765
766         static const EnumPropertyItem prop_tex_paint_map_mode_items[] = {
767                 {MTEX_MAP_MODE_VIEW, "VIEW_PLANE", 0, "View Plane", ""},
768                 {MTEX_MAP_MODE_TILED, "TILED", 0, "Tiled", ""},
769                 {MTEX_MAP_MODE_3D, "3D", 0, "3D", ""},
770                 {MTEX_MAP_MODE_RANDOM, "RANDOM", 0, "Random", ""},
771                 {MTEX_MAP_MODE_STENCIL, "STENCIL", 0, "Stencil", ""},
772                 {0, NULL, 0, NULL, NULL},
773         };
774
775         static const EnumPropertyItem prop_mask_paint_map_mode_items[] = {
776                 {MTEX_MAP_MODE_VIEW, "VIEW_PLANE", 0, "View Plane", ""},
777                 {MTEX_MAP_MODE_TILED, "TILED", 0, "Tiled", ""},
778                 {MTEX_MAP_MODE_RANDOM, "RANDOM", 0, "Random", ""},
779                 {MTEX_MAP_MODE_STENCIL, "STENCIL", 0, "Stencil", ""},
780                 {0, NULL, 0, NULL, NULL},
781         };
782
783 #define TEXTURE_CAPABILITY(prop_name_, ui_name_)                          \
784         prop = RNA_def_property(srna, #prop_name_,                          \
785                                 PROP_BOOLEAN, PROP_NONE);                   \
786         RNA_def_property_clear_flag(prop, PROP_EDITABLE);                   \
787         RNA_def_property_boolean_funcs(prop, "rna_TextureCapabilities_"      \
788                                        #prop_name_ "_get", NULL);           \
789         RNA_def_property_ui_text(prop, ui_name_, NULL)
790
791
792         srna = RNA_def_struct(brna, "BrushTextureSlot", "TextureSlot");
793         RNA_def_struct_sdna(srna, "MTex");
794         RNA_def_struct_ui_text(srna, "Brush Texture Slot", "Texture slot for textures in a Brush data-block");
795
796         prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
797         RNA_def_property_float_sdna(prop, NULL, "rot");
798         RNA_def_property_range(prop, 0, M_PI * 2);
799         RNA_def_property_ui_text(prop, "Angle", "Brush texture rotation");
800         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
801         RNA_def_property_update(prop, 0, "rna_TextureSlot_brush_angle_update");
802
803         prop = RNA_def_property(srna, "map_mode", PROP_ENUM, PROP_NONE);
804         RNA_def_property_enum_sdna(prop, NULL, "brush_map_mode");
805         RNA_def_property_enum_items(prop, prop_map_mode_items);
806         RNA_def_property_ui_text(prop, "Mode", "");
807         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
808         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
809
810         prop = RNA_def_property(srna, "tex_paint_map_mode", PROP_ENUM, PROP_NONE);
811         RNA_def_property_enum_sdna(prop, NULL, "brush_map_mode");
812         RNA_def_property_enum_items(prop, prop_tex_paint_map_mode_items);
813         RNA_def_property_ui_text(prop, "Mode", "");
814         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
815         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
816
817         prop = RNA_def_property(srna, "mask_map_mode", PROP_ENUM, PROP_NONE);
818         RNA_def_property_enum_sdna(prop, NULL, "brush_map_mode");
819         RNA_def_property_enum_items(prop, prop_mask_paint_map_mode_items);
820         RNA_def_property_ui_text(prop, "Mode", "");
821         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
822         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
823
824         prop = RNA_def_property(srna, "use_rake", PROP_BOOLEAN, PROP_NONE);
825         RNA_def_property_boolean_sdna(prop, NULL, "brush_angle_mode", MTEX_ANGLE_RAKE);
826         RNA_def_property_ui_text(prop, "Rake", "");
827         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
828         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
829
830         prop = RNA_def_property(srna, "use_random", PROP_BOOLEAN, PROP_NONE);
831         RNA_def_property_boolean_sdna(prop, NULL, "brush_angle_mode", MTEX_ANGLE_RANDOM);
832         RNA_def_property_ui_text(prop, "Random", "");
833         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
834         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
835
836         prop = RNA_def_property(srna, "random_angle", PROP_FLOAT, PROP_ANGLE);
837         RNA_def_property_range(prop, 0, M_PI * 2);
838         RNA_def_property_ui_text(prop, "Random Angle", "Brush texture random angle");
839         RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
840         RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
841
842         TEXTURE_CAPABILITY(has_texture_angle_source, "Has Texture Angle Source");
843         TEXTURE_CAPABILITY(has_random_texture_angle, "Has Random Texture Angle");
844         TEXTURE_CAPABILITY(has_texture_angle, "Has Texture Angle Source");
845 }
846
847 static void rna_def_sculpt_capabilities(BlenderRNA *brna)
848 {
849         StructRNA *srna;
850         PropertyRNA *prop;
851
852         srna = RNA_def_struct(brna, "BrushCapabilitiesSculpt", NULL);
853         RNA_def_struct_sdna(srna, "Brush");
854         RNA_def_struct_nested(brna, srna, "Brush");
855         RNA_def_struct_ui_text(srna, "Sculpt Capabilities",
856                                "Read-only indications of which brush operations "
857                                "are supported by the current sculpt tool");
858
859 #define SCULPT_TOOL_CAPABILITY(prop_name_, ui_name_)                    \
860         prop = RNA_def_property(srna, #prop_name_,                          \
861                                 PROP_BOOLEAN, PROP_NONE);                   \
862         RNA_def_property_clear_flag(prop, PROP_EDITABLE);                   \
863         RNA_def_property_boolean_funcs(prop, "rna_BrushCapabilitiesSculpt_" \
864                                        #prop_name_ "_get", NULL);           \
865         RNA_def_property_ui_text(prop, ui_name_, NULL)
866
867         SCULPT_TOOL_CAPABILITY(has_accumulate, "Has Accumulate");
868         SCULPT_TOOL_CAPABILITY(has_auto_smooth, "Has Auto Smooth");
869         SCULPT_TOOL_CAPABILITY(has_topology_rake, "Has Topology Rake");
870         SCULPT_TOOL_CAPABILITY(has_height, "Has Height");
871         SCULPT_TOOL_CAPABILITY(has_jitter, "Has Jitter");
872         SCULPT_TOOL_CAPABILITY(has_normal_weight, "Has Crease/Pinch Factor");
873         SCULPT_TOOL_CAPABILITY(has_rake_factor, "Has Rake Factor");
874         SCULPT_TOOL_CAPABILITY(has_persistence, "Has Persistence");
875         SCULPT_TOOL_CAPABILITY(has_pinch_factor, "Has Pinch Factor");
876         SCULPT_TOOL_CAPABILITY(has_plane_offset, "Has Plane Offset");
877         SCULPT_TOOL_CAPABILITY(has_random_texture_angle, "Has Random Texture Angle");
878         SCULPT_TOOL_CAPABILITY(has_sculpt_plane, "Has Sculpt Plane");
879         SCULPT_TOOL_CAPABILITY(has_secondary_color, "Has Secondary Color");
880         SCULPT_TOOL_CAPABILITY(has_smooth_stroke, "Has Smooth Stroke");
881         SCULPT_TOOL_CAPABILITY(has_space_attenuation, "Has Space Attenuation");
882         SCULPT_TOOL_CAPABILITY(has_strength_pressure, "Has Strength Pressure");
883         SCULPT_TOOL_CAPABILITY(has_gravity, "Has Gravity");
884
885 #undef SCULPT_CAPABILITY
886 }
887
888 static void rna_def_brush_capabilities(BlenderRNA *brna)
889 {
890         StructRNA *srna;
891         PropertyRNA *prop;
892
893         srna = RNA_def_struct(brna, "BrushCapabilities", NULL);
894         RNA_def_struct_sdna(srna, "Brush");
895         RNA_def_struct_nested(brna, srna, "Brush");
896         RNA_def_struct_ui_text(srna, "Brush Capabilities",
897                                "Read-only indications of supported operations");
898
899 #define BRUSH_CAPABILITY(prop_name_, ui_name_)                          \
900         prop = RNA_def_property(srna, #prop_name_,                          \
901                                 PROP_BOOLEAN, PROP_NONE);                   \
902         RNA_def_property_clear_flag(prop, PROP_EDITABLE);                   \
903         RNA_def_property_boolean_funcs(prop, "rna_BrushCapabilities_"       \
904                                        #prop_name_ "_get", NULL);           \
905         RNA_def_property_ui_text(prop, ui_name_, NULL)
906
907         BRUSH_CAPABILITY(has_overlay, "Has Overlay");
908         BRUSH_CAPABILITY(has_random_texture_angle, "Has Random Texture Angle");
909         BRUSH_CAPABILITY(has_spacing, "Has Spacing");
910         BRUSH_CAPABILITY(has_smooth_stroke, "Has Smooth Stroke");
911
912
913 #undef BRUSH_CAPABILITY
914 }
915
916 static void rna_def_image_paint_capabilities(BlenderRNA *brna)
917 {
918         StructRNA *srna;
919         PropertyRNA *prop;
920
921         srna = RNA_def_struct(brna, "BrushCapabilitiesImagePaint", NULL);
922         RNA_def_struct_sdna(srna, "Brush");
923         RNA_def_struct_nested(brna, srna, "Brush");
924         RNA_def_struct_ui_text(srna, "Image Paint Capabilities",
925                                "Read-only indications of supported operations");
926
927 #define IMAPAINT_TOOL_CAPABILITY(prop_name_, ui_name_)                       \
928         prop = RNA_def_property(srna, #prop_name_,                               \
929                                 PROP_BOOLEAN, PROP_NONE);                        \
930         RNA_def_property_clear_flag(prop, PROP_EDITABLE);                        \
931         RNA_def_property_boolean_funcs(prop, "rna_BrushCapabilitiesImagePaint_"  \
932                                        #prop_name_ "_get", NULL);                \
933         RNA_def_property_ui_text(prop, ui_name_, NULL)
934
935         IMAPAINT_TOOL_CAPABILITY(has_accumulate, "Has Accumulate");
936         IMAPAINT_TOOL_CAPABILITY(has_space_attenuation, "Has Space Attenuation");
937         IMAPAINT_TOOL_CAPABILITY(has_radius, "Has Radius");
938         IMAPAINT_TOOL_CAPABILITY(has_color, "Has Color");
939
940 #undef IMAPAINT_TOOL_CAPABILITY
941 }
942
943 static void rna_def_vertex_paint_capabilities(BlenderRNA *brna)
944 {
945         StructRNA *srna;
946         PropertyRNA *prop;
947
948         srna = RNA_def_struct(brna, "BrushCapabilitiesVertexPaint", NULL);
949         RNA_def_struct_sdna(srna, "Brush");
950         RNA_def_struct_nested(brna, srna, "Brush");
951         RNA_def_struct_ui_text(srna, "Vertex Paint Capabilities",
952                                "Read-only indications of supported operations");
953
954 #define VPAINT_TOOL_CAPABILITY(prop_name_, ui_name_)                         \
955         prop = RNA_def_property(srna, #prop_name_,                               \
956                                 PROP_BOOLEAN, PROP_NONE);                        \
957         RNA_def_property_clear_flag(prop, PROP_EDITABLE);                        \
958         RNA_def_property_boolean_funcs(prop, "rna_BrushCapabilitiesVertexPaint_" \
959                                        #prop_name_ "_get", NULL);                \
960         RNA_def_property_ui_text(prop, ui_name_, NULL)
961
962         VPAINT_TOOL_CAPABILITY(has_color, "Has Color");
963
964 #undef VPAINT_TOOL_CAPABILITY
965 }
966
967 static void rna_def_weight_paint_capabilities(BlenderRNA *brna)
968 {
969         StructRNA *srna;
970         PropertyRNA *prop;
971
972         srna = RNA_def_struct(brna, "BrushCapabilitiesWeightPaint", NULL);
973         RNA_def_struct_sdna(srna, "Brush");
974         RNA_def_struct_nested(brna, srna, "Brush");
975         RNA_def_struct_ui_text(srna, "Weight Paint Capabilities",
976                                "Read-only indications of supported operations");
977
978 #define WPAINT_TOOL_CAPABILITY(prop_name_, ui_name_)                         \
979         prop = RNA_def_property(srna, #prop_name_,                               \
980                                 PROP_BOOLEAN, PROP_NONE);                        \
981         RNA_def_property_clear_flag(prop, PROP_EDITABLE);                        \
982         RNA_def_property_boolean_funcs(prop, "rna_BrushCapabilitiesWeightPaint_" \
983                                        #prop_name_ "_get", NULL);                \
984         RNA_def_property_ui_text(prop, ui_name_, NULL)
985
986         WPAINT_TOOL_CAPABILITY(has_weight, "Has Weight");
987
988 #undef WPAINT_TOOL_CAPABILITY
989 }
990
991 static void rna_def_gpencil_options(BlenderRNA *brna)
992 {
993         StructRNA *srna;
994         PropertyRNA *prop;
995
996         srna = RNA_def_struct(brna, "BrushGpencilSettings", NULL);
997         RNA_def_struct_sdna(srna, "BrushGpencilSettings");
998         RNA_def_struct_path_func(srna, "rna_BrushGpencilSettings_path");
999         RNA_def_struct_ui_text(srna, "Grease Pencil Brush Settings", "Settings for grease pencil brush");
1000
1001         /* Sensitivity factor for new strokes */
1002         prop = RNA_def_property(srna, "pen_sensitivity_factor", PROP_FLOAT, PROP_NONE);
1003         RNA_def_property_float_sdna(prop, NULL, "draw_sensitivity");
1004         RNA_def_property_range(prop, 0.1f, 3.0f);
1005         RNA_def_property_ui_text(prop, "Sensitivity", "Pressure sensitivity factor for new strokes");
1006         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1007         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1008
1009         /* Strength factor for new strokes */
1010         prop = RNA_def_property(srna, "pen_strength", PROP_FLOAT, PROP_FACTOR);
1011         RNA_def_property_float_sdna(prop, NULL, "draw_strength");
1012         RNA_def_property_range(prop, 0.0f, 1.0f);
1013         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
1014         RNA_def_property_ui_text(prop, "Strength", "Color strength for new strokes (affect alpha factor of color)");
1015         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1016         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1017
1018         /* Jitter factor for new strokes */
1019         prop = RNA_def_property(srna, "pen_jitter", PROP_FLOAT, PROP_FACTOR);
1020         RNA_def_property_float_sdna(prop, NULL, "draw_jitter");
1021         RNA_def_property_range(prop, 0.0f, 1.0f);
1022         RNA_def_property_ui_text(prop, "Jitter", "Jitter factor for new strokes");
1023         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1024         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1025
1026         /* Randomnes factor for pressure */
1027         prop = RNA_def_property(srna, "random_pressure", PROP_FLOAT, PROP_FACTOR);
1028         RNA_def_property_float_sdna(prop, NULL, "draw_random_press");
1029         RNA_def_property_range(prop, 0.0f, 1.0f);
1030         RNA_def_property_ui_text(prop, "Pressure Randomness", "Randomness factor for pressure in new strokes");
1031         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1032         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1033
1034         /* Randomnes factor for strength */
1035         prop = RNA_def_property(srna, "random_strength", PROP_FLOAT, PROP_FACTOR);
1036         RNA_def_property_float_sdna(prop, NULL, "draw_random_strength");
1037         RNA_def_property_range(prop, 0.0f, 1.0f);
1038         RNA_def_property_ui_text(prop, "Strength Randomness", "Randomness factor strength in new strokes");
1039         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1040         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1041
1042         /* Randomnes factor for subdivision */
1043         prop = RNA_def_property(srna, "random_subdiv", PROP_FLOAT, PROP_FACTOR);
1044         RNA_def_property_float_sdna(prop, NULL, "draw_random_sub");
1045         RNA_def_property_range(prop, 0.0f, 1.0f);
1046         RNA_def_property_ui_text(prop, "Random Subdivision", "Randomness factor for new strokes after subdivision");
1047         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1048         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1049
1050         /* Angle when brush is full size */
1051         prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
1052         RNA_def_property_float_sdna(prop, NULL, "draw_angle");
1053         RNA_def_property_range(prop, -M_PI_2, M_PI_2);
1054         RNA_def_property_ui_text(
1055                 prop, "Angle",
1056                 "Direction of the stroke at which brush gives maximal thickness "
1057                 "(0° for horizontal)");
1058         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1059         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1060
1061         /* Factor to change brush size depending of angle */
1062         prop = RNA_def_property(srna, "angle_factor", PROP_FLOAT, PROP_FACTOR);
1063         RNA_def_property_float_sdna(prop, NULL, "draw_angle_factor");
1064         RNA_def_property_range(prop, 0.0f, 1.0f);
1065         RNA_def_property_ui_text(
1066                 prop, "Angle Factor",
1067                 "Reduce brush thickness by this factor when stroke is perpendicular to 'Angle' direction");
1068         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1069         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1070
1071         /* Smoothing factor for new strokes */
1072         prop = RNA_def_property(srna, "pen_smooth_factor", PROP_FLOAT, PROP_NONE);
1073         RNA_def_property_float_sdna(prop, NULL, "draw_smoothfac");
1074         RNA_def_property_range(prop, 0.0, 2.0f);
1075         RNA_def_property_ui_text(
1076                 prop, "Smooth",
1077                 "Amount of smoothing to apply after finish newly created strokes, to reduce jitter/noise");
1078         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1079         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1080
1081         /* Iterations of the Smoothing factor */
1082         prop = RNA_def_property(srna, "pen_smooth_steps", PROP_INT, PROP_NONE);
1083         RNA_def_property_int_sdna(prop, NULL, "draw_smoothlvl");
1084         RNA_def_property_range(prop, 1, 3);
1085         RNA_def_property_ui_text(
1086                 prop, "Iterations",
1087                 "Number of times to smooth newly created strokes");
1088         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1089         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1090
1091         /* Thickness smoothing factor for new strokes */
1092         prop = RNA_def_property(srna, "pen_thick_smooth_factor", PROP_FLOAT, PROP_NONE);
1093         RNA_def_property_float_sdna(prop, NULL, "thick_smoothfac");
1094         RNA_def_property_range(prop, 0.0, 2.0f);
1095         RNA_def_property_ui_text(
1096                 prop, "Smooth Thickness",
1097                 "Amount of thickness smoothing to apply after finish newly created strokes, to reduce jitter/noise");
1098         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1099         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1100
1101         /* Thickness iterations of the Smoothing factor */
1102         prop = RNA_def_property(srna, "pen_thick_smooth_steps", PROP_INT, PROP_NONE);
1103         RNA_def_property_int_sdna(prop, NULL, "thick_smoothlvl");
1104         RNA_def_property_range(prop, 1, 3);
1105         RNA_def_property_ui_text(
1106                 prop, "Iterations Thickness",
1107                 "Number of times to smooth thickness for newly created strokes");
1108         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1109         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1110
1111         /* Subdivision level for new strokes */
1112         prop = RNA_def_property(srna, "pen_subdivision_steps", PROP_INT, PROP_NONE);
1113         RNA_def_property_int_sdna(prop, NULL, "draw_subdivide");
1114         RNA_def_property_range(prop, 0, 3);
1115         RNA_def_property_ui_text(
1116                 prop, "Subdivision Steps",
1117                 "Number of times to subdivide newly created strokes, for less jagged strokes");
1118         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1119         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1120
1121         /* Curves for pressure */
1122         prop = RNA_def_property(srna, "curve_sensitivity", PROP_POINTER, PROP_NONE);
1123         RNA_def_property_pointer_sdna(prop, NULL, "curve_sensitivity");
1124         RNA_def_property_struct_type(prop, "CurveMapping");
1125         RNA_def_property_ui_text(prop, "Curve Sensitivity", "Curve used for the sensitivity");
1126         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1127         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1128
1129         prop = RNA_def_property(srna, "curve_strength", PROP_POINTER, PROP_NONE);
1130         RNA_def_property_pointer_sdna(prop, NULL, "curve_strength");
1131         RNA_def_property_struct_type(prop, "CurveMapping");
1132         RNA_def_property_ui_text(prop, "Curve Strength", "Curve used for the strength");
1133         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1134         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1135
1136         prop = RNA_def_property(srna, "curve_jitter", PROP_POINTER, PROP_NONE);
1137         RNA_def_property_pointer_sdna(prop, NULL, "curve_jitter");
1138         RNA_def_property_struct_type(prop, "CurveMapping");
1139         RNA_def_property_ui_text(prop, "Curve Jitter", "Curve used for the jitter effect");
1140         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1141         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1142
1143         /* fill threshold for transparence */
1144         prop = RNA_def_property(srna, "fill_threshold", PROP_FLOAT, PROP_FACTOR);
1145         RNA_def_property_float_sdna(prop, NULL, "fill_threshold");
1146         RNA_def_property_range(prop, 0.0f, 1.0f);
1147         RNA_def_property_ui_text(
1148                 prop, "Threshold",
1149                 "Threshold to consider color transparent for filling");
1150         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1151         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1152
1153         /* fill leak size */
1154         prop = RNA_def_property(srna, "fill_leak", PROP_INT, PROP_PIXEL);
1155         RNA_def_property_int_sdna(prop, NULL, "fill_leak");
1156         RNA_def_property_range(prop, 0, 100);
1157         RNA_def_property_ui_text(
1158                 prop, "Leak Size",
1159                 "Size in pixels to consider the leak closed");
1160         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1161         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1162
1163         /* fill factor size */
1164         prop = RNA_def_property(srna, "fill_factor", PROP_INT, PROP_NONE);
1165         RNA_def_property_int_sdna(prop, NULL, "fill_factor");
1166         RNA_def_property_range(prop, 1, 8);
1167         RNA_def_property_ui_text(prop, "Resolution",
1168                 "Multiplier for fill resolution, higher resolution is more accurate but slower");
1169         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1170         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1171
1172         /* fill simplify steps */
1173         prop = RNA_def_property(srna, "fill_simplify_level", PROP_INT, PROP_NONE);
1174         RNA_def_property_int_sdna(prop, NULL, "fill_simplylvl");
1175         RNA_def_property_range(prop, 0, 10);
1176         RNA_def_property_ui_text(
1177                 prop, "Simplify",
1178                 "Number of simplify steps (large values reduce fill accuracy)");
1179         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1180         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1181
1182         prop = RNA_def_property(srna, "uv_random", PROP_FLOAT, PROP_FACTOR);
1183         RNA_def_property_float_sdna(prop, NULL, "uv_random");
1184         RNA_def_property_range(prop, 0.0, 1.0);
1185         RNA_def_property_ui_text(prop, "UV Random", "Random factor for autogenerated UV rotation");
1186         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1187         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1188
1189         prop = RNA_def_property(srna, "input_samples", PROP_INT, PROP_NONE);
1190         RNA_def_property_int_sdna(prop, NULL, "input_samples");
1191         RNA_def_property_range(prop, 0, GP_MAX_INPUT_SAMPLES);
1192         RNA_def_property_ui_text(prop, "Input Samples", "Generate intermediate points for very fast mouse movements. Set to 0 to disable");
1193         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1194         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1195
1196         /* active smooth factor while drawing */
1197         prop = RNA_def_property(srna, "active_smooth_factor", PROP_FLOAT, PROP_FACTOR);
1198         RNA_def_property_float_sdna(prop, NULL, "active_smooth");
1199         RNA_def_property_range(prop, 0.0f, 1.0f);
1200         RNA_def_property_ui_text(
1201                 prop, "Active Smooth",
1202                 "Amount of smoothing while drawing ");
1203         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1204         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1205
1206         prop = RNA_def_property(srna, "eraser_strength_factor", PROP_FLOAT, PROP_PERCENTAGE);
1207         RNA_def_property_float_sdna(prop, NULL, "era_strength_f");
1208         RNA_def_property_range(prop, 0.0, 100.0);
1209         RNA_def_property_ui_range(prop, 0.0, 100.0, 10, 1);
1210         RNA_def_property_ui_text(
1211                 prop, "Affect Stroke Strength",
1212                 "Amount of erasing for strength ");
1213         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1214         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1215
1216         prop = RNA_def_property(srna, "eraser_thickness_factor", PROP_FLOAT, PROP_PERCENTAGE);
1217         RNA_def_property_float_sdna(prop, NULL, "era_thickness_f");
1218         RNA_def_property_range(prop, 0.0, 100.0);
1219         RNA_def_property_ui_range(prop, 0.0, 100.0, 10, 1);
1220         RNA_def_property_ui_text(
1221                 prop, "Affect Stroke Thickness",
1222                 "Amount of erasing for thickness ");
1223         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1224         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1225
1226         /* brush standard icon */
1227         prop = RNA_def_property(srna, "gp_icon", PROP_ENUM, PROP_NONE);
1228         RNA_def_property_enum_sdna(prop, NULL, "icon_id");
1229         RNA_def_property_enum_items(prop, rna_enum_gpencil_brush_icons_items);
1230         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1231         RNA_def_property_ui_text(prop, "Grease Pencil Icon", "");
1232
1233         /* Flags */
1234         prop = RNA_def_property(srna, "use_pressure", PROP_BOOLEAN, PROP_NONE);
1235         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_USE_PRESSURE);
1236         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1237         RNA_def_property_ui_text(prop, "Use Pressure", "Use tablet pressure");
1238         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1239         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1240
1241         prop = RNA_def_property(srna, "use_strength_pressure", PROP_BOOLEAN, PROP_NONE);
1242         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_USE_STENGTH_PRESSURE);
1243         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1244         RNA_def_property_ui_text(prop, "Use Pressure Strength", "Use tablet pressure for color strength");
1245         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1246         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1247
1248         prop = RNA_def_property(srna, "use_jitter_pressure", PROP_BOOLEAN, PROP_NONE);
1249         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_USE_JITTER_PRESSURE);
1250         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1251         RNA_def_property_ui_text(prop, "Use Pressure Jitter", "Use tablet pressure for jitter");
1252         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1253         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1254
1255         prop = RNA_def_property(srna, "use_settings_stabilizer", PROP_BOOLEAN, PROP_NONE);
1256         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_STABILIZE_MOUSE);
1257         RNA_def_property_boolean_default(prop, true);
1258         RNA_def_property_ui_text(
1259                 prop, "Use Stabilizer",
1260                 "Draw lines with a delay to allow smooth strokes. Press Shift key to override while drawing");
1261         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1262
1263         prop = RNA_def_property(srna, "use_cursor", PROP_BOOLEAN, PROP_NONE);
1264         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_ENABLE_CURSOR);
1265         RNA_def_property_boolean_default(prop, true);
1266         RNA_def_property_ui_text(prop, "Enable Cursor", "Enable cursor on screen");
1267         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1268
1269         prop = RNA_def_property(srna, "eraser_mode", PROP_ENUM, PROP_NONE);
1270         RNA_def_property_enum_sdna(prop, NULL, "eraser_mode");
1271         RNA_def_property_enum_items(prop, rna_enum_gpencil_brush_eraser_modes_items);
1272         RNA_def_property_ui_text(prop, "Mode", "Eraser Mode");
1273         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1274         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_BrushGpencilSettings_eraser_mode_update");
1275
1276         prop = RNA_def_property(srna, "fill_draw_mode", PROP_ENUM, PROP_NONE);
1277         RNA_def_property_enum_sdna(prop, NULL, "fill_draw_mode");
1278         RNA_def_property_enum_items(prop, rna_enum_gpencil_fill_draw_modes_items);
1279         RNA_def_property_ui_text(prop, "Mode", "Mode to draw boundary limits");
1280         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1281
1282         prop = RNA_def_property(srna, "trim", PROP_BOOLEAN, PROP_NONE);
1283         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_TRIM_STROKE);
1284         RNA_def_property_boolean_default(prop, false);
1285         RNA_def_property_ui_text(prop, "Trim Stroke Ends", "Trim intersecting stroke ends");
1286         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1287
1288         /* Material */
1289         prop = RNA_def_property(srna, "material", PROP_POINTER, PROP_NONE);
1290         RNA_def_property_struct_type(prop, "Material");
1291         RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_BrushGpencilSettings_material_poll");
1292         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK | PROP_CONTEXT_UPDATE);
1293         RNA_def_property_ui_text(prop, "Material", "Material used for strokes drawn using this brush");
1294         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1295         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_Brush_material_update");
1296
1297         prop = RNA_def_property(srna, "show_fill_boundary", PROP_BOOLEAN, PROP_NONE);
1298         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_FILL_SHOW_HELPLINES);
1299         RNA_def_property_boolean_default(prop, true);
1300         RNA_def_property_ui_text(prop, "Show Lines", "Show help lines for filling to see boundaries");
1301         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1302
1303         prop = RNA_def_property(srna, "show_fill", PROP_BOOLEAN, PROP_NONE);
1304         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GP_BRUSH_FILL_HIDE);
1305         RNA_def_property_boolean_default(prop, true);
1306         RNA_def_property_ui_text(prop, "Show Fill", "Show transparent lines to use as boundary for filling");
1307         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1308
1309         prop = RNA_def_property(srna, "use_default_eraser", PROP_BOOLEAN, PROP_NONE);
1310         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_DEFAULT_ERASER);
1311         RNA_def_property_boolean_default(prop, true);
1312         RNA_def_property_ui_icon(prop, ICON_UNPINNED, 1);
1313         RNA_def_property_ui_text(prop, "Default Eraser", "Use this brush when enable eraser with fast switch key");
1314         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1315         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_BrushGpencilSettings_default_eraser_update");
1316
1317         prop = RNA_def_property(srna, "use_settings_postprocess", PROP_BOOLEAN, PROP_NONE);
1318         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_GROUP_SETTINGS);
1319         RNA_def_property_ui_text(prop, "Use Post-Process Settings", "Additional post processing options for new strokes");
1320         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1321
1322         prop = RNA_def_property(srna, "use_settings_random", PROP_BOOLEAN, PROP_NONE);
1323         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_GROUP_RANDOM);
1324         RNA_def_property_ui_text(prop, "Random Settings", "Random brush settings");
1325         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1326
1327         prop = RNA_def_property(srna, "use_material_pin", PROP_BOOLEAN, PROP_NONE);
1328         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_MATERIAL_PINNED);
1329         RNA_def_property_ui_icon(prop, ICON_UNPINNED, 1);
1330         RNA_def_property_ui_text(prop, "Pin Material", "Keep material assigned to brush");
1331         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1332
1333         prop = RNA_def_property(srna, "show_lasso", PROP_BOOLEAN, PROP_NONE);
1334         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GP_BRUSH_DISSABLE_LASSO);
1335         RNA_def_property_ui_text(prop, "Show Lasso", "Do not draw fill color while drawing the stroke");
1336         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1337
1338         prop = RNA_def_property(srna, "use_occlude_eraser", PROP_BOOLEAN, PROP_NONE);
1339         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GP_BRUSH_OCCLUDE_ERASER);
1340         RNA_def_property_ui_text(
1341                 prop, "Occlude Eraser",
1342                 "Erase only strokes visible and not occluded");
1343         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1344 }
1345
1346 static void rna_def_brush(BlenderRNA *brna)
1347 {
1348         StructRNA *srna;
1349         PropertyRNA *prop;
1350
1351         static const EnumPropertyItem prop_blend_items[] = {
1352                 {IMB_BLEND_MIX, "MIX", 0, "Mix", "Use mix blending mode while painting"},
1353                 {0, "", ICON_NONE, NULL, NULL},
1354                 {IMB_BLEND_DARKEN, "DARKEN", 0, "Darken", "Use darken blending mode while painting"},
1355                 {IMB_BLEND_MUL, "MUL", 0, "Multiply", "Use multiply blending mode while painting"},
1356                 {IMB_BLEND_COLORBURN, "COLORBURN", 0, "Color burn", "Use color burn blending mode while painting"},
1357                 {IMB_BLEND_LINEARBURN, "LINEARBURN", 0, "Linear burn", "Use linear burn blending mode while painting"},
1358                 {0, "", ICON_NONE, NULL, NULL},
1359                 {IMB_BLEND_LIGHTEN, "LIGHTEN", 0, "Lighten", "Use lighten blending mode while painting"},
1360                 {IMB_BLEND_SCREEN, "SCREEN", 0, "Screen", "Use screen blending mode while painting"},
1361                 {IMB_BLEND_COLORDODGE, "COLORDODGE", 0, "Color dodge", "Use color dodge blending mode while painting"},
1362                 {IMB_BLEND_ADD, "ADD", 0, "Add", "Use add blending mode while painting"},
1363                 {0, "", ICON_NONE, NULL, NULL},
1364                 {IMB_BLEND_OVERLAY, "OVERLAY", 0, "Overlay", "Use overlay blending mode while painting"},
1365                 {IMB_BLEND_SOFTLIGHT, "SOFTLIGHT", 0, "Soft light", "Use softlight blending mode while painting"},
1366                 {IMB_BLEND_HARDLIGHT, "HARDLIGHT", 0, "Hard light", "Use hard light blending mode while painting"},
1367                 {IMB_BLEND_VIVIDLIGHT, "VIVIDLIGHT", 0, "Vivid light", "Use vividlight blending mode while painting"},
1368                 {IMB_BLEND_LINEARLIGHT, "LINEARLIGHT", 0, "Linear light", "Use linearlight blending mode while painting"},
1369                 {IMB_BLEND_PINLIGHT, "PINLIGHT", 0, "Pin light", "Use pinlight blending mode while painting"},
1370                 {0, "", ICON_NONE, NULL, NULL},
1371                 {IMB_BLEND_DIFFERENCE, "DIFFERENCE", 0, "Difference", "Use difference blending mode while painting"},
1372                 {IMB_BLEND_EXCLUSION, "EXCLUSION", 0, "Exclusion", "Use exclusion blending mode while painting"},
1373                 {IMB_BLEND_SUB, "SUB", 0, "Subtract", "Use subtract blending mode while painting"},
1374                 {0, "", ICON_NONE, NULL, NULL},
1375                 {IMB_BLEND_HUE, "HUE", 0, "Hue", "Use hue blending mode while painting"},
1376                 {IMB_BLEND_SATURATION, "SATURATION", 0, "Saturation", "Use saturation blending mode while painting"},
1377                 {IMB_BLEND_COLOR, "COLOR", 0, "Color", "Use color blending mode while painting"},
1378                 {IMB_BLEND_LUMINOSITY, "LUMINOSITY", 0, "Luminosity", "Use luminosity blending mode while painting"},
1379                 {0, "", ICON_NONE, NULL, NULL},
1380                 {IMB_BLEND_ERASE_ALPHA, "ERASE_ALPHA", 0, "Erase Alpha", "Erase alpha while painting"},
1381                 {IMB_BLEND_ADD_ALPHA, "ADD_ALPHA", 0, "Add Alpha", "Add alpha while painting"},
1382                 {0, NULL, 0, NULL, NULL},
1383         };
1384
1385         static const EnumPropertyItem brush_sculpt_plane_items[] = {
1386                 {SCULPT_DISP_DIR_AREA, "AREA", 0, "Area Plane", ""},
1387                 {SCULPT_DISP_DIR_VIEW, "VIEW", 0, "View Plane", ""},
1388                 {SCULPT_DISP_DIR_X, "X", 0, "X Plane", ""},
1389                 {SCULPT_DISP_DIR_Y, "Y", 0, "Y Plane", ""},
1390                 {SCULPT_DISP_DIR_Z, "Z", 0, "Z Plane", ""},
1391                 {0, NULL, 0, NULL, NULL},
1392         };
1393
1394         static const EnumPropertyItem brush_mask_tool_items[] = {
1395                 {BRUSH_MASK_DRAW, "DRAW", 0, "Draw", ""},
1396                 {BRUSH_MASK_SMOOTH, "SMOOTH", 0, "Smooth", ""},
1397                 {0, NULL, 0, NULL, NULL},
1398         };
1399
1400         static const EnumPropertyItem brush_blur_mode_items[] = {
1401                 {KERNEL_BOX, "BOX", 0, "Box", ""},
1402                 {KERNEL_GAUSSIAN, "GAUSSIAN", 0, "Gaussian", ""},
1403                 {0, NULL, 0, NULL, NULL},
1404         };
1405
1406         static const EnumPropertyItem brush_gradient_items[] = {
1407                 {BRUSH_GRADIENT_PRESSURE, "PRESSURE", 0, "Pressure", ""},
1408                 {BRUSH_GRADIENT_SPACING_REPEAT, "SPACING_REPEAT", 0, "Repeat", ""},
1409                 {BRUSH_GRADIENT_SPACING_CLAMP, "SPACING_CLAMP", 0, "Clamp", ""},
1410                 {0, NULL, 0, NULL, NULL},
1411         };
1412
1413         static const EnumPropertyItem brush_gradient_fill_items[] = {
1414                 {BRUSH_GRADIENT_LINEAR, "LINEAR", 0, "Linear", ""},
1415                 {BRUSH_GRADIENT_RADIAL, "RADIAL", 0, "Radial", ""},
1416                 {0, NULL, 0, NULL, NULL},
1417         };
1418
1419         static const EnumPropertyItem brush_mask_pressure_items[] = {
1420                 {0, "NONE", 0, "Off", ""},
1421                 {BRUSH_MASK_PRESSURE_RAMP, "RAMP", ICON_STYLUS_PRESSURE, "Ramp", ""},
1422                 {BRUSH_MASK_PRESSURE_CUTOFF, "CUTOFF", ICON_STYLUS_PRESSURE, "Cutoff", ""},
1423                 {0, NULL, 0, NULL, NULL},
1424         };
1425
1426         srna = RNA_def_struct(brna, "Brush", "ID");
1427         RNA_def_struct_ui_text(srna, "Brush", "Brush data-block for storing brush settings for painting and sculpting");
1428         RNA_def_struct_ui_icon(srna, ICON_BRUSH_DATA);
1429
1430         /* enums */
1431         prop = RNA_def_property(srna, "blend", PROP_ENUM, PROP_NONE);
1432         RNA_def_property_enum_items(prop, prop_blend_items);
1433         RNA_def_property_ui_text(prop, "Blending mode", "Brush blending mode");
1434         RNA_def_property_update(prop, 0, "rna_Brush_update");
1435
1436
1437         /**
1438          * Begin per-mode tool properties.
1439          *
1440          * keep in sync with #BKE_paint_get_tool_prop_id_from_paintmode
1441          */
1442         prop = RNA_def_property(srna, "sculpt_tool", PROP_ENUM, PROP_NONE);
1443         RNA_def_property_enum_items(prop, rna_enum_brush_sculpt_tool_items);
1444         RNA_def_property_ui_text(prop, "Sculpt Tool", "");
1445         RNA_def_property_update(prop, 0, "rna_Brush_update_and_reset_icon");
1446
1447         prop = RNA_def_property(srna, "vertex_tool", PROP_ENUM, PROP_NONE);
1448         RNA_def_property_enum_sdna(prop, NULL, "vertexpaint_tool");
1449         RNA_def_property_enum_items(prop, rna_enum_brush_vertex_tool_items);
1450         RNA_def_property_ui_text(prop, "Vertex Paint Tool", "");
1451         RNA_def_property_update(prop, 0, "rna_Brush_update_and_reset_icon");
1452
1453         prop = RNA_def_property(srna, "weight_tool", PROP_ENUM, PROP_NONE);
1454         RNA_def_property_enum_sdna(prop, NULL, "weightpaint_tool");
1455         RNA_def_property_enum_items(prop, rna_enum_brush_weight_tool_items);
1456         RNA_def_property_ui_text(prop, "Weight Paint Tool", "");
1457         RNA_def_property_update(prop, 0, "rna_Brush_update_and_reset_icon");
1458
1459         prop = RNA_def_property(srna, "image_tool", PROP_ENUM, PROP_NONE);
1460         RNA_def_property_enum_sdna(prop, NULL, "imagepaint_tool");
1461         RNA_def_property_enum_items(prop, rna_enum_brush_image_tool_items);
1462         RNA_def_property_ui_text(prop, "Image Paint Tool", "");
1463         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_Brush_update_and_reset_icon");
1464
1465         prop = RNA_def_property(srna, "gpencil_tool", PROP_ENUM, PROP_NONE);
1466         RNA_def_property_enum_sdna(prop, NULL, "gpencil_tool");
1467         RNA_def_property_enum_items(prop, rna_enum_brush_gpencil_types_items);
1468         RNA_def_property_ui_text(prop, "Type", "Category of the brush");
1469         RNA_def_parameter_clear_flags(prop, PROP_ANIMATABLE, 0);
1470         /** End per mode tool properties. */
1471
1472
1473         prop = RNA_def_property(srna, "direction", PROP_ENUM, PROP_NONE);
1474         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
1475         RNA_def_property_enum_items(prop, prop_direction_items);
1476         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Brush_direction_itemf");
1477         RNA_def_property_ui_text(prop, "Direction", "");
1478         RNA_def_property_update(prop, 0, "rna_Brush_update");
1479
1480         prop = RNA_def_property(srna, "stroke_method", PROP_ENUM, PROP_NONE);
1481         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
1482         RNA_def_property_enum_items(prop, sculpt_stroke_method_items);
1483         RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Brush_stroke_itemf");
1484         RNA_def_property_ui_text(prop, "Stroke Method", "");
1485         RNA_def_property_update(prop, 0, "rna_Brush_stroke_update");
1486
1487         prop = RNA_def_property(srna, "sculpt_plane", PROP_ENUM, PROP_NONE);
1488         RNA_def_property_enum_items(prop, brush_sculpt_plane_items);
1489         RNA_def_property_ui_text(prop, "Sculpt Plane", "");
1490         RNA_def_property_update(prop, 0, "rna_Brush_update");
1491
1492         prop = RNA_def_property(srna, "mask_tool", PROP_ENUM, PROP_NONE);
1493         RNA_def_property_enum_items(prop, brush_mask_tool_items);
1494         RNA_def_property_ui_text(prop, "Mask Tool", "");
1495         RNA_def_property_update(prop, 0, "rna_Brush_update");
1496
1497         /* number values */
1498         prop = RNA_def_property(srna, "size", PROP_INT, PROP_PIXEL);
1499         RNA_def_property_int_funcs(prop, NULL, "rna_Brush_set_size", NULL);
1500         RNA_def_property_range(prop, 1, MAX_BRUSH_PIXEL_RADIUS * 10);
1501         RNA_def_property_ui_range(prop, 1, MAX_BRUSH_PIXEL_RADIUS, 1, -1);
1502         RNA_def_property_ui_text(prop, "Radius", "Radius of the brush in pixels");
1503         RNA_def_property_update(prop, 0, "rna_Brush_size_update");
1504
1505         prop = RNA_def_property(srna, "unprojected_radius", PROP_FLOAT, PROP_DISTANCE);
1506         RNA_def_property_float_funcs(prop, NULL, "rna_Brush_set_unprojected_radius", NULL);
1507         RNA_def_property_range(prop, 0.001, FLT_MAX);
1508         RNA_def_property_ui_range(prop, 0.001, 1, 0, -1);
1509         RNA_def_property_ui_text(prop, "Unprojected Radius", "Radius of brush in Blender units");
1510         RNA_def_property_update(prop, 0, "rna_Brush_size_update");
1511
1512         prop = RNA_def_property(srna, "jitter", PROP_FLOAT, PROP_NONE);
1513         RNA_def_property_float_sdna(prop, NULL, "jitter");
1514         RNA_def_property_range(prop, 0.0f, 1000.0f);
1515         RNA_def_property_ui_range(prop, 0.0f, 2.0f, 0.1, 4);
1516         RNA_def_property_ui_text(prop, "Jitter", "Jitter the position of the brush while painting");
1517         RNA_def_property_update(prop, 0, "rna_Brush_update");
1518
1519         prop = RNA_def_property(srna, "jitter_absolute", PROP_INT, PROP_PIXEL);
1520         RNA_def_property_int_sdna(prop, NULL, "jitter_absolute");
1521         RNA_def_property_range(prop, 0, 1000000);
1522         RNA_def_property_ui_text(prop, "Jitter", "Jitter the position of the brush in pixels while painting");
1523         RNA_def_property_update(prop, 0, "rna_Brush_update");
1524
1525         prop = RNA_def_property(srna, "spacing", PROP_INT, PROP_PERCENTAGE);
1526         RNA_def_property_int_sdna(prop, NULL, "spacing");
1527         RNA_def_property_range(prop, 1, 1000);
1528         RNA_def_property_ui_range(prop, 1, 500, 5, -1);
1529         RNA_def_property_ui_text(prop, "Spacing", "Spacing between brush daubs as a percentage of brush diameter");
1530         RNA_def_property_update(prop, 0, "rna_Brush_update");
1531
1532         prop = RNA_def_property(srna, "grad_spacing", PROP_INT, PROP_NONE);
1533         RNA_def_property_int_sdna(prop, NULL, "gradient_spacing");
1534         RNA_def_property_range(prop, 1, 10000);
1535         RNA_def_property_ui_range(prop, 1, 10000, 5, -1);
1536         RNA_def_property_ui_text(prop, "Gradient Spacing", "Spacing before brush gradient goes full circle");
1537         RNA_def_property_update(prop, 0, "rna_Brush_update");
1538
1539         prop = RNA_def_property(srna, "smooth_stroke_radius", PROP_INT, PROP_PIXEL);
1540         RNA_def_property_range(prop, 10, 200);
1541         RNA_def_property_ui_text(prop, "Smooth Stroke Radius", "Minimum distance from last point before stroke continues");
1542         RNA_def_property_update(prop, 0, "rna_Brush_update");
1543
1544         prop = RNA_def_property(srna, "smooth_stroke_factor", PROP_FLOAT, PROP_FACTOR);
1545         RNA_def_property_range(prop, 0.5, 0.99);
1546         RNA_def_property_ui_text(prop, "Smooth Stroke Factor", "Higher values give a smoother stroke");
1547         RNA_def_property_update(prop, 0, "rna_Brush_update");
1548
1549         prop = RNA_def_property(srna, "rate", PROP_FLOAT, PROP_NONE);
1550         RNA_def_property_float_sdna(prop, NULL, "rate");
1551         RNA_def_property_range(prop, 0.0001f, 10000.0f);
1552         RNA_def_property_ui_range(prop, 0.01f, 1.0f, 1, 3);
1553         RNA_def_property_ui_text(prop, "Rate", "Interval between paints for Airbrush");
1554         RNA_def_property_update(prop, 0, "rna_Brush_update");
1555
1556         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
1557         RNA_def_property_range(prop, 0.0, 1.0);
1558         RNA_def_property_float_sdna(prop, NULL, "rgb");
1559         RNA_def_property_ui_text(prop, "Color", "");
1560         RNA_def_property_update(prop, 0, "rna_Brush_update");
1561
1562         prop = RNA_def_property(srna, "secondary_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1563         RNA_def_property_range(prop, 0.0, 1.0);
1564         RNA_def_property_float_sdna(prop, NULL, "secondary_rgb");
1565         RNA_def_property_ui_text(prop, "Secondary Color", "");
1566         RNA_def_property_update(prop, 0, "rna_Brush_update");
1567
1568         prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_FACTOR);
1569         RNA_def_property_float_default(prop, 1.0f);
1570         RNA_def_property_range(prop, 0.0f, 1.0f);
1571         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
1572         RNA_def_property_ui_text(prop, "Weight", "Vertex weight when brush is applied");
1573         RNA_def_property_update(prop, 0, "rna_Brush_update");
1574
1575         prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_FACTOR);
1576         RNA_def_property_float_sdna(prop, NULL, "alpha");
1577         RNA_def_property_float_default(prop, 0.5f);
1578         RNA_def_property_range(prop, 0.0f, 10.0f);
1579         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
1580         RNA_def_property_ui_text(prop, "Strength", "How powerful the effect of the brush is when applied");
1581         RNA_def_property_update(prop, 0, "rna_Brush_update");
1582
1583         prop = RNA_def_property(srna, "plane_offset", PROP_FLOAT, PROP_DISTANCE);
1584         RNA_def_property_float_sdna(prop, NULL, "plane_offset");
1585         RNA_def_property_float_default(prop, 0);
1586         RNA_def_property_range(prop, -2.0f, 2.0f);
1587         RNA_def_property_ui_range(prop, -0.5f, 0.5f, 0.001, 3);
1588         RNA_def_property_ui_text(prop, "Plane Offset",
1589                                  "Adjust plane on which the brush acts towards or away from the object surface");
1590         RNA_def_property_update(prop, 0, "rna_Brush_update");
1591
1592         prop = RNA_def_property(srna, "plane_trim", PROP_FLOAT, PROP_DISTANCE);
1593         RNA_def_property_float_sdna(prop, NULL, "plane_trim");
1594         RNA_def_property_float_default(prop, 0.5f);
1595         RNA_def_property_range(prop, 0, 1.0f);
1596         RNA_def_property_ui_text(prop, "Plane Trim",
1597                                  "If a vertex is further away from offset plane than this, then it is not affected");
1598         RNA_def_property_update(prop, 0, "rna_Brush_update");
1599
1600         prop = RNA_def_property(srna, "height", PROP_FLOAT, PROP_DISTANCE);
1601         RNA_def_property_float_sdna(prop, NULL, "height");
1602         RNA_def_property_float_default(prop, 0.5f);
1603         RNA_def_property_range(prop, 0, 1.0f);
1604         RNA_def_property_ui_text(prop, "Brush Height", "Affectable height of brush (layer height for layer tool, i.e.)");
1605         RNA_def_property_update(prop, 0, "rna_Brush_update");
1606
1607         prop = RNA_def_property(srna, "texture_sample_bias", PROP_FLOAT, PROP_DISTANCE);
1608         RNA_def_property_float_sdna(prop, NULL, "texture_sample_bias");
1609         RNA_def_property_float_default(prop, 0);
1610         RNA_def_property_range(prop, -1, 1);
1611         RNA_def_property_ui_text(prop, "Texture Sample Bias", "Value added to texture samples");
1612         RNA_def_property_update(prop, 0, "rna_Brush_update");
1613
1614         prop = RNA_def_property(srna, "normal_weight", PROP_FLOAT, PROP_FACTOR);
1615         RNA_def_property_float_sdna(prop, NULL, "normal_weight");
1616         RNA_def_property_float_default(prop, 0);
1617         RNA_def_property_range(prop, 0.0f, 1.0f);
1618         RNA_def_property_ui_text(prop, "Normal Weight", "How much grab will pull vertexes out of surface during a grab");
1619         RNA_def_property_update(prop, 0, "rna_Brush_update");
1620
1621         prop = RNA_def_property(srna, "rake_factor", PROP_FLOAT, PROP_FACTOR);
1622         RNA_def_property_float_sdna(prop, NULL, "rake_factor");
1623         RNA_def_property_float_default(prop, 0);
1624         RNA_def_property_range(prop, 0.0f, 10.0f);
1625         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
1626         RNA_def_property_ui_text(prop, "Rake", "How much grab will follow cursor rotation");
1627         RNA_def_property_update(prop, 0, "rna_Brush_update");
1628
1629         prop = RNA_def_property(srna, "crease_pinch_factor", PROP_FLOAT, PROP_FACTOR);
1630         RNA_def_property_float_sdna(prop, NULL, "crease_pinch_factor");
1631         RNA_def_property_float_default(prop, 2.0f / 3.0f);
1632         RNA_def_property_range(prop, 0.0f, 1.0f);
1633         RNA_def_property_ui_text(prop, "Crease Brush Pinch Factor", "How much the crease brush pinches");
1634         RNA_def_property_update(prop, 0, "rna_Brush_update");
1635
1636         prop = RNA_def_property(srna, "auto_smooth_factor", PROP_FLOAT, PROP_FACTOR);
1637         RNA_def_property_float_sdna(prop, NULL, "autosmooth_factor");
1638         RNA_def_property_float_default(prop, 0);
1639         RNA_def_property_range(prop, 0.0f, 1.0f);
1640         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
1641         RNA_def_property_ui_text(prop, "Autosmooth", "Amount of smoothing to automatically apply to each stroke");
1642         RNA_def_property_update(prop, 0, "rna_Brush_update");
1643
1644         prop = RNA_def_property(srna, "topology_rake_factor", PROP_FLOAT, PROP_FACTOR);
1645         RNA_def_property_float_sdna(prop, NULL, "topology_rake_factor");
1646         RNA_def_property_float_default(prop, 0);
1647         RNA_def_property_range(prop, 0.0f, 1.0f);
1648         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
1649         RNA_def_property_ui_text(prop, "Topology Rake", "Automatically align edges to the brush direction to "
1650                                                         "to generate cleaner topology and define sharp features "
1651                                                         "dynamic topology. Best used on low-poly meshes as it has "
1652                                                         "a performance impact");
1653         RNA_def_property_update(prop, 0, "rna_Brush_update");
1654
1655         prop = RNA_def_property(srna, "stencil_pos", PROP_FLOAT, PROP_XYZ);
1656         RNA_def_property_float_sdna(prop, NULL, "stencil_pos");
1657         RNA_def_property_array(prop, 2);
1658         RNA_def_property_ui_text(prop, "Stencil Position", "Position of stencil in viewport");
1659         RNA_def_property_update(prop, 0, "rna_Brush_update");
1660
1661         prop = RNA_def_property(srna, "stencil_dimension", PROP_FLOAT, PROP_XYZ);
1662         RNA_def_property_float_sdna(prop, NULL, "stencil_dimension");
1663         RNA_def_property_array(prop, 2);
1664         RNA_def_property_ui_text(prop, "Stencil Dimensions", "Dimensions of stencil in viewport");
1665         RNA_def_property_update(prop, 0, "rna_Brush_update");
1666
1667         prop = RNA_def_property(srna, "mask_stencil_pos", PROP_FLOAT, PROP_XYZ);
1668         RNA_def_property_float_sdna(prop, NULL, "mask_stencil_pos");
1669         RNA_def_property_array(prop, 2);
1670         RNA_def_property_ui_text(prop, "Mask Stencil Position", "Position of mask stencil in viewport");
1671         RNA_def_property_update(prop, 0, "rna_Brush_update");
1672
1673         prop = RNA_def_property(srna, "mask_stencil_dimension", PROP_FLOAT, PROP_XYZ);
1674         RNA_def_property_float_sdna(prop, NULL, "mask_stencil_dimension");
1675         RNA_def_property_array(prop, 2);
1676         RNA_def_property_ui_text(prop, "Mask Stencil Dimensions", "Dimensions of mask stencil in viewport");
1677         RNA_def_property_update(prop, 0, "rna_Brush_update");
1678
1679         prop = RNA_def_property(srna, "sharp_threshold", PROP_FLOAT, PROP_NONE);
1680         RNA_def_property_range(prop, 0.0, 100.0);
1681         RNA_def_property_ui_range(prop, 0.0, 1.0, 1, 3);
1682         RNA_def_property_float_sdna(prop, NULL, "sharp_threshold");
1683         RNA_def_property_ui_text(prop, "Sharp Threshold", "Threshold below which, no sharpening is done");
1684         RNA_def_property_update(prop, 0, "rna_Brush_update");
1685
1686         prop = RNA_def_property(srna, "fill_threshold", PROP_FLOAT, PROP_NONE);
1687         RNA_def_property_range(prop, 0.0, 100.0);
1688         RNA_def_property_ui_range(prop, 0.0, 1.0, 1, 3);
1689         RNA_def_property_float_sdna(prop, NULL, "fill_threshold");
1690         RNA_def_property_ui_text(prop, "Fill Threshold", "Threshold above which filling is not propagated");
1691         RNA_def_property_update(prop, 0, "rna_Brush_update");
1692
1693         prop = RNA_def_property(srna, "blur_kernel_radius", PROP_INT, PROP_NONE);
1694         RNA_def_property_int_sdna(prop, NULL, "blur_kernel_radius");
1695         RNA_def_property_range(prop, 1, 10000);
1696         RNA_def_property_ui_range(prop, 1, 50, 1, -1);
1697         RNA_def_property_ui_text(prop, "Kernel Radius", "Radius of kernel used for soften and sharpen in pixels");
1698         RNA_def_property_update(prop, 0, "rna_Brush_update");
1699
1700         prop = RNA_def_property(srna, "blur_mode", PROP_ENUM, PROP_NONE);
1701         RNA_def_property_enum_items(prop, brush_blur_mode_items);
1702         RNA_def_property_ui_text(prop, "Blur Mode", "");
1703         RNA_def_property_update(prop, 0, "rna_Brush_update");
1704
1705         prop = RNA_def_property(srna, "falloff_angle", PROP_FLOAT, PROP_ANGLE);
1706         RNA_def_property_float_sdna(prop, NULL, "falloff_angle");
1707         RNA_def_property_range(prop, 0, M_PI / 2);
1708         RNA_def_property_ui_text(prop, "Falloff Angle",
1709                                  "Paint most on faces pointing towards the view according to this angle");
1710         RNA_def_property_update(prop, 0, "rna_Brush_update");
1711
1712         /* flag */
1713         /* This is an enum but its unlikely we add other shapes, so expose as a boolean. */
1714         prop = RNA_def_property(srna, "use_projected", PROP_BOOLEAN, PROP_NONE);
1715         RNA_def_property_boolean_sdna(prop, NULL, "falloff_shape", BRUSH_AIRBRUSH);
1716         RNA_def_property_ui_text(prop, "2D Falloff", "Apply brush influence in 2D circle instead of a sphere");
1717         RNA_def_property_update(prop, 0, "rna_Brush_update");
1718
1719         prop = RNA_def_property(srna, "use_airbrush", PROP_BOOLEAN, PROP_NONE);
1720         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_AIRBRUSH);
1721         RNA_def_property_ui_text(prop, "Airbrush", "Keep applying paint effect while holding mouse (spray)");
1722         RNA_def_property_update(prop, 0, "rna_Brush_update");
1723
1724         prop = RNA_def_property(srna, "use_original_normal", PROP_BOOLEAN, PROP_NONE);
1725         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_ORIGINAL_NORMAL);
1726         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, true);
1727         RNA_def_property_ui_text(prop, "Original Normal",
1728                                  "When locked keep using normal of surface where stroke was initiated");
1729         RNA_def_property_update(prop, 0, "rna_Brush_update");
1730
1731         prop = RNA_def_property(srna, "use_pressure_strength", PROP_BOOLEAN, PROP_NONE);
1732         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_ALPHA_PRESSURE);
1733         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1734         RNA_def_property_ui_text(prop, "Strength Pressure", "Enable tablet pressure sensitivity for strength");
1735         RNA_def_property_update(prop, 0, "rna_Brush_update");
1736
1737         prop = RNA_def_property(srna, "use_offset_pressure", PROP_BOOLEAN, PROP_NONE);
1738         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_OFFSET_PRESSURE);
1739         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1740         RNA_def_property_ui_text(prop, "Plane Offset Pressure", "Enable tablet pressure sensitivity for offset");
1741         RNA_def_property_update(prop, 0, "rna_Brush_update");
1742
1743         prop = RNA_def_property(srna, "use_pressure_size", PROP_BOOLEAN, PROP_NONE);
1744         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_SIZE_PRESSURE);
1745         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1746         RNA_def_property_ui_text(prop, "Size Pressure", "Enable tablet pressure sensitivity for size");
1747         RNA_def_property_update(prop, 0, "rna_Brush_update");
1748
1749         prop = RNA_def_property(srna, "use_gradient", PROP_BOOLEAN, PROP_NONE);
1750         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_USE_GRADIENT);
1751         RNA_def_property_boolean_funcs(prop, NULL, "rna_Brush_use_gradient_set");
1752         RNA_def_property_ui_text(prop, "Use Gradient", "Use Gradient by utilizing a sampling method");
1753         RNA_def_property_update(prop, 0, "rna_Brush_update");
1754
1755         prop = RNA_def_property(srna, "use_pressure_jitter", PROP_BOOLEAN, PROP_NONE);
1756         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_JITTER_PRESSURE);
1757         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1758         RNA_def_property_ui_text(prop, "Jitter Pressure", "Enable tablet pressure sensitivity for jitter");
1759         RNA_def_property_update(prop, 0, "rna_Brush_update");
1760
1761         prop = RNA_def_property(srna, "use_pressure_spacing", PROP_BOOLEAN, PROP_NONE);
1762         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_SPACING_PRESSURE);
1763         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1764         RNA_def_property_ui_text(prop, "Spacing Pressure", "Enable tablet pressure sensitivity for spacing");
1765         RNA_def_property_update(prop, 0, "rna_Brush_update");
1766
1767         prop = RNA_def_property(srna, "use_pressure_masking", PROP_ENUM, PROP_NONE);
1768         RNA_def_property_enum_sdna(prop, NULL, "mask_pressure");
1769         RNA_def_property_enum_items(prop, brush_mask_pressure_items);
1770         RNA_def_property_ui_text(prop, "Mask Pressure Mode", "Pen pressure makes texture influence smaller");
1771         RNA_def_property_update(prop, 0, "rna_Brush_update");
1772
1773         prop = RNA_def_property(srna, "use_inverse_smooth_pressure", PROP_BOOLEAN, PROP_NONE);
1774         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_INVERSE_SMOOTH_PRESSURE);
1775         RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
1776         RNA_def_property_ui_text(prop, "Inverse Smooth Pressure", "Lighter pressure causes more smoothing to be applied");
1777         RNA_def_property_update(prop, 0, "rna_Brush_update");
1778
1779         prop = RNA_def_property(srna, "use_relative_jitter", PROP_BOOLEAN, PROP_NONE);
1780         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BRUSH_ABSOLUTE_JITTER);
1781         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, true);
1782         RNA_def_property_ui_text(prop, "Absolute Jitter", "Jittering happens in screen space, not relative to brush size");
1783         RNA_def_property_update(prop, 0, "rna_Brush_update");
1784
1785         prop = RNA_def_property(srna, "use_plane_trim", PROP_BOOLEAN, PROP_NONE);
1786         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_PLANE_TRIM);
1787         RNA_def_property_ui_text(prop, "Use Plane Trim", "Enable Plane Trim");
1788         RNA_def_property_update(prop, 0, "rna_Brush_update");
1789
1790         prop = RNA_def_property(srna, "use_frontface", PROP_BOOLEAN, PROP_NONE);
1791         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_FRONTFACE);
1792         RNA_def_property_ui_text(prop, "Use Front-Face", "Brush only affects vertexes that face the viewer");
1793         RNA_def_property_update(prop, 0, "rna_Brush_update");
1794
1795         prop = RNA_def_property(srna, "use_frontface_falloff", PROP_BOOLEAN, PROP_NONE);
1796         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_FRONTFACE_FALLOFF);
1797         RNA_def_property_ui_text(prop, "Use Front-Face Falloff", "Blend brush influence by how much they face the front");
1798         RNA_def_property_update(prop, 0, "rna_Brush_update");
1799
1800         prop = RNA_def_property(srna, "use_anchor", PROP_BOOLEAN, PROP_NONE);
1801         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_ANCHORED);
1802         RNA_def_property_ui_text(prop, "Anchored", "Keep the brush anchored to the initial location");
1803         RNA_def_property_update(prop, 0, "rna_Brush_update");
1804
1805         prop = RNA_def_property(srna, "use_space", PROP_BOOLEAN, PROP_NONE);
1806         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_SPACE);
1807         RNA_def_property_ui_text(prop, "Space", "Limit brush application to the distance specified by spacing");
1808         RNA_def_property_update(prop, 0, "rna_Brush_update");
1809
1810         prop = RNA_def_property(srna, "use_line", PROP_BOOLEAN, PROP_NONE);
1811         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_LINE);
1812         RNA_def_property_ui_text(prop, "Line", "Draw a line with dabs separated according to spacing");
1813         RNA_def_property_update(prop, 0, "rna_Brush_update");
1814
1815         prop = RNA_def_property(srna, "use_curve", PROP_BOOLEAN, PROP_NONE);
1816         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_CURVE);
1817         RNA_def_property_ui_text(prop, "Curve", "Define the stroke curve with a bezier curve. Dabs are separated according to spacing");
1818         RNA_def_property_update(prop, 0, "rna_Brush_update");
1819
1820         prop = RNA_def_property(srna, "use_smooth_stroke", PROP_BOOLEAN, PROP_NONE);
1821         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_SMOOTH_STROKE);
1822         RNA_def_property_ui_text(prop, "Smooth Stroke", "Brush lags behind mouse and follows a smoother path");
1823         RNA_def_property_update(prop, 0, "rna_Brush_update");
1824
1825         prop = RNA_def_property(srna, "use_persistent", PROP_BOOLEAN, PROP_NONE);
1826         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_PERSISTENT);
1827         RNA_def_property_ui_text(prop, "Persistent", "Sculpt on a persistent layer of the mesh");
1828         RNA_def_property_update(prop, 0, "rna_Brush_update");
1829
1830         prop = RNA_def_property(srna, "use_accumulate", PROP_BOOLEAN, PROP_NONE);
1831         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_ACCUMULATE);
1832         RNA_def_property_ui_text(prop, "Accumulate", "Accumulate stroke daubs on top of each other");
1833         RNA_def_property_update(prop, 0, "rna_Brush_update");
1834
1835         prop = RNA_def_property(srna, "use_space_attenuation", PROP_BOOLEAN, PROP_NONE);
1836         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_SPACE_ATTEN);
1837         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, true);
1838         RNA_def_property_ui_text(prop, "Use Automatic Strength Adjustment",
1839                                  "Automatically adjust strength to give consistent results for different spacings");
1840         RNA_def_property_update(prop, 0, "rna_Brush_update");
1841
1842         /* adaptive space is not implemented yet */
1843         prop = RNA_def_property(srna, "use_adaptive_space", PROP_BOOLEAN, PROP_NONE);
1844         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_ADAPTIVE_SPACE);
1845         RNA_def_property_ui_text(prop, "Adaptive Spacing",
1846                                  "Space daubs according to surface orientation instead of screen space");
1847         RNA_def_property_update(prop, 0, "rna_Brush_update");
1848
1849         prop = RNA_def_property(srna, "use_locked_size", PROP_BOOLEAN, PROP_NONE);
1850         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_LOCK_SIZE);
1851         RNA_def_property_ui_text(prop, "Use Blender Units",
1852                                  "When locked brush stays same size relative to object; when unlocked brush size is "
1853                                  "given in pixels");
1854         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, true);
1855         RNA_def_property_update(prop, 0, "rna_Brush_update");
1856
1857         prop = RNA_def_property(srna, "use_edge_to_edge", PROP_BOOLEAN, PROP_NONE);
1858         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_EDGE_TO_EDGE);
1859         RNA_def_property_ui_text(prop, "Edge-to-edge", "Drag anchor brush from edge-to-edge");
1860         RNA_def_property_update(prop, 0, "rna_Brush_update");
1861
1862         prop = RNA_def_property(srna, "use_restore_mesh", PROP_BOOLEAN, PROP_NONE);
1863         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_DRAG_DOT);
1864         RNA_def_property_ui_text(prop, "Restore Mesh", "Allow a single dot to be carefully positioned");
1865         RNA_def_property_update(prop, 0, "rna_Brush_update");
1866
1867         /* only for projection paint & vertex paint, TODO, other paint modes */
1868         prop = RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
1869         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BRUSH_LOCK_ALPHA);
1870         RNA_def_property_ui_text(prop, "Alpha", "When this is disabled, lock alpha while painting");
1871         RNA_def_property_update(prop, 0, "rna_Brush_update");
1872
1873         prop = RNA_def_property(srna, "curve", PROP_POINTER, PROP_NONE);
1874         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1875         RNA_def_property_ui_text(prop, "Curve", "Editable falloff curve");
1876         RNA_def_property_update(prop, 0, "rna_Brush_update");
1877
1878         prop = RNA_def_property(srna, "paint_curve", PROP_POINTER, PROP_NONE);
1879         RNA_def_property_flag(prop, PROP_EDITABLE);
1880         RNA_def_property_ui_text(prop, "Paint Curve", "Active Paint Curve");
1881         RNA_def_property_update(prop, 0, "rna_Brush_update");
1882
1883         prop = RNA_def_property(srna, "gradient", PROP_POINTER, PROP_NEVER_NULL);
1884         RNA_def_property_pointer_sdna(prop, NULL, "gradient");
1885         RNA_def_property_struct_type(prop, "ColorRamp");
1886         RNA_def_property_ui_text(prop, "Gradient", "");
1887         RNA_def_property_update(prop, 0, "rna_Brush_update");
1888
1889         /* gradient source */
1890         prop = RNA_def_property(srna, "gradient_stroke_mode", PROP_ENUM, PROP_NONE);
1891         RNA_def_property_enum_items(prop, brush_gradient_items);
1892         RNA_def_property_ui_text(prop, "Gradient Stroke Mode", "");
1893         RNA_def_property_update(prop, 0, "rna_Brush_update");
1894
1895         prop = RNA_def_property(srna, "gradient_fill_mode", PROP_ENUM, PROP_NONE);
1896         RNA_def_property_enum_items(prop, brush_gradient_fill_items);
1897         RNA_def_property_ui_text(prop, "Gradient Fill Mode", "");
1898         RNA_def_property_update(prop, 0, "rna_Brush_update");
1899
1900         /* overlay flags */
1901         prop = RNA_def_property(srna, "use_primary_overlay", PROP_BOOLEAN, PROP_NONE);
1902         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_PRIMARY);
1903         RNA_def_property_ui_text(prop, "Use Texture Overlay", "Show texture in viewport");
1904         RNA_def_property_update(prop, 0, "rna_Brush_update");
1905
1906         prop = RNA_def_property(srna, "use_secondary_overlay", PROP_BOOLEAN, PROP_NONE);
1907         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_SECONDARY);
1908         RNA_def_property_ui_text(prop, "Use Texture Overlay", "Show texture in viewport");
1909         RNA_def_property_update(prop, 0, "rna_Brush_update");
1910
1911         prop = RNA_def_property(srna, "use_cursor_overlay", PROP_BOOLEAN, PROP_NONE);
1912         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_CURSOR);
1913         RNA_def_property_ui_text(prop, "Use Cursor Overlay", "Show cursor in viewport");
1914         RNA_def_property_update(prop, 0, "rna_Brush_update");
1915
1916         prop = RNA_def_property(srna, "use_cursor_overlay_override", PROP_BOOLEAN, PROP_NONE);
1917         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_CURSOR_OVERRIDE_ON_STROKE);
1918         RNA_def_property_ui_text(prop, "Override Overlay", "Don't show overlay during a stroke");
1919         RNA_def_property_update(prop, 0, "rna_Brush_update");
1920
1921         prop = RNA_def_property(srna, "use_primary_overlay_override", PROP_BOOLEAN, PROP_NONE);
1922         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_PRIMARY_OVERRIDE_ON_STROKE);
1923         RNA_def_property_ui_text(prop, "Override Overlay", "Don't show overlay during a stroke");
1924         RNA_def_property_update(prop, 0, "rna_Brush_update");
1925
1926         prop = RNA_def_property(srna, "use_secondary_overlay_override", PROP_BOOLEAN, PROP_NONE);
1927         RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_SECONDARY_OVERRIDE_ON_STROKE);
1928         RNA_def_property_ui_text(prop, "Override Overlay", "Don't show overlay during a stroke");
1929         RNA_def_property_update(prop, 0, "rna_Brush_update");
1930
1931         /* paint mode flags */
1932         prop = RNA_def_property(srna, "use_paint_sculpt", PROP_BOOLEAN, PROP_NONE);
1933         RNA_def_property_boolean_sdna(prop, NULL, "ob_mode", OB_MODE_SCULPT);
1934         RNA_def_property_ui_text(prop, "Use Sculpt", "Use this brush in sculpt mode");
1935
1936         prop = RNA_def_property(srna, "use_paint_vertex", PROP_BOOLEAN, PROP_NONE);
1937         RNA_def_property_boolean_sdna(prop, NULL, "ob_mode", OB_MODE_VERTEX_PAINT);
1938         RNA_def_property_ui_text(prop, "Use Vertex", "Use this brush in vertex paint mode");
1939
1940         prop = RNA_def_property(srna, "use_paint_weight", PROP_BOOLEAN, PROP_NONE);
1941         RNA_def_property_boolean_sdna(prop, NULL, "ob_mode", OB_MODE_WEIGHT_PAINT);
1942         RNA_def_property_ui_text(prop, "Use Weight", "Use this brush in weight paint mode");
1943
1944         prop = RNA_def_property(srna, "use_paint_image", PROP_BOOLEAN, PROP_NONE);
1945         RNA_def_property_boolean_sdna(prop, NULL, "ob_mode", OB_MODE_TEXTURE_PAINT);
1946         RNA_def_property_ui_text(prop, "Use Texture", "Use this brush in texture paint mode");
1947
1948         prop = RNA_def_property(srna, "use_paint_grease_pencil", PROP_BOOLEAN, PROP_NONE);
1949         RNA_def_property_boolean_sdna(prop, NULL, "ob_mode", OB_MODE_PAINT_GPENCIL);
1950         RNA_def_property_ui_text(prop, "Use Sculpt", "Use this brush in grease pencil drawing mode");
1951
1952         /* texture */
1953         prop = RNA_def_property(srna, "texture_slot", PROP_POINTER, PROP_NONE);
1954         RNA_def_property_struct_type(prop, "BrushTextureSlot");
1955         RNA_def_property_pointer_sdna(prop, NULL, "mtex");
1956         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1957         RNA_def_property_ui_text(prop, "Texture Slot", "");
1958
1959         prop = RNA_def_property(srna, "texture", PROP_POINTER, PROP_NONE);
1960         RNA_def_property_pointer_sdna(prop, NULL, "mtex.tex");
1961         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_CONTEXT_UPDATE);
1962         RNA_def_property_ui_text(prop, "Texture", "");
1963         RNA_def_property_update(prop, NC_TEXTURE, "rna_Brush_main_tex_update");
1964
1965         prop = RNA_def_property(srna, "mask_texture_slot", PROP_POINTER, PROP_NONE);
1966         RNA_def_property_struct_type(prop, "BrushTextureSlot");
1967         RNA_def_property_pointer_sdna(prop, NULL, "mask_mtex");
1968         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1969         RNA_def_property_ui_text(prop, "Mask Texture Slot", "");
1970
1971         prop = RNA_def_property(srna, "mask_texture", PROP_POINTER, PROP_NONE);
1972         RNA_def_property_pointer_sdna(prop, NULL, "mask_mtex.tex");
1973         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_CONTEXT_UPDATE);
1974         RNA_def_property_ui_text(prop, "Mask Texture", "");
1975         RNA_def_property_update(prop, NC_TEXTURE, "rna_Brush_secondary_tex_update");
1976
1977         prop = RNA_def_property(srna, "texture_overlay_alpha", PROP_INT, PROP_PERCENTAGE);
1978         RNA_def_property_int_sdna(prop, NULL, "texture_overlay_alpha");
1979         RNA_def_property_range(prop, 0, 100);
1980         RNA_def_property_ui_text(prop, "Texture Overlay Alpha", "");
1981         RNA_def_property_update(prop, 0, "rna_Brush_update");
1982
1983         prop = RNA_def_property(srna, "mask_overlay_alpha", PROP_INT, PROP_PERCENTAGE);
1984         RNA_def_property_int_sdna(prop, NULL, "mask_overlay_alpha");
1985         RNA_def_property_range(prop, 0, 100);
1986         RNA_def_property_ui_text(prop, "Mask Texture Overlay Alpha", "");
1987         RNA_def_property_update(prop, 0, "rna_Brush_update");
1988
1989         prop = RNA_def_property(srna, "cursor_overlay_alpha", PROP_INT, PROP_PERCENTAGE);
1990         RNA_def_property_int_sdna(prop, NULL, "cursor_overlay_alpha");
1991         RNA_def_property_range(prop, 0, 100);
1992         RNA_def_property_ui_text(prop, "Mask Texture Overlay Alpha", "");
1993         RNA_def_property_update(prop, 0, "rna_Brush_update");
1994
1995         prop = RNA_def_property(srna, "cursor_color_add", PROP_FLOAT, PROP_COLOR);
1996         RNA_def_property_float_sdna(prop, NULL, "add_col");
1997         RNA_def_property_array(prop, 3);
1998         RNA_def_property_ui_text(prop, "Add Color", "Color of cursor when adding");
1999         RNA_def_property_update(prop, 0, "rna_Brush_update");
2000
2001         prop = RNA_def_property(srna, "cursor_color_subtract", PROP_FLOAT, PROP_COLOR);
2002         RNA_def_property_float_sdna(prop, NULL, "sub_col");
2003         RNA_def_property_array(prop, 3);
2004         RNA_def_property_ui_text(prop, "Subtract Color", "Color of cursor when subtracting");
2005         RNA_def_property_update(prop, 0, "rna_Brush_update");
2006
2007         prop = RNA_def_property(srna, "use_custom_icon", PROP_BOOLEAN, PROP_NONE);
2008         RNA_def_property_boolean_sdna(prop, NULL, "flag", BRUSH_CUSTOM_ICON);
2009         RNA_def_property_ui_text(prop, "Custom Icon", "Set the brush icon from an image file");
2010         RNA_def_property_update(prop, 0, "rna_Brush_icon_update");
2011
2012         prop = RNA_def_property(srna, "icon_filepath", PROP_STRING, PROP_FILEPATH);
2013         RNA_def_property_string_sdna(prop, NULL, "icon_filepath");
2014         RNA_def_property_ui_text(prop, "Brush Icon Filepath", "File path to brush icon");
2015         RNA_def_property_update(prop, 0, "rna_Brush_icon_update");
2016
2017         /* clone tool */
2018         prop = RNA_def_property(srna, "clone_image", PROP_POINTER, PROP_NONE);
2019         RNA_def_property_pointer_sdna(prop, NULL, "clone.image");
2020         RNA_def_property_flag(prop, PROP_EDITABLE);
2021         RNA_def_property_ui_text(prop, "Clone Image", "Image for clone tool");
2022         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_Brush_update");
2023
2024         prop = RNA_def_property(srna, "clone_alpha", PROP_FLOAT, PROP_FACTOR);
2025         RNA_def_property_float_sdna(prop, NULL, "clone.alpha");
2026         RNA_def_property_range(prop, 0.0f, 1.0f);
2027         RNA_def_property_ui_text(prop, "Clone Alpha", "Opacity of clone image display");
2028         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_Brush_update");
2029
2030         prop = RNA_def_property(srna, "clone_offset", PROP_FLOAT, PROP_XYZ);
2031         RNA_def_property_float_sdna(prop, NULL, "clone.offset");
2032         RNA_def_property_ui_text(prop, "Clone Offset", "");
2033         RNA_def_property_ui_range(prop, -1.0f, 1.0f, 10.0f, 3);
2034         RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_Brush_update");
2035
2036         prop = RNA_def_property(srna, "brush_capabilities", PROP_POINTER, PROP_NONE);
2037         RNA_def_property_flag(prop, PROP_NEVER_NULL);
2038         RNA_def_property_struct_type(prop, "BrushCapabilities");
2039         RNA_def_property_pointer_funcs(prop, "rna_Brush_capabilities_get", NULL, NULL, NULL);
2040         RNA_def_property_ui_text(prop, "Brush Capabilities", "Brush's capabilities");
2041
2042         /* brush capabilities (mode-dependent) */
2043         prop = RNA_def_property(srna, "sculpt_capabilities", PROP_POINTER, PROP_NONE);
2044         RNA_def_property_flag(prop, PROP_NEVER_NULL);
2045         RNA_def_property_struct_type(prop, "BrushCapabilitiesSculpt");
2046         RNA_def_property_pointer_funcs(prop, "rna_Sculpt_tool_capabilities_get", NULL, NULL, NULL);
2047         RNA_def_property_ui_text(prop, "Sculpt Capabilities", "");
2048
2049         prop = RNA_def_property(srna, "image_paint_capabilities", PROP_POINTER, PROP_NONE);
2050         RNA_def_property_flag(prop, PROP_NEVER_NULL);
2051         RNA_def_property_struct_type(prop, "BrushCapabilitiesImagePaint");
2052         RNA_def_property_pointer_funcs(prop, "rna_Imapaint_tool_capabilities_get", NULL, NULL, NULL);
2053         RNA_def_property_ui_text(prop, "Image Paint Capabilities", "");
2054
2055         prop = RNA_def_property(srna, "vertex_paint_capabilities", PROP_POINTER, PROP_NONE);
2056         RNA_def_property_flag(prop, PROP_NEVER_NULL);
2057         RNA_def_property_struct_type(prop, "BrushCapabilitiesVertexPaint");
2058         RNA_def_property_pointer_funcs(prop, "rna_Vertexpaint_tool_capabilities_get", NULL, NULL, NULL);
2059         RNA_def_property_ui_text(prop, "Vertex Paint Capabilities", "");
2060
2061         prop = RNA_def_property(srna, "weight_paint_capabilities", PROP_POINTER, PROP_NONE);
2062         RNA_def_property_flag(prop, PROP_NEVER_NULL);
2063         RNA_def_property_struct_type(prop, "BrushCapabilitiesWeightPaint");
2064         RNA_def_property_pointer_funcs(prop, "rna_Weightpaint_tool_capabilities_get", NULL, NULL, NULL);
2065         RNA_def_property_ui_text(prop, "Weight Paint Capabilities", "");
2066
2067         prop = RNA_def_property(srna, "gpencil_settings", PROP_POINTER, PROP_NONE);
2068         RNA_def_property_struct_type(prop, "BrushGpencilSettings");
2069         RNA_def_property_pointer_sdna(prop, NULL, "gpencil_settings");
2070         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2071         RNA_def_property_ui_text(prop, "Gpencil Settings", "");
2072
2073 }
2074
2075 /**
2076  * A brush stroke is a list of changes to the brush that
2077  * can occur during a stroke
2078  *
2079  * - 3D location of the brush
2080  * - 2D mouse location
2081  * - Tablet pressure
2082  * - Direction flip
2083  * - Tool switch
2084  * - Time
2085  */
2086 static void rna_def_operator_stroke_element(BlenderRNA *brna)
2087 {
2088         StructRNA *srna;
2089         PropertyRNA *prop;
2090
2091         srna = RNA_def_struct(brna, "OperatorStrokeElement", "PropertyGroup");
2092         RNA_def_struct_ui_text(srna, "Operator Stroke Element", "");
2093
2094         prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_XYZ);
2095         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2096         RNA_def_property_array(prop, 3);
2097         RNA_def_property_ui_text(prop, "Location", "");
2098
2099         prop = RNA_def_property(srna, "mouse", PROP_FLOAT, PROP_XYZ);
2100         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2101         RNA_def_property_array(prop, 2);
2102         RNA_def_property_ui_text(prop, "Mouse", "");
2103
2104         prop = RNA_def_property(srna, "pressure", PROP_FLOAT, PROP_FACTOR);
2105         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2106         RNA_def_property_range(prop, 0.0f, 1.0f);
2107         RNA_def_property_ui_text(prop, "Pressure", "Tablet pressure");
2108
2109         prop = RNA_def_property(srna, "size", PROP_FLOAT, PROP_NONE);
2110         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2111         RNA_def_property_range(prop, 0.0f, FLT_MAX);
2112         RNA_def_property_ui_text(prop, "Brush Size", "Brush Size in screen space");
2113
2114         prop = RNA_def_property(srna, "pen_flip", PROP_BOOLEAN, PROP_NONE);
2115         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2116         RNA_def_property_ui_text(prop, "Flip", "");
2117
2118         /* used in uv painting */
2119         prop = RNA_def_property(srna, "time", PROP_FLOAT, PROP_UNSIGNED);
2120         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2121         RNA_def_property_ui_text(prop, "Time", "");
2122
2123         /* used for Grease Pencil sketching sessions */
2124         prop = RNA_def_property(srna, "is_start", PROP_BOOLEAN, PROP_NONE);
2125         RNA_def_property_flag(prop, PROP_IDPROPERTY);
2126         RNA_def_property_ui_text(prop, "Is Stroke Start", "");
2127
2128         /* XXX: Tool (this will be for pressing a modifier key for a different brush,
2129          *      e.g. switching to a Smooth brush in the middle of the stroke */
2130
2131         /* XXX: i don't think blender currently supports the ability to properly do a remappable modifier
2132          *      in the middle of a stroke */
2133 }
2134
2135 void RNA_def_brush(BlenderRNA *brna)
2136 {
2137         rna_def_brush(brna);
2138         rna_def_brush_capabilities(brna);
2139         rna_def_sculpt_capabilities(brna);
2140         rna_def_image_paint_capabilities(brna);
2141         rna_def_vertex_paint_capabilities(brna);
2142         rna_def_weight_paint_capabilities(brna);
2143         rna_def_gpencil_options(brna);
2144         rna_def_brush_texture_slot(brna);
2145         rna_def_operator_stroke_element(brna);
2146 }
2147
2148 #endif