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 bke
19 */
20
21 #include "MEM_guardedalloc.h"
22
23 #include "DNA_brush_types.h"
24 #include "DNA_defaults.h"
25 #include "DNA_gpencil_types.h"
26 #include "DNA_object_types.h"
27 #include "DNA_scene_types.h"
28
29 #include "BLI_listbase.h"
30 #include "BLI_math.h"
31 #include "BLI_rand.h"
32
33 #include "BLT_translation.h"
34
35 #include "BKE_brush.h"
36 #include "BKE_colortools.h"
37 #include "BKE_context.h"
38 #include "BKE_gpencil.h"
39 #include "BKE_icons.h"
40 #include "BKE_idtype.h"
41 #include "BKE_lib_id.h"
42 #include "BKE_lib_query.h"
43 #include "BKE_lib_remap.h"
44 #include "BKE_main.h"
45 #include "BKE_material.h"
46 #include "BKE_paint.h"
47 #include "BKE_texture.h"
48
49 #include "IMB_colormanagement.h"
50 #include "IMB_imbuf.h"
51 #include "IMB_imbuf_types.h"
52
53 #include "RE_render_ext.h" /* RE_texture_evaluate */
54
55 #include "BLO_read_write.h"
56
brush_init_data(ID * id)57 static void brush_init_data(ID *id)
58 {
59 Brush *brush = (Brush *)id;
60 BLI_assert(MEMCMP_STRUCT_AFTER_IS_ZERO(brush, id));
61
62 MEMCPY_STRUCT_AFTER(brush, DNA_struct_default_get(Brush), id);
63
64 /* enable fake user by default */
65 id_fake_user_set(&brush->id);
66
67 /* the default alpha falloff curve */
68 BKE_brush_curve_preset(brush, CURVE_PRESET_SMOOTH);
69 }
70
brush_copy_data(Main * UNUSED (bmain),ID * id_dst,const ID * id_src,const int flag)71 static void brush_copy_data(Main *UNUSED(bmain), ID *id_dst, const ID *id_src, const int flag)
72 {
73 Brush *brush_dst = (Brush *)id_dst;
74 const Brush *brush_src = (const Brush *)id_src;
75 if (brush_src->icon_imbuf) {
76 brush_dst->icon_imbuf = IMB_dupImBuf(brush_src->icon_imbuf);
77 }
78
79 if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
80 BKE_previewimg_id_copy(&brush_dst->id, &brush_src->id);
81 }
82 else {
83 brush_dst->preview = NULL;
84 }
85
86 brush_dst->curve = BKE_curvemapping_copy(brush_src->curve);
87 if (brush_src->gpencil_settings != NULL) {
88 brush_dst->gpencil_settings = MEM_dupallocN(brush_src->gpencil_settings);
89 brush_dst->gpencil_settings->curve_sensitivity = BKE_curvemapping_copy(
90 brush_src->gpencil_settings->curve_sensitivity);
91 brush_dst->gpencil_settings->curve_strength = BKE_curvemapping_copy(
92 brush_src->gpencil_settings->curve_strength);
93 brush_dst->gpencil_settings->curve_jitter = BKE_curvemapping_copy(
94 brush_src->gpencil_settings->curve_jitter);
95
96 brush_dst->gpencil_settings->curve_rand_pressure = BKE_curvemapping_copy(
97 brush_src->gpencil_settings->curve_rand_pressure);
98 brush_dst->gpencil_settings->curve_rand_strength = BKE_curvemapping_copy(
99 brush_src->gpencil_settings->curve_rand_strength);
100 brush_dst->gpencil_settings->curve_rand_uv = BKE_curvemapping_copy(
101 brush_src->gpencil_settings->curve_rand_uv);
102 brush_dst->gpencil_settings->curve_rand_hue = BKE_curvemapping_copy(
103 brush_src->gpencil_settings->curve_rand_hue);
104 brush_dst->gpencil_settings->curve_rand_saturation = BKE_curvemapping_copy(
105 brush_src->gpencil_settings->curve_rand_saturation);
106 brush_dst->gpencil_settings->curve_rand_value = BKE_curvemapping_copy(
107 brush_src->gpencil_settings->curve_rand_value);
108 }
109
110 /* enable fake user by default */
111 id_fake_user_set(&brush_dst->id);
112 }
113
brush_free_data(ID * id)114 static void brush_free_data(ID *id)
115 {
116 Brush *brush = (Brush *)id;
117 if (brush->icon_imbuf) {
118 IMB_freeImBuf(brush->icon_imbuf);
119 }
120 BKE_curvemapping_free(brush->curve);
121
122 if (brush->gpencil_settings != NULL) {
123 BKE_curvemapping_free(brush->gpencil_settings->curve_sensitivity);
124 BKE_curvemapping_free(brush->gpencil_settings->curve_strength);
125 BKE_curvemapping_free(brush->gpencil_settings->curve_jitter);
126
127 BKE_curvemapping_free(brush->gpencil_settings->curve_rand_pressure);
128 BKE_curvemapping_free(brush->gpencil_settings->curve_rand_strength);
129 BKE_curvemapping_free(brush->gpencil_settings->curve_rand_uv);
130 BKE_curvemapping_free(brush->gpencil_settings->curve_rand_hue);
131 BKE_curvemapping_free(brush->gpencil_settings->curve_rand_saturation);
132 BKE_curvemapping_free(brush->gpencil_settings->curve_rand_value);
133
134 MEM_SAFE_FREE(brush->gpencil_settings);
135 }
136
137 MEM_SAFE_FREE(brush->gradient);
138
139 BKE_previewimg_free(&(brush->preview));
140 }
141
brush_make_local(Main * bmain,ID * id,const int flags)142 static void brush_make_local(Main *bmain, ID *id, const int flags)
143 {
144 Brush *brush = (Brush *)id;
145 const bool lib_local = (flags & LIB_ID_MAKELOCAL_FULL_LIBRARY) != 0;
146 bool is_local = false, is_lib = false;
147
148 /* - only lib users: do nothing (unless force_local is set)
149 * - only local users: set flag
150 * - mixed: make copy
151 */
152
153 if (!ID_IS_LINKED(brush)) {
154 return;
155 }
156
157 if (brush->clone.image) {
158 /* Special case: ima always local immediately. Clone image should only have one user anyway. */
159 BKE_lib_id_make_local(bmain, &brush->clone.image->id, false, 0);
160 }
161
162 BKE_library_ID_test_usages(bmain, brush, &is_local, &is_lib);
163
164 if (lib_local || is_local) {
165 if (!is_lib) {
166 BKE_lib_id_clear_library_data(bmain, &brush->id);
167 BKE_lib_id_expand_local(bmain, &brush->id);
168
169 /* enable fake user by default */
170 id_fake_user_set(&brush->id);
171 }
172 else {
173 Brush *brush_new = (Brush *)BKE_id_copy(bmain, &brush->id); /* Ensures FAKE_USER is set */
174
175 brush_new->id.us = 0;
176
177 /* setting newid is mandatory for complex make_lib_local logic... */
178 ID_NEW_SET(brush, brush_new);
179
180 if (!lib_local) {
181 BKE_libblock_remap(bmain, brush, brush_new, ID_REMAP_SKIP_INDIRECT_USAGE);
182 }
183 }
184 }
185 }
186
brush_foreach_id(ID * id,LibraryForeachIDData * data)187 static void brush_foreach_id(ID *id, LibraryForeachIDData *data)
188 {
189 Brush *brush = (Brush *)id;
190
191 BKE_LIB_FOREACHID_PROCESS(data, brush->toggle_brush, IDWALK_CB_NOP);
192 BKE_LIB_FOREACHID_PROCESS(data, brush->clone.image, IDWALK_CB_NOP);
193 BKE_LIB_FOREACHID_PROCESS(data, brush->paint_curve, IDWALK_CB_USER);
194 if (brush->gpencil_settings) {
195 BKE_LIB_FOREACHID_PROCESS(data, brush->gpencil_settings->material, IDWALK_CB_USER);
196 }
197 BKE_texture_mtex_foreach_id(data, &brush->mtex);
198 BKE_texture_mtex_foreach_id(data, &brush->mask_mtex);
199 }
200
brush_blend_write(BlendWriter * writer,ID * id,const void * id_address)201 static void brush_blend_write(BlendWriter *writer, ID *id, const void *id_address)
202 {
203 Brush *brush = (Brush *)id;
204 if (brush->id.us > 0 || BLO_write_is_undo(writer)) {
205 BLO_write_id_struct(writer, Brush, id_address, &brush->id);
206 BKE_id_blend_write(writer, &brush->id);
207
208 if (brush->curve) {
209 BKE_curvemapping_blend_write(writer, brush->curve);
210 }
211
212 if (brush->gpencil_settings) {
213 BLO_write_struct(writer, BrushGpencilSettings, brush->gpencil_settings);
214
215 if (brush->gpencil_settings->curve_sensitivity) {
216 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_sensitivity);
217 }
218 if (brush->gpencil_settings->curve_strength) {
219 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_strength);
220 }
221 if (brush->gpencil_settings->curve_jitter) {
222 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_jitter);
223 }
224 if (brush->gpencil_settings->curve_rand_pressure) {
225 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_pressure);
226 }
227 if (brush->gpencil_settings->curve_rand_strength) {
228 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_strength);
229 }
230 if (brush->gpencil_settings->curve_rand_uv) {
231 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_uv);
232 }
233 if (brush->gpencil_settings->curve_rand_hue) {
234 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_hue);
235 }
236 if (brush->gpencil_settings->curve_rand_saturation) {
237 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_saturation);
238 }
239 if (brush->gpencil_settings->curve_rand_value) {
240 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_value);
241 }
242 }
243 if (brush->gradient) {
244 BLO_write_struct(writer, ColorBand, brush->gradient);
245 }
246 }
247 }
248
brush_blend_read_data(BlendDataReader * reader,ID * id)249 static void brush_blend_read_data(BlendDataReader *reader, ID *id)
250 {
251 Brush *brush = (Brush *)id;
252
253 /* Falloff curve. */
254 BLO_read_data_address(reader, &brush->curve);
255
256 BLO_read_data_address(reader, &brush->gradient);
257
258 if (brush->curve) {
259 BKE_curvemapping_blend_read(reader, brush->curve);
260 }
261 else {
262 BKE_brush_curve_preset(brush, CURVE_PRESET_SHARP);
263 }
264
265 /* grease pencil */
266 BLO_read_data_address(reader, &brush->gpencil_settings);
267 if (brush->gpencil_settings != NULL) {
268 BLO_read_data_address(reader, &brush->gpencil_settings->curve_sensitivity);
269 BLO_read_data_address(reader, &brush->gpencil_settings->curve_strength);
270 BLO_read_data_address(reader, &brush->gpencil_settings->curve_jitter);
271
272 BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_pressure);
273 BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_strength);
274 BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_uv);
275 BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_hue);
276 BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_saturation);
277 BLO_read_data_address(reader, &brush->gpencil_settings->curve_rand_value);
278
279 if (brush->gpencil_settings->curve_sensitivity) {
280 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_sensitivity);
281 }
282
283 if (brush->gpencil_settings->curve_strength) {
284 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_strength);
285 }
286
287 if (brush->gpencil_settings->curve_jitter) {
288 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_jitter);
289 }
290
291 if (brush->gpencil_settings->curve_rand_pressure) {
292 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_pressure);
293 }
294
295 if (brush->gpencil_settings->curve_rand_strength) {
296 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_strength);
297 }
298
299 if (brush->gpencil_settings->curve_rand_uv) {
300 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_uv);
301 }
302
303 if (brush->gpencil_settings->curve_rand_hue) {
304 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_hue);
305 }
306
307 if (brush->gpencil_settings->curve_rand_saturation) {
308 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_saturation);
309 }
310
311 if (brush->gpencil_settings->curve_rand_value) {
312 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_value);
313 }
314 }
315
316 brush->preview = NULL;
317 brush->icon_imbuf = NULL;
318 }
319
brush_blend_read_lib(BlendLibReader * reader,ID * id)320 static void brush_blend_read_lib(BlendLibReader *reader, ID *id)
321 {
322 Brush *brush = (Brush *)id;
323
324 /* brush->(mask_)mtex.obj is ignored on purpose? */
325 BLO_read_id_address(reader, brush->id.lib, &brush->mtex.tex);
326 BLO_read_id_address(reader, brush->id.lib, &brush->mask_mtex.tex);
327 BLO_read_id_address(reader, brush->id.lib, &brush->clone.image);
328 BLO_read_id_address(reader, brush->id.lib, &brush->toggle_brush);
329 BLO_read_id_address(reader, brush->id.lib, &brush->paint_curve);
330
331 /* link default grease pencil palette */
332 if (brush->gpencil_settings != NULL) {
333 if (brush->gpencil_settings->flag & GP_BRUSH_MATERIAL_PINNED) {
334 BLO_read_id_address(reader, brush->id.lib, &brush->gpencil_settings->material);
335
336 if (!brush->gpencil_settings->material) {
337 brush->gpencil_settings->flag &= ~GP_BRUSH_MATERIAL_PINNED;
338 }
339 }
340 else {
341 brush->gpencil_settings->material = NULL;
342 }
343 }
344 }
345
brush_blend_read_expand(BlendExpander * expander,ID * id)346 static void brush_blend_read_expand(BlendExpander *expander, ID *id)
347 {
348 Brush *brush = (Brush *)id;
349 BLO_expand(expander, brush->mtex.tex);
350 BLO_expand(expander, brush->mask_mtex.tex);
351 BLO_expand(expander, brush->clone.image);
352 BLO_expand(expander, brush->paint_curve);
353 if (brush->gpencil_settings != NULL) {
354 BLO_expand(expander, brush->gpencil_settings->material);
355 }
356 }
357
358 IDTypeInfo IDType_ID_BR = {
359 .id_code = ID_BR,
360 .id_filter = FILTER_ID_BR,
361 .main_listbase_index = INDEX_ID_BR,
362 .struct_size = sizeof(Brush),
363 .name = "Brush",
364 .name_plural = "brushes",
365 .translation_context = BLT_I18NCONTEXT_ID_BRUSH,
366 .flags = IDTYPE_FLAGS_NO_ANIMDATA,
367
368 .init_data = brush_init_data,
369 .copy_data = brush_copy_data,
370 .free_data = brush_free_data,
371 .make_local = brush_make_local,
372 .foreach_id = brush_foreach_id,
373 .foreach_cache = NULL,
374
375 .blend_write = brush_blend_write,
376 .blend_read_data = brush_blend_read_data,
377 .blend_read_lib = brush_blend_read_lib,
378 .blend_read_expand = brush_blend_read_expand,
379 };
380
381 static RNG *brush_rng;
382
BKE_brush_system_init(void)383 void BKE_brush_system_init(void)
384 {
385 brush_rng = BLI_rng_new(0);
386 BLI_rng_srandom(brush_rng, 31415682);
387 }
388
BKE_brush_system_exit(void)389 void BKE_brush_system_exit(void)
390 {
391 if (brush_rng == NULL) {
392 return;
393 }
394 BLI_rng_free(brush_rng);
395 brush_rng = NULL;
396 }
397
brush_defaults(Brush * brush)398 static void brush_defaults(Brush *brush)
399 {
400
401 const Brush *brush_def = DNA_struct_default_get(Brush);
402
403 #define FROM_DEFAULT(member) memcpy(&brush->member, &brush_def->member, sizeof(brush->member))
404 #define FROM_DEFAULT_PTR(member) memcpy(brush->member, brush_def->member, sizeof(brush->member))
405
406 FROM_DEFAULT(blend);
407 FROM_DEFAULT(flag);
408 FROM_DEFAULT(weight);
409 FROM_DEFAULT(size);
410 FROM_DEFAULT(alpha);
411 FROM_DEFAULT(hardness);
412 FROM_DEFAULT(autosmooth_factor);
413 FROM_DEFAULT(topology_rake_factor);
414 FROM_DEFAULT(crease_pinch_factor);
415 FROM_DEFAULT(normal_radius_factor);
416 FROM_DEFAULT(area_radius_factor);
417 FROM_DEFAULT(disconnected_distance_max);
418 FROM_DEFAULT(sculpt_plane);
419 FROM_DEFAULT(plane_offset);
420 FROM_DEFAULT(clone.alpha);
421 FROM_DEFAULT(normal_weight);
422 FROM_DEFAULT(fill_threshold);
423 FROM_DEFAULT(flag);
424 FROM_DEFAULT(sampling_flag);
425 FROM_DEFAULT_PTR(rgb);
426 FROM_DEFAULT_PTR(secondary_rgb);
427 FROM_DEFAULT(spacing);
428 FROM_DEFAULT(smooth_stroke_radius);
429 FROM_DEFAULT(smooth_stroke_factor);
430 FROM_DEFAULT(rate);
431 FROM_DEFAULT(jitter);
432 FROM_DEFAULT(texture_sample_bias);
433 FROM_DEFAULT(texture_overlay_alpha);
434 FROM_DEFAULT(mask_overlay_alpha);
435 FROM_DEFAULT(cursor_overlay_alpha);
436 FROM_DEFAULT(overlay_flags);
437 FROM_DEFAULT_PTR(add_col);
438 FROM_DEFAULT_PTR(sub_col);
439 FROM_DEFAULT(stencil_pos);
440 FROM_DEFAULT(stencil_dimension);
441 FROM_DEFAULT(mtex);
442 FROM_DEFAULT(mask_mtex);
443
444 #undef FROM_DEFAULT
445 #undef FROM_DEFAULT_PTR
446 }
447
448 /* Datablock add/copy/free/make_local */
449
450 /**
451 * \note Resulting brush will have two users: one as a fake user,
452 * another is assumed to be used by the caller.
453 */
BKE_brush_add(Main * bmain,const char * name,const eObjectMode ob_mode)454 Brush *BKE_brush_add(Main *bmain, const char *name, const eObjectMode ob_mode)
455 {
456 Brush *brush;
457
458 brush = BKE_id_new(bmain, ID_BR, name);
459
460 brush->ob_mode = ob_mode;
461
462 return brush;
463 }
464
465 /* add grease pencil settings */
BKE_brush_init_gpencil_settings(Brush * brush)466 void BKE_brush_init_gpencil_settings(Brush *brush)
467 {
468 if (brush->gpencil_settings == NULL) {
469 brush->gpencil_settings = MEM_callocN(sizeof(BrushGpencilSettings), "BrushGpencilSettings");
470 }
471
472 brush->gpencil_settings->draw_smoothlvl = 1;
473 brush->gpencil_settings->flag = 0;
474 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
475 brush->gpencil_settings->draw_strength = 1.0f;
476 brush->gpencil_settings->draw_jitter = 0.0f;
477 brush->gpencil_settings->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
478 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_PEN;
479
480 /* curves */
481 brush->gpencil_settings->curve_sensitivity = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
482 brush->gpencil_settings->curve_strength = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
483 brush->gpencil_settings->curve_jitter = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
484
485 brush->gpencil_settings->curve_rand_pressure = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
486 brush->gpencil_settings->curve_rand_strength = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
487 brush->gpencil_settings->curve_rand_uv = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
488 brush->gpencil_settings->curve_rand_hue = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
489 brush->gpencil_settings->curve_rand_saturation = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
490 brush->gpencil_settings->curve_rand_value = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
491 }
492
493 /* add a new gp-brush */
BKE_brush_add_gpencil(Main * bmain,ToolSettings * ts,const char * name,eObjectMode mode)494 Brush *BKE_brush_add_gpencil(Main *bmain, ToolSettings *ts, const char *name, eObjectMode mode)
495 {
496 Paint *paint = NULL;
497 Brush *brush;
498 switch (mode) {
499 case OB_MODE_PAINT_GPENCIL: {
500 paint = &ts->gp_paint->paint;
501 break;
502 }
503 case OB_MODE_SCULPT_GPENCIL: {
504 paint = &ts->gp_sculptpaint->paint;
505 break;
506 }
507 case OB_MODE_WEIGHT_GPENCIL: {
508 paint = &ts->gp_weightpaint->paint;
509 break;
510 }
511 case OB_MODE_VERTEX_GPENCIL: {
512 paint = &ts->gp_vertexpaint->paint;
513 break;
514 }
515 default:
516 paint = &ts->gp_paint->paint;
517 }
518
519 brush = BKE_brush_add(bmain, name, mode);
520
521 BKE_paint_brush_set(paint, brush);
522 id_us_min(&brush->id);
523
524 brush->size = 3;
525
526 /* grease pencil basic settings */
527 BKE_brush_init_gpencil_settings(brush);
528
529 /* return brush */
530 return brush;
531 }
532
533 /* Delete a Brush. */
BKE_brush_delete(Main * bmain,Brush * brush)534 bool BKE_brush_delete(Main *bmain, Brush *brush)
535 {
536 if (brush->id.tag & LIB_TAG_INDIRECT) {
537 return false;
538 }
539 if (BKE_library_ID_is_indirectly_used(bmain, brush) && ID_REAL_USERS(brush) <= 1 &&
540 ID_EXTRA_USERS(brush) == 0) {
541 return false;
542 }
543
544 BKE_id_delete(bmain, brush);
545
546 return true;
547 }
548
549 /* grease pencil cumapping->preset */
550 typedef enum eGPCurveMappingPreset {
551 GPCURVE_PRESET_PENCIL = 0,
552 GPCURVE_PRESET_INK = 1,
553 GPCURVE_PRESET_INKNOISE = 2,
554 GPCURVE_PRESET_MARKER = 3,
555 GPCURVE_PRESET_CHISEL_SENSIVITY = 4,
556 GPCURVE_PRESET_CHISEL_STRENGTH = 5,
557 } eGPCurveMappingPreset;
558
brush_gpencil_curvemap_reset(CurveMap * cuma,int tot,int preset)559 static void brush_gpencil_curvemap_reset(CurveMap *cuma, int tot, int preset)
560 {
561 if (cuma->curve) {
562 MEM_freeN(cuma->curve);
563 }
564
565 cuma->totpoint = tot;
566 cuma->curve = MEM_callocN(cuma->totpoint * sizeof(CurveMapPoint), __func__);
567
568 switch (preset) {
569 case GPCURVE_PRESET_PENCIL:
570 cuma->curve[0].x = 0.0f;
571 cuma->curve[0].y = 0.0f;
572 cuma->curve[1].x = 0.75115f;
573 cuma->curve[1].y = 0.25f;
574 cuma->curve[2].x = 1.0f;
575 cuma->curve[2].y = 1.0f;
576 break;
577 case GPCURVE_PRESET_INK:
578 cuma->curve[0].x = 0.0f;
579 cuma->curve[0].y = 0.0f;
580 cuma->curve[1].x = 0.63448f;
581 cuma->curve[1].y = 0.375f;
582 cuma->curve[2].x = 1.0f;
583 cuma->curve[2].y = 1.0f;
584 break;
585 case GPCURVE_PRESET_INKNOISE:
586 cuma->curve[0].x = 0.0f;
587 cuma->curve[0].y = 0.0f;
588 cuma->curve[1].x = 0.55f;
589 cuma->curve[1].y = 0.45f;
590 cuma->curve[2].x = 0.85f;
591 cuma->curve[2].y = 1.0f;
592 break;
593 case GPCURVE_PRESET_MARKER:
594 cuma->curve[0].x = 0.0f;
595 cuma->curve[0].y = 0.0f;
596 cuma->curve[1].x = 0.38f;
597 cuma->curve[1].y = 0.22f;
598 cuma->curve[2].x = 0.65f;
599 cuma->curve[2].y = 0.68f;
600 cuma->curve[3].x = 1.0f;
601 cuma->curve[3].y = 1.0f;
602 break;
603 case GPCURVE_PRESET_CHISEL_SENSIVITY:
604 cuma->curve[0].x = 0.0f;
605 cuma->curve[0].y = 0.0f;
606 cuma->curve[1].x = 0.25f;
607 cuma->curve[1].y = 0.40f;
608 cuma->curve[2].x = 1.0f;
609 cuma->curve[2].y = 1.0f;
610 break;
611 case GPCURVE_PRESET_CHISEL_STRENGTH:
612 cuma->curve[0].x = 0.0f;
613 cuma->curve[0].y = 0.0f;
614 cuma->curve[1].x = 0.31f;
615 cuma->curve[1].y = 0.22f;
616 cuma->curve[2].x = 0.61f;
617 cuma->curve[2].y = 0.88f;
618 cuma->curve[3].x = 1.0f;
619 cuma->curve[3].y = 1.0f;
620 break;
621 default:
622 break;
623 }
624
625 if (cuma->table) {
626 MEM_freeN(cuma->table);
627 cuma->table = NULL;
628 }
629 }
630
BKE_gpencil_brush_preset_set(Main * bmain,Brush * brush,const short type)631 void BKE_gpencil_brush_preset_set(Main *bmain, Brush *brush, const short type)
632 {
633 #define SMOOTH_STROKE_RADIUS 40
634 #define SMOOTH_STROKE_FACTOR 0.9f
635 #define ACTIVE_SMOOTH 0.35f
636
637 CurveMapping *custom_curve = NULL;
638
639 /* Optionally assign a material preset. */
640 enum {
641 PRESET_MATERIAL_NONE = 0,
642 PRESET_MATERIAL_DOT_STROKE,
643 } material_preset = PRESET_MATERIAL_NONE;
644
645 /* Set general defaults at brush level. */
646 brush->smooth_stroke_radius = SMOOTH_STROKE_RADIUS;
647 brush->smooth_stroke_factor = SMOOTH_STROKE_FACTOR;
648
649 brush->rgb[0] = 0.498f;
650 brush->rgb[1] = 1.0f;
651 brush->rgb[2] = 0.498f;
652
653 brush->secondary_rgb[0] = 1.0f;
654 brush->secondary_rgb[1] = 1.0f;
655 brush->secondary_rgb[2] = 1.0f;
656
657 brush->curve_preset = BRUSH_CURVE_SMOOTH;
658
659 if (brush->gpencil_settings == NULL) {
660 return;
661 }
662
663 /* Set preset type. */
664 brush->gpencil_settings->preset_type = type;
665
666 /* Set vertex mix factor. */
667 brush->gpencil_settings->vertex_mode = GPPAINT_MODE_BOTH;
668 brush->gpencil_settings->vertex_factor = 1.0f;
669
670 switch (type) {
671 case GP_BRUSH_PRESET_AIRBRUSH: {
672 brush->size = 300.0f;
673 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
674
675 brush->gpencil_settings->draw_strength = 0.4f;
676 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
677
678 brush->gpencil_settings->input_samples = 10;
679 brush->gpencil_settings->active_smooth = ACTIVE_SMOOTH;
680 brush->gpencil_settings->draw_angle = 0.0f;
681 brush->gpencil_settings->draw_angle_factor = 0.0f;
682 brush->gpencil_settings->hardeness = 0.9f;
683 copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
684
685 brush->gpencil_tool = GPAINT_TOOL_DRAW;
686 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_AIRBRUSH;
687
688 zero_v3(brush->secondary_rgb);
689
690 material_preset = PRESET_MATERIAL_DOT_STROKE;
691
692 break;
693 }
694 case GP_BRUSH_PRESET_INK_PEN: {
695
696 brush->size = 60.0f;
697 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
698
699 brush->gpencil_settings->draw_strength = 1.0f;
700
701 brush->gpencil_settings->input_samples = 10;
702 brush->gpencil_settings->active_smooth = ACTIVE_SMOOTH;
703 brush->gpencil_settings->draw_angle = 0.0f;
704 brush->gpencil_settings->draw_angle_factor = 0.0f;
705 brush->gpencil_settings->hardeness = 1.0f;
706 copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
707
708 brush->gpencil_settings->flag |= GP_BRUSH_GROUP_SETTINGS;
709 brush->gpencil_settings->draw_smoothfac = 0.1f;
710 brush->gpencil_settings->draw_smoothlvl = 1;
711 brush->gpencil_settings->draw_subdivide = 0;
712 brush->gpencil_settings->simplify_f = 0.002f;
713
714 brush->gpencil_settings->draw_random_press = 0.0f;
715 brush->gpencil_settings->draw_jitter = 0.0f;
716 brush->gpencil_settings->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
717
718 /* Curve. */
719 custom_curve = brush->gpencil_settings->curve_sensitivity;
720 BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
721 BKE_curvemapping_init(custom_curve);
722 brush_gpencil_curvemap_reset(custom_curve->cm, 3, GPCURVE_PRESET_INK);
723
724 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_INK;
725 brush->gpencil_tool = GPAINT_TOOL_DRAW;
726
727 zero_v3(brush->secondary_rgb);
728 break;
729 }
730 case GP_BRUSH_PRESET_INK_PEN_ROUGH: {
731 brush->size = 60.0f;
732 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
733
734 brush->gpencil_settings->draw_strength = 1.0f;
735
736 brush->gpencil_settings->input_samples = 10;
737 brush->gpencil_settings->active_smooth = ACTIVE_SMOOTH;
738 brush->gpencil_settings->draw_angle = 0.0f;
739 brush->gpencil_settings->draw_angle_factor = 0.0f;
740 brush->gpencil_settings->hardeness = 1.0f;
741 copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
742
743 brush->gpencil_settings->flag &= ~GP_BRUSH_GROUP_SETTINGS;
744 brush->gpencil_settings->draw_smoothfac = 0.0f;
745 brush->gpencil_settings->draw_smoothlvl = 2;
746 brush->gpencil_settings->draw_subdivide = 0;
747 brush->gpencil_settings->simplify_f = 0.000f;
748
749 brush->gpencil_settings->flag |= GP_BRUSH_GROUP_RANDOM;
750 brush->gpencil_settings->draw_random_press = 0.6f;
751 brush->gpencil_settings->draw_random_strength = 0.0f;
752 brush->gpencil_settings->draw_jitter = 0.0f;
753 brush->gpencil_settings->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
754
755 /* Curve. */
756 custom_curve = brush->gpencil_settings->curve_sensitivity;
757 BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
758 BKE_curvemapping_init(custom_curve);
759 brush_gpencil_curvemap_reset(custom_curve->cm, 3, GPCURVE_PRESET_INKNOISE);
760
761 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_INKNOISE;
762 brush->gpencil_tool = GPAINT_TOOL_DRAW;
763
764 zero_v3(brush->secondary_rgb);
765 break;
766 }
767 case GP_BRUSH_PRESET_MARKER_BOLD: {
768 brush->size = 150.0f;
769 brush->gpencil_settings->flag &= ~GP_BRUSH_USE_PRESSURE;
770
771 brush->gpencil_settings->draw_strength = 0.3f;
772
773 brush->gpencil_settings->input_samples = 10;
774 brush->gpencil_settings->active_smooth = ACTIVE_SMOOTH;
775 brush->gpencil_settings->draw_angle = 0.0f;
776 brush->gpencil_settings->draw_angle_factor = 0.0f;
777 brush->gpencil_settings->hardeness = 1.0f;
778 copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
779
780 brush->gpencil_settings->flag |= GP_BRUSH_GROUP_SETTINGS;
781 brush->gpencil_settings->draw_smoothfac = 0.1f;
782 brush->gpencil_settings->draw_smoothlvl = 1;
783 brush->gpencil_settings->draw_subdivide = 0;
784 brush->gpencil_settings->simplify_f = 0.002f;
785
786 brush->gpencil_settings->flag &= ~GP_BRUSH_GROUP_RANDOM;
787 brush->gpencil_settings->draw_random_press = 0.0f;
788 brush->gpencil_settings->draw_random_strength = 0.0f;
789 brush->gpencil_settings->draw_jitter = 0.0f;
790 brush->gpencil_settings->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
791
792 /* Curve. */
793 custom_curve = brush->gpencil_settings->curve_sensitivity;
794 BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
795 BKE_curvemapping_init(custom_curve);
796 brush_gpencil_curvemap_reset(custom_curve->cm, 4, GPCURVE_PRESET_MARKER);
797
798 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_MARKER;
799 brush->gpencil_tool = GPAINT_TOOL_DRAW;
800
801 zero_v3(brush->secondary_rgb);
802 break;
803 }
804 case GP_BRUSH_PRESET_MARKER_CHISEL: {
805 brush->size = 150.0f;
806 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
807
808 brush->gpencil_settings->draw_strength = 1.0f;
809
810 brush->gpencil_settings->input_samples = 10;
811 brush->gpencil_settings->active_smooth = 0.3f;
812 brush->gpencil_settings->draw_angle = DEG2RAD(35.0f);
813 brush->gpencil_settings->draw_angle_factor = 0.5f;
814 brush->gpencil_settings->hardeness = 1.0f;
815 copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
816
817 brush->gpencil_settings->flag |= GP_BRUSH_GROUP_SETTINGS;
818 brush->gpencil_settings->draw_smoothfac = 0.0f;
819 brush->gpencil_settings->draw_smoothlvl = 1;
820 brush->gpencil_settings->draw_subdivide = 0;
821 brush->gpencil_settings->simplify_f = 0.002f;
822
823 brush->gpencil_settings->flag &= ~GP_BRUSH_GROUP_RANDOM;
824 brush->gpencil_settings->draw_random_press = 0.0f;
825 brush->gpencil_settings->draw_jitter = 0.0f;
826 brush->gpencil_settings->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
827
828 /* Curve. */
829 custom_curve = brush->gpencil_settings->curve_sensitivity;
830 BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
831 BKE_curvemapping_init(custom_curve);
832 brush_gpencil_curvemap_reset(custom_curve->cm, 3, GPCURVE_PRESET_CHISEL_SENSIVITY);
833
834 custom_curve = brush->gpencil_settings->curve_strength;
835 BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
836 BKE_curvemapping_init(custom_curve);
837 brush_gpencil_curvemap_reset(custom_curve->cm, 4, GPCURVE_PRESET_CHISEL_STRENGTH);
838
839 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_CHISEL;
840 brush->gpencil_tool = GPAINT_TOOL_DRAW;
841
842 zero_v3(brush->secondary_rgb);
843 break;
844 }
845 case GP_BRUSH_PRESET_PEN: {
846 brush->size = 25.0f;
847 brush->gpencil_settings->flag &= ~GP_BRUSH_USE_PRESSURE;
848
849 brush->gpencil_settings->draw_strength = 1.0f;
850 brush->gpencil_settings->flag &= ~GP_BRUSH_USE_STRENGTH_PRESSURE;
851
852 brush->gpencil_settings->input_samples = 10;
853 brush->gpencil_settings->active_smooth = ACTIVE_SMOOTH;
854 brush->gpencil_settings->draw_angle = 0.0f;
855 brush->gpencil_settings->draw_angle_factor = 0.0f;
856 brush->gpencil_settings->hardeness = 1.0f;
857 copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
858
859 brush->gpencil_settings->flag |= GP_BRUSH_GROUP_SETTINGS;
860 brush->gpencil_settings->draw_smoothfac = 0.0f;
861 brush->gpencil_settings->draw_smoothlvl = 1;
862 brush->gpencil_settings->draw_subdivide = 1;
863 brush->gpencil_settings->simplify_f = 0.002f;
864
865 brush->gpencil_settings->draw_random_press = 0.0f;
866 brush->gpencil_settings->draw_random_strength = 0.0f;
867 brush->gpencil_settings->draw_jitter = 0.0f;
868 brush->gpencil_settings->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
869
870 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_PEN;
871 brush->gpencil_tool = GPAINT_TOOL_DRAW;
872
873 zero_v3(brush->secondary_rgb);
874 break;
875 }
876 case GP_BRUSH_PRESET_PENCIL_SOFT: {
877 brush->size = 80.0f;
878 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
879
880 brush->gpencil_settings->draw_strength = 0.4f;
881 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
882
883 brush->gpencil_settings->input_samples = 10;
884 brush->gpencil_settings->active_smooth = ACTIVE_SMOOTH;
885 brush->gpencil_settings->draw_angle = 0.0f;
886 brush->gpencil_settings->draw_angle_factor = 0.0f;
887 brush->gpencil_settings->hardeness = 0.8f;
888 copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
889
890 brush->gpencil_settings->flag |= GP_BRUSH_GROUP_SETTINGS;
891 brush->gpencil_settings->draw_smoothfac = 0.0f;
892 brush->gpencil_settings->draw_smoothlvl = 1;
893 brush->gpencil_settings->draw_subdivide = 0;
894 brush->gpencil_settings->simplify_f = 0.000f;
895
896 brush->gpencil_settings->draw_random_press = 0.0f;
897 brush->gpencil_settings->draw_random_strength = 0.0f;
898 brush->gpencil_settings->draw_jitter = 0.0f;
899 brush->gpencil_settings->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
900
901 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_PENCIL;
902 brush->gpencil_tool = GPAINT_TOOL_DRAW;
903
904 zero_v3(brush->secondary_rgb);
905
906 material_preset = PRESET_MATERIAL_DOT_STROKE;
907
908 break;
909 }
910 case GP_BRUSH_PRESET_PENCIL: {
911 brush->size = 20.0f;
912 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
913
914 brush->gpencil_settings->draw_strength = 0.6f;
915 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
916
917 brush->gpencil_settings->input_samples = 10;
918 brush->gpencil_settings->active_smooth = ACTIVE_SMOOTH;
919 brush->gpencil_settings->draw_angle = 0.0f;
920 brush->gpencil_settings->draw_angle_factor = 0.0f;
921 brush->gpencil_settings->hardeness = 1.0f;
922 copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
923
924 brush->gpencil_settings->flag |= GP_BRUSH_GROUP_SETTINGS;
925 brush->gpencil_settings->draw_smoothfac = 0.0f;
926 brush->gpencil_settings->draw_smoothlvl = 1;
927 brush->gpencil_settings->draw_subdivide = 0;
928 brush->gpencil_settings->simplify_f = 0.002f;
929
930 brush->gpencil_settings->draw_random_press = 0.0f;
931 brush->gpencil_settings->draw_jitter = 0.0f;
932 brush->gpencil_settings->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
933
934 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_PENCIL;
935 brush->gpencil_tool = GPAINT_TOOL_DRAW;
936
937 zero_v3(brush->secondary_rgb);
938 break;
939 }
940 case GP_BRUSH_PRESET_FILL_AREA: {
941 brush->size = 20.0f;
942
943 brush->gpencil_settings->fill_leak = 3;
944 brush->gpencil_settings->fill_threshold = 0.1f;
945 brush->gpencil_settings->fill_simplylvl = 1;
946 brush->gpencil_settings->fill_factor = 1;
947
948 brush->gpencil_settings->draw_strength = 1.0f;
949 brush->gpencil_settings->hardeness = 1.0f;
950 copy_v2_fl(brush->gpencil_settings->aspect_ratio, 1.0f);
951 brush->gpencil_settings->draw_smoothfac = 0.1f;
952 brush->gpencil_settings->draw_smoothlvl = 1;
953 brush->gpencil_settings->draw_subdivide = 1;
954
955 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_FILL;
956 brush->gpencil_tool = GPAINT_TOOL_FILL;
957 brush->gpencil_settings->vertex_mode = GPPAINT_MODE_FILL;
958
959 zero_v3(brush->secondary_rgb);
960 break;
961 }
962 case GP_BRUSH_PRESET_ERASER_SOFT: {
963 brush->size = 30.0f;
964 brush->gpencil_settings->draw_strength = 0.5f;
965 brush->gpencil_settings->flag |= GP_BRUSH_DEFAULT_ERASER;
966 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
967 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
968 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_ERASE_SOFT;
969 brush->gpencil_tool = GPAINT_TOOL_ERASE;
970 brush->gpencil_settings->eraser_mode = GP_BRUSH_ERASER_SOFT;
971 brush->gpencil_settings->era_strength_f = 100.0f;
972 brush->gpencil_settings->era_thickness_f = 10.0f;
973
974 break;
975 }
976 case GP_BRUSH_PRESET_ERASER_HARD: {
977 brush->size = 30.0f;
978 brush->gpencil_settings->draw_strength = 1.0f;
979 brush->gpencil_settings->eraser_mode = GP_BRUSH_ERASER_SOFT;
980 brush->gpencil_settings->era_strength_f = 100.0f;
981 brush->gpencil_settings->era_thickness_f = 50.0f;
982
983 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_ERASE_HARD;
984 brush->gpencil_tool = GPAINT_TOOL_ERASE;
985
986 break;
987 }
988 case GP_BRUSH_PRESET_ERASER_POINT: {
989 brush->size = 30.0f;
990 brush->gpencil_settings->eraser_mode = GP_BRUSH_ERASER_HARD;
991
992 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_ERASE_HARD;
993 brush->gpencil_tool = GPAINT_TOOL_ERASE;
994
995 break;
996 }
997 case GP_BRUSH_PRESET_ERASER_STROKE: {
998 brush->size = 30.0f;
999 brush->gpencil_settings->eraser_mode = GP_BRUSH_ERASER_STROKE;
1000
1001 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_ERASE_STROKE;
1002 brush->gpencil_tool = GPAINT_TOOL_ERASE;
1003
1004 break;
1005 }
1006 case GP_BRUSH_PRESET_TINT: {
1007 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_TINT;
1008 brush->gpencil_tool = GPAINT_TOOL_TINT;
1009
1010 brush->size = 25.0f;
1011 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
1012
1013 brush->gpencil_settings->draw_strength = 0.8f;
1014 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
1015
1016 zero_v3(brush->secondary_rgb);
1017 break;
1018 }
1019 case GP_BRUSH_PRESET_VERTEX_DRAW: {
1020 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_VERTEX_DRAW;
1021 brush->gpencil_vertex_tool = GPVERTEX_TOOL_DRAW;
1022
1023 brush->size = 25.0f;
1024 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
1025
1026 brush->gpencil_settings->draw_strength = 0.8f;
1027 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
1028
1029 zero_v3(brush->secondary_rgb);
1030 break;
1031 }
1032 case GP_BRUSH_PRESET_VERTEX_BLUR: {
1033 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_VERTEX_BLUR;
1034 brush->gpencil_vertex_tool = GPVERTEX_TOOL_BLUR;
1035
1036 brush->size = 25.0f;
1037 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
1038
1039 brush->gpencil_settings->draw_strength = 0.8f;
1040 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
1041
1042 zero_v3(brush->secondary_rgb);
1043 break;
1044 }
1045 case GP_BRUSH_PRESET_VERTEX_AVERAGE: {
1046 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_VERTEX_AVERAGE;
1047 brush->gpencil_vertex_tool = GPVERTEX_TOOL_AVERAGE;
1048
1049 brush->size = 25.0f;
1050 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
1051
1052 brush->gpencil_settings->draw_strength = 0.8f;
1053 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
1054
1055 zero_v3(brush->secondary_rgb);
1056 break;
1057 }
1058 case GP_BRUSH_PRESET_VERTEX_SMEAR: {
1059 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_VERTEX_SMEAR;
1060 brush->gpencil_vertex_tool = GPVERTEX_TOOL_SMEAR;
1061
1062 brush->size = 25.0f;
1063 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
1064
1065 brush->gpencil_settings->draw_strength = 0.8f;
1066 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
1067
1068 zero_v3(brush->secondary_rgb);
1069 break;
1070 }
1071 case GP_BRUSH_PRESET_VERTEX_REPLACE: {
1072 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_VERTEX_REPLACE;
1073 brush->gpencil_vertex_tool = GPVERTEX_TOOL_REPLACE;
1074
1075 brush->size = 25.0f;
1076 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
1077
1078 brush->gpencil_settings->draw_strength = 0.8f;
1079 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
1080
1081 zero_v3(brush->secondary_rgb);
1082 break;
1083 }
1084 case GP_BRUSH_PRESET_SMOOTH_STROKE: {
1085 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_SMOOTH;
1086 brush->gpencil_sculpt_tool = GPSCULPT_TOOL_SMOOTH;
1087
1088 brush->size = 25.0f;
1089 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
1090
1091 brush->gpencil_settings->draw_strength = 0.3f;
1092 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
1093 brush->gpencil_settings->sculpt_flag = GP_SCULPT_FLAG_SMOOTH_PRESSURE;
1094 brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
1095
1096 break;
1097 }
1098 case GP_BRUSH_PRESET_STRENGTH_STROKE: {
1099 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_STRENGTH;
1100 brush->gpencil_sculpt_tool = GPSCULPT_TOOL_STRENGTH;
1101
1102 brush->size = 25.0f;
1103 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
1104
1105 brush->gpencil_settings->draw_strength = 0.3f;
1106 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
1107 brush->gpencil_settings->sculpt_flag = GP_SCULPT_FLAG_SMOOTH_PRESSURE;
1108 brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
1109
1110 break;
1111 }
1112 case GP_BRUSH_PRESET_THICKNESS_STROKE: {
1113 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_THICKNESS;
1114 brush->gpencil_sculpt_tool = GPSCULPT_TOOL_THICKNESS;
1115
1116 brush->size = 25.0f;
1117 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
1118
1119 brush->gpencil_settings->draw_strength = 0.5f;
1120 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
1121 brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
1122
1123 break;
1124 }
1125 case GP_BRUSH_PRESET_GRAB_STROKE: {
1126 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_GRAB;
1127 brush->gpencil_sculpt_tool = GPSCULPT_TOOL_GRAB;
1128 brush->gpencil_settings->flag &= ~GP_BRUSH_USE_PRESSURE;
1129
1130 brush->size = 25.0f;
1131
1132 brush->gpencil_settings->draw_strength = 0.3f;
1133 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
1134 brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
1135
1136 break;
1137 }
1138 case GP_BRUSH_PRESET_PUSH_STROKE: {
1139 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_PUSH;
1140 brush->gpencil_sculpt_tool = GPSCULPT_TOOL_PUSH;
1141
1142 brush->size = 25.0f;
1143 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
1144
1145 brush->gpencil_settings->draw_strength = 0.3f;
1146 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
1147 brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
1148
1149 break;
1150 }
1151 case GP_BRUSH_PRESET_TWIST_STROKE: {
1152 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_TWIST;
1153 brush->gpencil_sculpt_tool = GPSCULPT_TOOL_TWIST;
1154
1155 brush->size = 50.0f;
1156 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
1157
1158 brush->gpencil_settings->draw_strength = 0.3f;
1159 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
1160 brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
1161
1162 break;
1163 }
1164 case GP_BRUSH_PRESET_PINCH_STROKE: {
1165 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_PINCH;
1166 brush->gpencil_sculpt_tool = GPSCULPT_TOOL_PINCH;
1167
1168 brush->size = 50.0f;
1169 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
1170
1171 brush->gpencil_settings->draw_strength = 0.5f;
1172 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
1173 brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
1174
1175 break;
1176 }
1177 case GP_BRUSH_PRESET_RANDOMIZE_STROKE: {
1178 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_RANDOMIZE;
1179 brush->gpencil_sculpt_tool = GPSCULPT_TOOL_RANDOMIZE;
1180
1181 brush->size = 25.0f;
1182 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
1183
1184 brush->gpencil_settings->draw_strength = 0.5f;
1185 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
1186 brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
1187
1188 break;
1189 }
1190 case GP_BRUSH_PRESET_CLONE_STROKE: {
1191 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_CLONE;
1192 brush->gpencil_sculpt_tool = GPSCULPT_TOOL_CLONE;
1193 brush->gpencil_settings->flag &= ~GP_BRUSH_USE_PRESSURE;
1194
1195 brush->size = 25.0f;
1196
1197 brush->gpencil_settings->draw_strength = 1.0f;
1198 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
1199 brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
1200
1201 break;
1202 }
1203 case GP_BRUSH_PRESET_DRAW_WEIGHT: {
1204 brush->gpencil_settings->icon_id = GP_BRUSH_ICON_GPBRUSH_WEIGHT;
1205 brush->gpencil_weight_tool = GPWEIGHT_TOOL_DRAW;
1206
1207 brush->size = 25.0f;
1208 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
1209
1210 brush->gpencil_settings->draw_strength = 0.8f;
1211 brush->gpencil_settings->flag |= GP_BRUSH_USE_STRENGTH_PRESSURE;
1212 brush->gpencil_settings->sculpt_mode_flag |= GP_SCULPT_FLAGMODE_APPLY_POSITION;
1213
1214 break;
1215 }
1216 default:
1217 break;
1218 }
1219
1220 switch (material_preset) {
1221 case PRESET_MATERIAL_NONE:
1222 break;
1223 case PRESET_MATERIAL_DOT_STROKE: {
1224 /* Create and link Black Dots material to brush.
1225 * This material is required because the brush uses the material
1226 * to define how the stroke is drawn. */
1227 const char *ma_id = "Dots Stroke";
1228 Material *ma = BLI_findstring(&bmain->materials, ma_id, offsetof(ID, name) + 2);
1229 if (ma == NULL) {
1230 ma = BKE_gpencil_material_add(bmain, ma_id);
1231 ma->gp_style->mode = GP_MATERIAL_MODE_DOT;
1232 BLI_assert(ma->id.us == 1);
1233 id_us_min(&ma->id);
1234 }
1235
1236 BKE_gpencil_brush_material_set(brush, ma);
1237
1238 /* Pin the material to the brush. */
1239 brush->gpencil_settings->flag |= GP_BRUSH_MATERIAL_PINNED;
1240 break;
1241 }
1242 }
1243 }
1244
gpencil_brush_ensure(Main * bmain,ToolSettings * ts,const char * brush_name,eObjectMode mode,bool * r_new)1245 static Brush *gpencil_brush_ensure(
1246 Main *bmain, ToolSettings *ts, const char *brush_name, eObjectMode mode, bool *r_new)
1247 {
1248 *r_new = false;
1249 Brush *brush = BLI_findstring(&bmain->brushes, brush_name, offsetof(ID, name) + 2);
1250
1251 /* If the brush exist, but the type is not GPencil or the mode is wrong, create a new one. */
1252 if ((brush != NULL) && ((brush->gpencil_settings == NULL) || (brush->ob_mode != mode))) {
1253 brush = NULL;
1254 }
1255
1256 if (brush == NULL) {
1257 brush = BKE_brush_add_gpencil(bmain, ts, brush_name, mode);
1258 *r_new = true;
1259 }
1260
1261 if (brush->gpencil_settings == NULL) {
1262 BKE_brush_init_gpencil_settings(brush);
1263 }
1264
1265 return brush;
1266 }
1267
1268 /* Create a set of grease pencil Drawing presets. */
BKE_brush_gpencil_paint_presets(Main * bmain,ToolSettings * ts,const bool reset)1269 void BKE_brush_gpencil_paint_presets(Main *bmain, ToolSettings *ts, const bool reset)
1270 {
1271 bool r_new = false;
1272
1273 Paint *paint = &ts->gp_paint->paint;
1274 Brush *brush_prev = paint->brush;
1275 Brush *brush, *deft_draw;
1276 /* Airbrush brush. */
1277 brush = gpencil_brush_ensure(bmain, ts, "Airbrush", OB_MODE_PAINT_GPENCIL, &r_new);
1278 if ((reset) || (r_new)) {
1279 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_AIRBRUSH);
1280 }
1281
1282 /* Ink Pen brush. */
1283 brush = gpencil_brush_ensure(bmain, ts, "Ink Pen", OB_MODE_PAINT_GPENCIL, &r_new);
1284 if ((reset) || (r_new)) {
1285 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_INK_PEN);
1286 }
1287
1288 /* Ink Pen Rough brush. */
1289 brush = gpencil_brush_ensure(bmain, ts, "Ink Pen Rough", OB_MODE_PAINT_GPENCIL, &r_new);
1290 if ((reset) || (r_new)) {
1291 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_INK_PEN_ROUGH);
1292 }
1293
1294 /* Marker Bold brush. */
1295 brush = gpencil_brush_ensure(bmain, ts, "Marker Bold", OB_MODE_PAINT_GPENCIL, &r_new);
1296 if ((reset) || (r_new)) {
1297 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_MARKER_BOLD);
1298 }
1299
1300 /* Marker Chisel brush. */
1301 brush = gpencil_brush_ensure(bmain, ts, "Marker Chisel", OB_MODE_PAINT_GPENCIL, &r_new);
1302 if ((reset) || (r_new)) {
1303 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_MARKER_CHISEL);
1304 }
1305
1306 /* Pen brush. */
1307 brush = gpencil_brush_ensure(bmain, ts, "Pen", OB_MODE_PAINT_GPENCIL, &r_new);
1308 if ((reset) || (r_new)) {
1309 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_PEN);
1310 }
1311
1312 /* Pencil Soft brush. */
1313 brush = gpencil_brush_ensure(bmain, ts, "Pencil Soft", OB_MODE_PAINT_GPENCIL, &r_new);
1314 if ((reset) || (r_new)) {
1315 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_PENCIL_SOFT);
1316 }
1317
1318 /* Pencil brush. */
1319 brush = gpencil_brush_ensure(bmain, ts, "Pencil", OB_MODE_PAINT_GPENCIL, &r_new);
1320 if ((reset) || (r_new)) {
1321 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_PENCIL);
1322 }
1323 deft_draw = brush; /* save default brush. */
1324
1325 /* Fill brush. */
1326 brush = gpencil_brush_ensure(bmain, ts, "Fill Area", OB_MODE_PAINT_GPENCIL, &r_new);
1327 if ((reset) || (r_new)) {
1328 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_FILL_AREA);
1329 }
1330
1331 /* Soft Eraser brush. */
1332 brush = gpencil_brush_ensure(bmain, ts, "Eraser Soft", OB_MODE_PAINT_GPENCIL, &r_new);
1333 if ((reset) || (r_new)) {
1334 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_ERASER_SOFT);
1335 }
1336
1337 /* Hard Eraser brush. */
1338 brush = gpencil_brush_ensure(bmain, ts, "Eraser Hard", OB_MODE_PAINT_GPENCIL, &r_new);
1339 if ((reset) || (r_new)) {
1340 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_ERASER_HARD);
1341 }
1342
1343 /* Point Eraser brush. */
1344 brush = gpencil_brush_ensure(bmain, ts, "Eraser Point", OB_MODE_PAINT_GPENCIL, &r_new);
1345 if ((reset) || (r_new)) {
1346 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_ERASER_POINT);
1347 }
1348
1349 /* Stroke Eraser brush. */
1350 brush = gpencil_brush_ensure(bmain, ts, "Eraser Stroke", OB_MODE_PAINT_GPENCIL, &r_new);
1351 if ((reset) || (r_new)) {
1352 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_ERASER_STROKE);
1353 }
1354
1355 /* Tint brush. */
1356 brush = gpencil_brush_ensure(bmain, ts, "Tint", OB_MODE_PAINT_GPENCIL, &r_new);
1357 if ((reset) || (r_new)) {
1358 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_TINT);
1359 }
1360
1361 /* Set default Draw brush. */
1362 if (reset || brush_prev == NULL) {
1363 BKE_paint_brush_set(paint, deft_draw);
1364 }
1365 else {
1366 if (brush_prev != NULL) {
1367 BKE_paint_brush_set(paint, brush_prev);
1368 }
1369 }
1370 }
1371
1372 /* Create a set of grease pencil Vertex Paint presets. */
BKE_brush_gpencil_vertex_presets(Main * bmain,ToolSettings * ts,const bool reset)1373 void BKE_brush_gpencil_vertex_presets(Main *bmain, ToolSettings *ts, const bool reset)
1374 {
1375 bool r_new = false;
1376
1377 Paint *vertexpaint = &ts->gp_vertexpaint->paint;
1378 Brush *brush_prev = vertexpaint->brush;
1379 Brush *brush, *deft_vertex;
1380 /* Vertex Draw brush. */
1381 brush = gpencil_brush_ensure(bmain, ts, "Vertex Draw", OB_MODE_VERTEX_GPENCIL, &r_new);
1382 if ((reset) || (r_new)) {
1383 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_VERTEX_DRAW);
1384 }
1385 deft_vertex = brush; /* save default brush. */
1386
1387 /* Vertex Blur brush. */
1388 brush = gpencil_brush_ensure(bmain, ts, "Vertex Blur", OB_MODE_VERTEX_GPENCIL, &r_new);
1389 if ((reset) || (r_new)) {
1390 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_VERTEX_BLUR);
1391 }
1392 /* Vertex Average brush. */
1393 brush = gpencil_brush_ensure(bmain, ts, "Vertex Average", OB_MODE_VERTEX_GPENCIL, &r_new);
1394 if ((reset) || (r_new)) {
1395 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_VERTEX_AVERAGE);
1396 }
1397 /* Vertex Smear brush. */
1398 brush = gpencil_brush_ensure(bmain, ts, "Vertex Smear", OB_MODE_VERTEX_GPENCIL, &r_new);
1399 if ((reset) || (r_new)) {
1400 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_VERTEX_SMEAR);
1401 }
1402 /* Vertex Replace brush. */
1403 brush = gpencil_brush_ensure(bmain, ts, "Vertex Replace", OB_MODE_VERTEX_GPENCIL, &r_new);
1404 if ((reset) || (r_new)) {
1405 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_VERTEX_REPLACE);
1406 }
1407
1408 /* Set default Vertex brush. */
1409 if (reset || brush_prev == NULL) {
1410 BKE_paint_brush_set(vertexpaint, deft_vertex);
1411 }
1412 else {
1413 if (brush_prev != NULL) {
1414 BKE_paint_brush_set(vertexpaint, brush_prev);
1415 }
1416 }
1417 }
1418
1419 /* Create a set of grease pencil Sculpt Paint presets. */
BKE_brush_gpencil_sculpt_presets(Main * bmain,ToolSettings * ts,const bool reset)1420 void BKE_brush_gpencil_sculpt_presets(Main *bmain, ToolSettings *ts, const bool reset)
1421 {
1422 bool r_new = false;
1423
1424 Paint *sculptpaint = &ts->gp_sculptpaint->paint;
1425 Brush *brush_prev = sculptpaint->brush;
1426 Brush *brush, *deft_sculpt;
1427
1428 /* Smooth brush. */
1429 brush = gpencil_brush_ensure(bmain, ts, "Smooth Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1430 if ((reset) || (r_new)) {
1431 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_SMOOTH_STROKE);
1432 }
1433 deft_sculpt = brush;
1434
1435 /* Strength brush. */
1436 brush = gpencil_brush_ensure(bmain, ts, "Strength Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1437 if ((reset) || (r_new)) {
1438 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_STRENGTH_STROKE);
1439 }
1440
1441 /* Thickness brush. */
1442 brush = gpencil_brush_ensure(bmain, ts, "Thickness Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1443 if ((reset) || (r_new)) {
1444 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_THICKNESS_STROKE);
1445 }
1446
1447 /* Grab brush. */
1448 brush = gpencil_brush_ensure(bmain, ts, "Grab Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1449 if ((reset) || (r_new)) {
1450 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_GRAB_STROKE);
1451 }
1452
1453 /* Push brush. */
1454 brush = gpencil_brush_ensure(bmain, ts, "Push Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1455 if ((reset) || (r_new)) {
1456 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_PUSH_STROKE);
1457 }
1458
1459 /* Twist brush. */
1460 brush = gpencil_brush_ensure(bmain, ts, "Twist Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1461 if ((reset) || (r_new)) {
1462 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_TWIST_STROKE);
1463 }
1464
1465 /* Pinch brush. */
1466 brush = gpencil_brush_ensure(bmain, ts, "Pinch Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1467 if ((reset) || (r_new)) {
1468 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_PINCH_STROKE);
1469 }
1470
1471 /* Randomize brush. */
1472 brush = gpencil_brush_ensure(bmain, ts, "Randomize Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1473 if ((reset) || (r_new)) {
1474 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_RANDOMIZE_STROKE);
1475 }
1476
1477 /* Clone brush. */
1478 brush = gpencil_brush_ensure(bmain, ts, "Clone Stroke", OB_MODE_SCULPT_GPENCIL, &r_new);
1479 if ((reset) || (r_new)) {
1480 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_CLONE_STROKE);
1481 }
1482
1483 /* Set default brush. */
1484 if (reset || brush_prev == NULL) {
1485 BKE_paint_brush_set(sculptpaint, deft_sculpt);
1486 }
1487 else {
1488 if (brush_prev != NULL) {
1489 BKE_paint_brush_set(sculptpaint, brush_prev);
1490 }
1491 }
1492 }
1493
1494 /* Create a set of grease pencil Weight Paint presets. */
BKE_brush_gpencil_weight_presets(Main * bmain,ToolSettings * ts,const bool reset)1495 void BKE_brush_gpencil_weight_presets(Main *bmain, ToolSettings *ts, const bool reset)
1496 {
1497 bool r_new = false;
1498
1499 Paint *weightpaint = &ts->gp_weightpaint->paint;
1500 Brush *brush_prev = weightpaint->brush;
1501 Brush *brush, *deft_weight;
1502 /* Vertex Draw brush. */
1503 brush = gpencil_brush_ensure(bmain, ts, "Draw Weight", OB_MODE_WEIGHT_GPENCIL, &r_new);
1504 if ((reset) || (r_new)) {
1505 BKE_gpencil_brush_preset_set(bmain, brush, GP_BRUSH_PRESET_DRAW_WEIGHT);
1506 }
1507 deft_weight = brush; /* save default brush. */
1508
1509 /* Set default brush. */
1510 if (reset || brush_prev == NULL) {
1511 BKE_paint_brush_set(weightpaint, deft_weight);
1512 }
1513 else {
1514 if (brush_prev != NULL) {
1515 BKE_paint_brush_set(weightpaint, brush_prev);
1516 }
1517 }
1518 }
1519
BKE_brush_first_search(struct Main * bmain,const eObjectMode ob_mode)1520 struct Brush *BKE_brush_first_search(struct Main *bmain, const eObjectMode ob_mode)
1521 {
1522 Brush *brush;
1523
1524 for (brush = bmain->brushes.first; brush; brush = brush->id.next) {
1525 if (brush->ob_mode & ob_mode) {
1526 return brush;
1527 }
1528 }
1529 return NULL;
1530 }
1531
BKE_brush_debug_print_state(Brush * br)1532 void BKE_brush_debug_print_state(Brush *br)
1533 {
1534 /* create a fake brush and set it to the defaults */
1535 Brush def = {{NULL}};
1536 brush_defaults(&def);
1537
1538 #define BR_TEST(field, t) \
1539 if (br->field != def.field) { \
1540 printf("br->" #field " = %" #t ";\n", br->field); \
1541 } \
1542 ((void)0)
1543
1544 #define BR_TEST_FLAG(_f) \
1545 if ((br->flag & _f) && !(def.flag & _f)) { \
1546 printf("br->flag |= " #_f ";\n"); \
1547 } \
1548 else if (!(br->flag & _f) && (def.flag & _f)) { \
1549 printf("br->flag &= ~" #_f ";\n"); \
1550 } \
1551 ((void)0)
1552
1553 #define BR_TEST_FLAG_OVERLAY(_f) \
1554 if ((br->overlay_flags & _f) && !(def.overlay_flags & _f)) { \
1555 printf("br->overlay_flags |= " #_f ";\n"); \
1556 } \
1557 else if (!(br->overlay_flags & _f) && (def.overlay_flags & _f)) { \
1558 printf("br->overlay_flags &= ~" #_f ";\n"); \
1559 } \
1560 ((void)0)
1561
1562 /* print out any non-default brush state */
1563 BR_TEST(normal_weight, f);
1564
1565 BR_TEST(blend, d);
1566 BR_TEST(size, d);
1567
1568 /* br->flag */
1569 BR_TEST_FLAG(BRUSH_AIRBRUSH);
1570 BR_TEST_FLAG(BRUSH_ALPHA_PRESSURE);
1571 BR_TEST_FLAG(BRUSH_SIZE_PRESSURE);
1572 BR_TEST_FLAG(BRUSH_JITTER_PRESSURE);
1573 BR_TEST_FLAG(BRUSH_SPACING_PRESSURE);
1574 BR_TEST_FLAG(BRUSH_ANCHORED);
1575 BR_TEST_FLAG(BRUSH_DIR_IN);
1576 BR_TEST_FLAG(BRUSH_SPACE);
1577 BR_TEST_FLAG(BRUSH_SMOOTH_STROKE);
1578 BR_TEST_FLAG(BRUSH_PERSISTENT);
1579 BR_TEST_FLAG(BRUSH_ACCUMULATE);
1580 BR_TEST_FLAG(BRUSH_LOCK_ALPHA);
1581 BR_TEST_FLAG(BRUSH_ORIGINAL_NORMAL);
1582 BR_TEST_FLAG(BRUSH_OFFSET_PRESSURE);
1583 BR_TEST_FLAG(BRUSH_SPACE_ATTEN);
1584 BR_TEST_FLAG(BRUSH_ADAPTIVE_SPACE);
1585 BR_TEST_FLAG(BRUSH_LOCK_SIZE);
1586 BR_TEST_FLAG(BRUSH_EDGE_TO_EDGE);
1587 BR_TEST_FLAG(BRUSH_DRAG_DOT);
1588 BR_TEST_FLAG(BRUSH_INVERSE_SMOOTH_PRESSURE);
1589 BR_TEST_FLAG(BRUSH_PLANE_TRIM);
1590 BR_TEST_FLAG(BRUSH_FRONTFACE);
1591 BR_TEST_FLAG(BRUSH_CUSTOM_ICON);
1592
1593 BR_TEST_FLAG_OVERLAY(BRUSH_OVERLAY_CURSOR);
1594 BR_TEST_FLAG_OVERLAY(BRUSH_OVERLAY_PRIMARY);
1595 BR_TEST_FLAG_OVERLAY(BRUSH_OVERLAY_SECONDARY);
1596 BR_TEST_FLAG_OVERLAY(BRUSH_OVERLAY_CURSOR_OVERRIDE_ON_STROKE);
1597 BR_TEST_FLAG_OVERLAY(BRUSH_OVERLAY_PRIMARY_OVERRIDE_ON_STROKE);
1598 BR_TEST_FLAG_OVERLAY(BRUSH_OVERLAY_SECONDARY_OVERRIDE_ON_STROKE);
1599
1600 BR_TEST(jitter, f);
1601 BR_TEST(spacing, d);
1602 BR_TEST(smooth_stroke_radius, d);
1603 BR_TEST(smooth_stroke_factor, f);
1604 BR_TEST(rate, f);
1605
1606 BR_TEST(alpha, f);
1607
1608 BR_TEST(sculpt_plane, d);
1609
1610 BR_TEST(plane_offset, f);
1611
1612 BR_TEST(autosmooth_factor, f);
1613
1614 BR_TEST(topology_rake_factor, f);
1615
1616 BR_TEST(crease_pinch_factor, f);
1617
1618 BR_TEST(plane_trim, f);
1619
1620 BR_TEST(texture_sample_bias, f);
1621 BR_TEST(texture_overlay_alpha, d);
1622
1623 BR_TEST(add_col[0], f);
1624 BR_TEST(add_col[1], f);
1625 BR_TEST(add_col[2], f);
1626 BR_TEST(add_col[3], f);
1627 BR_TEST(sub_col[0], f);
1628 BR_TEST(sub_col[1], f);
1629 BR_TEST(sub_col[2], f);
1630 BR_TEST(sub_col[3], f);
1631
1632 printf("\n");
1633
1634 #undef BR_TEST
1635 #undef BR_TEST_FLAG
1636 }
1637
BKE_brush_sculpt_reset(Brush * br)1638 void BKE_brush_sculpt_reset(Brush *br)
1639 {
1640 /* enable this to see any non-default
1641 * settings used by a brush: */
1642 // BKE_brush_debug_print_state(br);
1643
1644 brush_defaults(br);
1645 BKE_brush_curve_preset(br, CURVE_PRESET_SMOOTH);
1646
1647 /* Use the curve presets by default */
1648 br->curve_preset = BRUSH_CURVE_SMOOTH;
1649
1650 /* Note that sculpt defaults where set when 0.5 was the default (now it's 1.0)
1651 * assign this so logic below can remain the same. */
1652 br->alpha = 0.5f;
1653
1654 /* Brush settings */
1655 switch (br->sculpt_tool) {
1656 case SCULPT_TOOL_DRAW_SHARP:
1657 br->flag |= BRUSH_DIR_IN;
1658 br->curve_preset = BRUSH_CURVE_POW4;
1659 br->spacing = 5;
1660 break;
1661 case SCULPT_TOOL_DISPLACEMENT_ERASER:
1662 br->curve_preset = BRUSH_CURVE_SMOOTHER;
1663 br->spacing = 10;
1664 br->alpha = 1.0f;
1665 break;
1666 case SCULPT_TOOL_SLIDE_RELAX:
1667 br->spacing = 10;
1668 br->alpha = 1.0f;
1669 br->slide_deform_type = BRUSH_SLIDE_DEFORM_DRAG;
1670 break;
1671 case SCULPT_TOOL_CLAY:
1672 br->flag |= BRUSH_SIZE_PRESSURE;
1673 br->spacing = 3;
1674 br->autosmooth_factor = 0.25f;
1675 br->normal_radius_factor = 0.75f;
1676 br->hardness = 0.65f;
1677 break;
1678 case SCULPT_TOOL_CLAY_THUMB:
1679 br->alpha = 0.5f;
1680 br->normal_radius_factor = 1.0f;
1681 br->spacing = 6;
1682 br->hardness = 0.5f;
1683 br->flag |= BRUSH_SIZE_PRESSURE;
1684 br->flag &= ~BRUSH_SPACE_ATTEN;
1685 break;
1686 case SCULPT_TOOL_CLAY_STRIPS:
1687 br->flag |= BRUSH_ACCUMULATE | BRUSH_SIZE_PRESSURE;
1688 br->flag &= ~BRUSH_SPACE_ATTEN;
1689 br->alpha = 0.6f;
1690 br->spacing = 5;
1691 br->normal_radius_factor = 1.55f;
1692 br->tip_roundness = 0.18f;
1693 br->curve_preset = BRUSH_CURVE_SMOOTHER;
1694 break;
1695 case SCULPT_TOOL_MULTIPLANE_SCRAPE:
1696 br->flag2 |= BRUSH_MULTIPLANE_SCRAPE_DYNAMIC | BRUSH_MULTIPLANE_SCRAPE_PLANES_PREVIEW;
1697 br->alpha = 0.7f;
1698 br->normal_radius_factor = 0.70f;
1699 br->multiplane_scrape_angle = 60;
1700 br->curve_preset = BRUSH_CURVE_SMOOTH;
1701 br->spacing = 5;
1702 break;
1703 case SCULPT_TOOL_CREASE:
1704 br->flag |= BRUSH_DIR_IN;
1705 br->alpha = 0.25;
1706 break;
1707 case SCULPT_TOOL_SCRAPE:
1708 case SCULPT_TOOL_FILL:
1709 br->alpha = 0.7f;
1710 br->area_radius_factor = 0.5f;
1711 br->spacing = 7;
1712 br->flag |= BRUSH_ACCUMULATE;
1713 br->flag |= BRUSH_INVERT_TO_SCRAPE_FILL;
1714 break;
1715 case SCULPT_TOOL_ROTATE:
1716 br->alpha = 1.0;
1717 break;
1718 case SCULPT_TOOL_SMOOTH:
1719 br->flag &= ~BRUSH_SPACE_ATTEN;
1720 br->spacing = 5;
1721 br->alpha = 0.7f;
1722 br->surface_smooth_shape_preservation = 0.5f;
1723 br->surface_smooth_current_vertex = 0.5f;
1724 br->surface_smooth_iterations = 4;
1725 break;
1726 case SCULPT_TOOL_SNAKE_HOOK:
1727 br->alpha = 1.0f;
1728 br->rake_factor = 1.0f;
1729 break;
1730 case SCULPT_TOOL_THUMB:
1731 br->size = 75;
1732 br->flag &= ~BRUSH_ALPHA_PRESSURE;
1733 br->flag &= ~BRUSH_SPACE;
1734 br->flag &= ~BRUSH_SPACE_ATTEN;
1735 break;
1736 case SCULPT_TOOL_ELASTIC_DEFORM:
1737 br->elastic_deform_volume_preservation = 0.4f;
1738 br->elastic_deform_type = BRUSH_ELASTIC_DEFORM_GRAB_TRISCALE;
1739 br->flag &= ~BRUSH_ALPHA_PRESSURE;
1740 br->flag &= ~BRUSH_SPACE;
1741 br->flag &= ~BRUSH_SPACE_ATTEN;
1742 break;
1743 case SCULPT_TOOL_POSE:
1744 br->pose_smooth_iterations = 4;
1745 br->pose_ik_segments = 1;
1746 br->flag2 |= BRUSH_POSE_IK_ANCHORED | BRUSH_USE_CONNECTED_ONLY;
1747 br->flag &= ~BRUSH_ALPHA_PRESSURE;
1748 br->flag &= ~BRUSH_SPACE;
1749 br->flag &= ~BRUSH_SPACE_ATTEN;
1750 break;
1751 case SCULPT_TOOL_BOUNDARY:
1752 br->flag &= ~BRUSH_ALPHA_PRESSURE;
1753 br->flag &= ~BRUSH_SPACE;
1754 br->flag &= ~BRUSH_SPACE_ATTEN;
1755 br->curve_preset = BRUSH_CURVE_CONSTANT;
1756 break;
1757 case SCULPT_TOOL_DRAW_FACE_SETS:
1758 br->alpha = 0.5f;
1759 br->flag &= ~BRUSH_ALPHA_PRESSURE;
1760 br->flag &= ~BRUSH_SPACE;
1761 br->flag &= ~BRUSH_SPACE_ATTEN;
1762 break;
1763 case SCULPT_TOOL_GRAB:
1764 br->alpha = 0.4f;
1765 br->size = 75;
1766 br->flag &= ~BRUSH_ALPHA_PRESSURE;
1767 br->flag &= ~BRUSH_SPACE;
1768 br->flag &= ~BRUSH_SPACE_ATTEN;
1769 break;
1770 case SCULPT_TOOL_CLOTH:
1771 br->cloth_mass = 1.0f;
1772 br->cloth_damping = 0.01f;
1773 br->cloth_sim_limit = 2.5f;
1774 br->cloth_sim_falloff = 0.75f;
1775 br->cloth_deform_type = BRUSH_CLOTH_DEFORM_DRAG;
1776 br->flag &= ~(BRUSH_ALPHA_PRESSURE | BRUSH_SIZE_PRESSURE);
1777 break;
1778 case SCULPT_TOOL_LAYER:
1779 br->flag &= ~BRUSH_SPACE_ATTEN;
1780 br->hardness = 0.35f;
1781 br->alpha = 1.0f;
1782 br->height = 0.05f;
1783 break;
1784 case SCULPT_TOOL_PAINT:
1785 br->hardness = 0.4f;
1786 br->spacing = 10;
1787 br->alpha = 0.6f;
1788 br->flow = 1.0f;
1789 br->tip_scale_x = 1.0f;
1790 br->tip_roundness = 1.0f;
1791 br->density = 1.0f;
1792 br->flag &= ~BRUSH_SPACE_ATTEN;
1793 zero_v3(br->rgb);
1794 break;
1795 case SCULPT_TOOL_SMEAR:
1796 br->alpha = 1.0f;
1797 br->spacing = 5;
1798 br->flag &= ~BRUSH_ALPHA_PRESSURE;
1799 br->flag &= ~BRUSH_SPACE_ATTEN;
1800 br->curve_preset = BRUSH_CURVE_SPHERE;
1801 break;
1802 default:
1803 break;
1804 }
1805
1806 /* Cursor colors */
1807
1808 /* Default Alpha */
1809 br->add_col[3] = 0.90f;
1810 br->sub_col[3] = 0.90f;
1811
1812 switch (br->sculpt_tool) {
1813 case SCULPT_TOOL_DRAW:
1814 case SCULPT_TOOL_DRAW_SHARP:
1815 case SCULPT_TOOL_CLAY:
1816 case SCULPT_TOOL_CLAY_STRIPS:
1817 case SCULPT_TOOL_CLAY_THUMB:
1818 case SCULPT_TOOL_LAYER:
1819 case SCULPT_TOOL_INFLATE:
1820 case SCULPT_TOOL_BLOB:
1821 case SCULPT_TOOL_CREASE:
1822 br->add_col[0] = 0.0f;
1823 br->add_col[1] = 0.5f;
1824 br->add_col[2] = 1.0f;
1825 br->sub_col[0] = 0.0f;
1826 br->sub_col[1] = 0.5f;
1827 br->sub_col[2] = 1.0f;
1828 break;
1829
1830 case SCULPT_TOOL_SMOOTH:
1831 case SCULPT_TOOL_FLATTEN:
1832 case SCULPT_TOOL_FILL:
1833 case SCULPT_TOOL_SCRAPE:
1834 case SCULPT_TOOL_MULTIPLANE_SCRAPE:
1835 br->add_col[0] = 0.877f;
1836 br->add_col[1] = 0.142f;
1837 br->add_col[2] = 0.117f;
1838 br->sub_col[0] = 0.877f;
1839 br->sub_col[1] = 0.142f;
1840 br->sub_col[2] = 0.117f;
1841 break;
1842
1843 case SCULPT_TOOL_PINCH:
1844 case SCULPT_TOOL_GRAB:
1845 case SCULPT_TOOL_SNAKE_HOOK:
1846 case SCULPT_TOOL_THUMB:
1847 case SCULPT_TOOL_NUDGE:
1848 case SCULPT_TOOL_ROTATE:
1849 case SCULPT_TOOL_ELASTIC_DEFORM:
1850 case SCULPT_TOOL_POSE:
1851 case SCULPT_TOOL_BOUNDARY:
1852 case SCULPT_TOOL_SLIDE_RELAX:
1853 br->add_col[0] = 1.0f;
1854 br->add_col[1] = 0.95f;
1855 br->add_col[2] = 0.005f;
1856 br->sub_col[0] = 1.0f;
1857 br->sub_col[1] = 0.95f;
1858 br->sub_col[2] = 0.005f;
1859 break;
1860
1861 case SCULPT_TOOL_SIMPLIFY:
1862 case SCULPT_TOOL_PAINT:
1863 case SCULPT_TOOL_MASK:
1864 case SCULPT_TOOL_DRAW_FACE_SETS:
1865 case SCULPT_TOOL_DISPLACEMENT_ERASER:
1866 br->add_col[0] = 0.75f;
1867 br->add_col[1] = 0.75f;
1868 br->add_col[2] = 0.75f;
1869 br->sub_col[0] = 0.75f;
1870 br->sub_col[1] = 0.75f;
1871 br->sub_col[2] = 0.75f;
1872 break;
1873
1874 case SCULPT_TOOL_CLOTH:
1875 br->add_col[0] = 1.0f;
1876 br->add_col[1] = 0.5f;
1877 br->add_col[2] = 0.1f;
1878 br->sub_col[0] = 1.0f;
1879 br->sub_col[1] = 0.5f;
1880 br->sub_col[2] = 0.1f;
1881 break;
1882 default:
1883 break;
1884 }
1885 }
1886
1887 /**
1888 * Library Operations
1889 */
BKE_brush_curve_preset(Brush * b,eCurveMappingPreset preset)1890 void BKE_brush_curve_preset(Brush *b, eCurveMappingPreset preset)
1891 {
1892 CurveMapping *cumap = NULL;
1893 CurveMap *cuma = NULL;
1894
1895 if (!b->curve) {
1896 b->curve = BKE_curvemapping_add(1, 0, 0, 1, 1);
1897 }
1898 cumap = b->curve;
1899 cumap->flag &= ~CUMA_EXTEND_EXTRAPOLATE;
1900 cumap->preset = preset;
1901
1902 cuma = b->curve->cm;
1903 BKE_curvemap_reset(cuma, &cumap->clipr, cumap->preset, CURVEMAP_SLOPE_NEGATIVE);
1904 BKE_curvemapping_changed(cumap, false);
1905 }
1906
1907 /* Generic texture sampler for 3D painting systems. point has to be either in
1908 * region space mouse coordinates, or 3d world coordinates for 3D mapping.
1909 *
1910 * rgba outputs straight alpha. */
BKE_brush_sample_tex_3d(const Scene * scene,const Brush * br,const float point[3],float rgba[4],const int thread,struct ImagePool * pool)1911 float BKE_brush_sample_tex_3d(const Scene *scene,
1912 const Brush *br,
1913 const float point[3],
1914 float rgba[4],
1915 const int thread,
1916 struct ImagePool *pool)
1917 {
1918 UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
1919 const MTex *mtex = &br->mtex;
1920 float intensity = 1.0;
1921 bool hasrgb = false;
1922
1923 if (!mtex->tex) {
1924 intensity = 1;
1925 }
1926 else if (mtex->brush_map_mode == MTEX_MAP_MODE_3D) {
1927 /* Get strength by feeding the vertex
1928 * location directly into a texture */
1929 hasrgb = RE_texture_evaluate(mtex, point, thread, pool, false, false, &intensity, rgba);
1930 }
1931 else if (mtex->brush_map_mode == MTEX_MAP_MODE_STENCIL) {
1932 float rotation = -mtex->rot;
1933 const float point_2d[2] = {point[0], point[1]};
1934 float x, y;
1935 float co[3];
1936
1937 x = point_2d[0] - br->stencil_pos[0];
1938 y = point_2d[1] - br->stencil_pos[1];
1939
1940 if (rotation > 0.001f || rotation < -0.001f) {
1941 const float angle = atan2f(y, x) + rotation;
1942 const float flen = sqrtf(x * x + y * y);
1943
1944 x = flen * cosf(angle);
1945 y = flen * sinf(angle);
1946 }
1947
1948 if (fabsf(x) > br->stencil_dimension[0] || fabsf(y) > br->stencil_dimension[1]) {
1949 zero_v4(rgba);
1950 return 0.0f;
1951 }
1952 x /= (br->stencil_dimension[0]);
1953 y /= (br->stencil_dimension[1]);
1954
1955 co[0] = x;
1956 co[1] = y;
1957 co[2] = 0.0f;
1958
1959 hasrgb = RE_texture_evaluate(mtex, co, thread, pool, false, false, &intensity, rgba);
1960 }
1961 else {
1962 float rotation = -mtex->rot;
1963 const float point_2d[2] = {point[0], point[1]};
1964 float x = 0.0f, y = 0.0f; /* Quite warnings */
1965 float invradius = 1.0f; /* Quite warnings */
1966 float co[3];
1967
1968 if (mtex->brush_map_mode == MTEX_MAP_MODE_VIEW) {
1969 /* keep coordinates relative to mouse */
1970
1971 rotation += ups->brush_rotation;
1972
1973 x = point_2d[0] - ups->tex_mouse[0];
1974 y = point_2d[1] - ups->tex_mouse[1];
1975
1976 /* use pressure adjusted size for fixed mode */
1977 invradius = 1.0f / ups->pixel_radius;
1978 }
1979 else if (mtex->brush_map_mode == MTEX_MAP_MODE_TILED) {
1980 /* leave the coordinates relative to the screen */
1981
1982 /* use unadjusted size for tiled mode */
1983 invradius = 1.0f / BKE_brush_size_get(scene, br);
1984
1985 x = point_2d[0];
1986 y = point_2d[1];
1987 }
1988 else if (mtex->brush_map_mode == MTEX_MAP_MODE_RANDOM) {
1989 rotation += ups->brush_rotation;
1990 /* these contain a random coordinate */
1991 x = point_2d[0] - ups->tex_mouse[0];
1992 y = point_2d[1] - ups->tex_mouse[1];
1993
1994 invradius = 1.0f / ups->pixel_radius;
1995 }
1996
1997 x *= invradius;
1998 y *= invradius;
1999
2000 /* it is probably worth optimizing for those cases where
2001 * the texture is not rotated by skipping the calls to
2002 * atan2, sqrtf, sin, and cos. */
2003 if (rotation > 0.001f || rotation < -0.001f) {
2004 const float angle = atan2f(y, x) + rotation;
2005 const float flen = sqrtf(x * x + y * y);
2006
2007 x = flen * cosf(angle);
2008 y = flen * sinf(angle);
2009 }
2010
2011 co[0] = x;
2012 co[1] = y;
2013 co[2] = 0.0f;
2014
2015 hasrgb = RE_texture_evaluate(mtex, co, thread, pool, false, false, &intensity, rgba);
2016 }
2017
2018 intensity += br->texture_sample_bias;
2019
2020 if (!hasrgb) {
2021 rgba[0] = intensity;
2022 rgba[1] = intensity;
2023 rgba[2] = intensity;
2024 rgba[3] = 1.0f;
2025 }
2026 /* For consistency, sampling always returns color in linear space */
2027 else if (ups->do_linear_conversion) {
2028 IMB_colormanagement_colorspace_to_scene_linear_v3(rgba, ups->colorspace);
2029 }
2030
2031 return intensity;
2032 }
2033
BKE_brush_sample_masktex(const Scene * scene,Brush * br,const float point[2],const int thread,struct ImagePool * pool)2034 float BKE_brush_sample_masktex(
2035 const Scene *scene, Brush *br, const float point[2], const int thread, struct ImagePool *pool)
2036 {
2037 UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
2038 MTex *mtex = &br->mask_mtex;
2039 float rgba[4], intensity;
2040
2041 if (!mtex->tex) {
2042 return 1.0f;
2043 }
2044 if (mtex->brush_map_mode == MTEX_MAP_MODE_STENCIL) {
2045 float rotation = -mtex->rot;
2046 const float point_2d[2] = {point[0], point[1]};
2047 float x, y;
2048 float co[3];
2049
2050 x = point_2d[0] - br->mask_stencil_pos[0];
2051 y = point_2d[1] - br->mask_stencil_pos[1];
2052
2053 if (rotation > 0.001f || rotation < -0.001f) {
2054 const float angle = atan2f(y, x) + rotation;
2055 const float flen = sqrtf(x * x + y * y);
2056
2057 x = flen * cosf(angle);
2058 y = flen * sinf(angle);
2059 }
2060
2061 if (fabsf(x) > br->mask_stencil_dimension[0] || fabsf(y) > br->mask_stencil_dimension[1]) {
2062 zero_v4(rgba);
2063 return 0.0f;
2064 }
2065 x /= (br->mask_stencil_dimension[0]);
2066 y /= (br->mask_stencil_dimension[1]);
2067
2068 co[0] = x;
2069 co[1] = y;
2070 co[2] = 0.0f;
2071
2072 RE_texture_evaluate(mtex, co, thread, pool, false, false, &intensity, rgba);
2073 }
2074 else {
2075 float rotation = -mtex->rot;
2076 const float point_2d[2] = {point[0], point[1]};
2077 float x = 0.0f, y = 0.0f; /* Quite warnings */
2078 float invradius = 1.0f; /* Quite warnings */
2079 float co[3];
2080
2081 if (mtex->brush_map_mode == MTEX_MAP_MODE_VIEW) {
2082 /* keep coordinates relative to mouse */
2083
2084 rotation += ups->brush_rotation_sec;
2085
2086 x = point_2d[0] - ups->mask_tex_mouse[0];
2087 y = point_2d[1] - ups->mask_tex_mouse[1];
2088
2089 /* use pressure adjusted size for fixed mode */
2090 invradius = 1.0f / ups->pixel_radius;
2091 }
2092 else if (mtex->brush_map_mode == MTEX_MAP_MODE_TILED) {
2093 /* leave the coordinates relative to the screen */
2094
2095 /* use unadjusted size for tiled mode */
2096 invradius = 1.0f / BKE_brush_size_get(scene, br);
2097
2098 x = point_2d[0];
2099 y = point_2d[1];
2100 }
2101 else if (mtex->brush_map_mode == MTEX_MAP_MODE_RANDOM) {
2102 rotation += ups->brush_rotation_sec;
2103 /* these contain a random coordinate */
2104 x = point_2d[0] - ups->mask_tex_mouse[0];
2105 y = point_2d[1] - ups->mask_tex_mouse[1];
2106
2107 invradius = 1.0f / ups->pixel_radius;
2108 }
2109
2110 x *= invradius;
2111 y *= invradius;
2112
2113 /* it is probably worth optimizing for those cases where
2114 * the texture is not rotated by skipping the calls to
2115 * atan2, sqrtf, sin, and cos. */
2116 if (rotation > 0.001f || rotation < -0.001f) {
2117 const float angle = atan2f(y, x) + rotation;
2118 const float flen = sqrtf(x * x + y * y);
2119
2120 x = flen * cosf(angle);
2121 y = flen * sinf(angle);
2122 }
2123
2124 co[0] = x;
2125 co[1] = y;
2126 co[2] = 0.0f;
2127
2128 RE_texture_evaluate(mtex, co, thread, pool, false, false, &intensity, rgba);
2129 }
2130
2131 CLAMP(intensity, 0.0f, 1.0f);
2132
2133 switch (br->mask_pressure) {
2134 case BRUSH_MASK_PRESSURE_CUTOFF:
2135 intensity = ((1.0f - intensity) < ups->size_pressure_value) ? 1.0f : 0.0f;
2136 break;
2137 case BRUSH_MASK_PRESSURE_RAMP:
2138 intensity = ups->size_pressure_value + intensity * (1.0f - ups->size_pressure_value);
2139 break;
2140 default:
2141 break;
2142 }
2143
2144 return intensity;
2145 }
2146
2147 /* Unified Size / Strength / Color */
2148
2149 /* XXX: be careful about setting size and unprojected radius
2150 * because they depend on one another
2151 * these functions do not set the other corresponding value
2152 * this can lead to odd behavior if size and unprojected
2153 * radius become inconsistent.
2154 * the biggest problem is that it isn't possible to change
2155 * unprojected radius because a view context is not
2156 * available. my usual solution to this is to use the
2157 * ratio of change of the size to change the unprojected
2158 * radius. Not completely convinced that is correct.
2159 * In any case, a better solution is needed to prevent
2160 * inconsistency. */
2161
BKE_brush_color_get(const struct Scene * scene,const struct Brush * brush)2162 const float *BKE_brush_color_get(const struct Scene *scene, const struct Brush *brush)
2163 {
2164 UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
2165 return (ups->flag & UNIFIED_PAINT_COLOR) ? ups->rgb : brush->rgb;
2166 }
2167
BKE_brush_secondary_color_get(const struct Scene * scene,const struct Brush * brush)2168 const float *BKE_brush_secondary_color_get(const struct Scene *scene, const struct Brush *brush)
2169 {
2170 UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
2171 return (ups->flag & UNIFIED_PAINT_COLOR) ? ups->secondary_rgb : brush->secondary_rgb;
2172 }
2173
BKE_brush_color_set(struct Scene * scene,struct Brush * brush,const float color[3])2174 void BKE_brush_color_set(struct Scene *scene, struct Brush *brush, const float color[3])
2175 {
2176 UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
2177
2178 if (ups->flag & UNIFIED_PAINT_COLOR) {
2179 copy_v3_v3(ups->rgb, color);
2180 }
2181 else {
2182 copy_v3_v3(brush->rgb, color);
2183 }
2184 }
2185
BKE_brush_size_set(Scene * scene,Brush * brush,int size)2186 void BKE_brush_size_set(Scene *scene, Brush *brush, int size)
2187 {
2188 UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
2189
2190 /* make sure range is sane */
2191 CLAMP(size, 1, MAX_BRUSH_PIXEL_RADIUS);
2192
2193 if (ups->flag & UNIFIED_PAINT_SIZE) {
2194 ups->size = size;
2195 }
2196 else {
2197 brush->size = size;
2198 }
2199 }
2200
BKE_brush_size_get(const Scene * scene,const Brush * brush)2201 int BKE_brush_size_get(const Scene *scene, const Brush *brush)
2202 {
2203 UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
2204 int size = (ups->flag & UNIFIED_PAINT_SIZE) ? ups->size : brush->size;
2205
2206 return size;
2207 }
2208
BKE_brush_use_locked_size(const Scene * scene,const Brush * brush)2209 bool BKE_brush_use_locked_size(const Scene *scene, const Brush *brush)
2210 {
2211 const short us_flag = scene->toolsettings->unified_paint_settings.flag;
2212
2213 return (us_flag & UNIFIED_PAINT_SIZE) ? (us_flag & UNIFIED_PAINT_BRUSH_LOCK_SIZE) :
2214 (brush->flag & BRUSH_LOCK_SIZE);
2215 }
2216
BKE_brush_use_size_pressure(const Brush * brush)2217 bool BKE_brush_use_size_pressure(const Brush *brush)
2218 {
2219 return brush->flag & BRUSH_SIZE_PRESSURE;
2220 }
2221
BKE_brush_use_alpha_pressure(const Brush * brush)2222 bool BKE_brush_use_alpha_pressure(const Brush *brush)
2223 {
2224 return brush->flag & BRUSH_ALPHA_PRESSURE;
2225 }
2226
BKE_brush_sculpt_has_secondary_color(const Brush * brush)2227 bool BKE_brush_sculpt_has_secondary_color(const Brush *brush)
2228 {
2229 return ELEM(brush->sculpt_tool,
2230 SCULPT_TOOL_BLOB,
2231 SCULPT_TOOL_DRAW,
2232 SCULPT_TOOL_DRAW_SHARP,
2233 SCULPT_TOOL_INFLATE,
2234 SCULPT_TOOL_CLAY,
2235 SCULPT_TOOL_CLAY_STRIPS,
2236 SCULPT_TOOL_CLAY_THUMB,
2237 SCULPT_TOOL_PINCH,
2238 SCULPT_TOOL_CREASE,
2239 SCULPT_TOOL_LAYER,
2240 SCULPT_TOOL_FLATTEN,
2241 SCULPT_TOOL_FILL,
2242 SCULPT_TOOL_SCRAPE,
2243 SCULPT_TOOL_MASK);
2244 }
2245
BKE_brush_unprojected_radius_set(Scene * scene,Brush * brush,float unprojected_radius)2246 void BKE_brush_unprojected_radius_set(Scene *scene, Brush *brush, float unprojected_radius)
2247 {
2248 UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
2249
2250 if (ups->flag & UNIFIED_PAINT_SIZE) {
2251 ups->unprojected_radius = unprojected_radius;
2252 }
2253 else {
2254 brush->unprojected_radius = unprojected_radius;
2255 }
2256 }
2257
BKE_brush_unprojected_radius_get(const Scene * scene,const Brush * brush)2258 float BKE_brush_unprojected_radius_get(const Scene *scene, const Brush *brush)
2259 {
2260 UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
2261
2262 return (ups->flag & UNIFIED_PAINT_SIZE) ? ups->unprojected_radius : brush->unprojected_radius;
2263 }
2264
BKE_brush_alpha_set(Scene * scene,Brush * brush,float alpha)2265 void BKE_brush_alpha_set(Scene *scene, Brush *brush, float alpha)
2266 {
2267 UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
2268
2269 if (ups->flag & UNIFIED_PAINT_ALPHA) {
2270 ups->alpha = alpha;
2271 }
2272 else {
2273 brush->alpha = alpha;
2274 }
2275 }
2276
BKE_brush_alpha_get(const Scene * scene,const Brush * brush)2277 float BKE_brush_alpha_get(const Scene *scene, const Brush *brush)
2278 {
2279 UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
2280
2281 return (ups->flag & UNIFIED_PAINT_ALPHA) ? ups->alpha : brush->alpha;
2282 }
2283
BKE_brush_weight_get(const Scene * scene,const Brush * brush)2284 float BKE_brush_weight_get(const Scene *scene, const Brush *brush)
2285 {
2286 UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
2287
2288 return (ups->flag & UNIFIED_PAINT_WEIGHT) ? ups->weight : brush->weight;
2289 }
2290
BKE_brush_weight_set(const Scene * scene,Brush * brush,float value)2291 void BKE_brush_weight_set(const Scene *scene, Brush *brush, float value)
2292 {
2293 UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
2294
2295 if (ups->flag & UNIFIED_PAINT_WEIGHT) {
2296 ups->weight = value;
2297 }
2298 else {
2299 brush->weight = value;
2300 }
2301 }
2302
2303 /* scale unprojected radius to reflect a change in the brush's 2D size */
BKE_brush_scale_unprojected_radius(float * unprojected_radius,int new_brush_size,int old_brush_size)2304 void BKE_brush_scale_unprojected_radius(float *unprojected_radius,
2305 int new_brush_size,
2306 int old_brush_size)
2307 {
2308 float scale = new_brush_size;
2309 /* avoid division by zero */
2310 if (old_brush_size != 0) {
2311 scale /= (float)old_brush_size;
2312 }
2313 (*unprojected_radius) *= scale;
2314 }
2315
2316 /* scale brush size to reflect a change in the brush's unprojected radius */
BKE_brush_scale_size(int * r_brush_size,float new_unprojected_radius,float old_unprojected_radius)2317 void BKE_brush_scale_size(int *r_brush_size,
2318 float new_unprojected_radius,
2319 float old_unprojected_radius)
2320 {
2321 float scale = new_unprojected_radius;
2322 /* avoid division by zero */
2323 if (old_unprojected_radius != 0) {
2324 scale /= new_unprojected_radius;
2325 }
2326 (*r_brush_size) = (int)((float)(*r_brush_size) * scale);
2327 }
2328
BKE_brush_jitter_pos(const Scene * scene,Brush * brush,const float pos[2],float jitterpos[2])2329 void BKE_brush_jitter_pos(const Scene *scene, Brush *brush, const float pos[2], float jitterpos[2])
2330 {
2331 float rand_pos[2];
2332 float spread;
2333 int diameter;
2334
2335 do {
2336 rand_pos[0] = BLI_rng_get_float(brush_rng) - 0.5f;
2337 rand_pos[1] = BLI_rng_get_float(brush_rng) - 0.5f;
2338 } while (len_squared_v2(rand_pos) > square_f(0.5f));
2339
2340 if (brush->flag & BRUSH_ABSOLUTE_JITTER) {
2341 diameter = 2 * brush->jitter_absolute;
2342 spread = 1.0;
2343 }
2344 else {
2345 diameter = 2 * BKE_brush_size_get(scene, brush);
2346 spread = brush->jitter;
2347 }
2348 /* find random position within a circle of diameter 1 */
2349 jitterpos[0] = pos[0] + 2 * rand_pos[0] * diameter * spread;
2350 jitterpos[1] = pos[1] + 2 * rand_pos[1] * diameter * spread;
2351 }
2352
BKE_brush_randomize_texture_coords(UnifiedPaintSettings * ups,bool mask)2353 void BKE_brush_randomize_texture_coords(UnifiedPaintSettings *ups, bool mask)
2354 {
2355 /* we multiply with brush radius as an optimization for the brush
2356 * texture sampling functions */
2357 if (mask) {
2358 ups->mask_tex_mouse[0] = BLI_rng_get_float(brush_rng) * ups->pixel_radius;
2359 ups->mask_tex_mouse[1] = BLI_rng_get_float(brush_rng) * ups->pixel_radius;
2360 }
2361 else {
2362 ups->tex_mouse[0] = BLI_rng_get_float(brush_rng) * ups->pixel_radius;
2363 ups->tex_mouse[1] = BLI_rng_get_float(brush_rng) * ups->pixel_radius;
2364 }
2365 }
2366
2367 /* Uses the brush curve control to find a strength value */
BKE_brush_curve_strength(const Brush * br,float p,const float len)2368 float BKE_brush_curve_strength(const Brush *br, float p, const float len)
2369 {
2370 float strength = 1.0f;
2371
2372 if (p >= len) {
2373 return 0;
2374 }
2375
2376 p = p / len;
2377 p = 1.0f - p;
2378
2379 switch (br->curve_preset) {
2380 case BRUSH_CURVE_CUSTOM:
2381 strength = BKE_curvemapping_evaluateF(br->curve, 0, 1.0f - p);
2382 break;
2383 case BRUSH_CURVE_SHARP:
2384 strength = p * p;
2385 break;
2386 case BRUSH_CURVE_SMOOTH:
2387 strength = 3.0f * p * p - 2.0f * p * p * p;
2388 break;
2389 case BRUSH_CURVE_SMOOTHER:
2390 strength = pow3f(p) * (p * (p * 6.0f - 15.0f) + 10.0f);
2391 break;
2392 case BRUSH_CURVE_ROOT:
2393 strength = sqrtf(p);
2394 break;
2395 case BRUSH_CURVE_LIN:
2396 strength = p;
2397 break;
2398 case BRUSH_CURVE_CONSTANT:
2399 strength = 1.0f;
2400 break;
2401 case BRUSH_CURVE_SPHERE:
2402 strength = sqrtf(2 * p - p * p);
2403 break;
2404 case BRUSH_CURVE_POW4:
2405 strength = p * p * p * p;
2406 break;
2407 case BRUSH_CURVE_INVSQUARE:
2408 strength = p * (2.0f - p);
2409 break;
2410 }
2411
2412 return strength;
2413 }
2414
2415 /* Uses the brush curve control to find a strength value between 0 and 1 */
BKE_brush_curve_strength_clamped(Brush * br,float p,const float len)2416 float BKE_brush_curve_strength_clamped(Brush *br, float p, const float len)
2417 {
2418 float strength = BKE_brush_curve_strength(br, p, len);
2419
2420 CLAMP(strength, 0.0f, 1.0f);
2421
2422 return strength;
2423 }
2424
2425 /* TODO: should probably be unified with BrushPainter stuff? */
BKE_brush_gen_texture_cache(Brush * br,int half_side,bool use_secondary)2426 unsigned int *BKE_brush_gen_texture_cache(Brush *br, int half_side, bool use_secondary)
2427 {
2428 unsigned int *texcache = NULL;
2429 MTex *mtex = (use_secondary) ? &br->mask_mtex : &br->mtex;
2430 float intensity;
2431 float rgba_dummy[4];
2432 int ix, iy;
2433 int side = half_side * 2;
2434
2435 if (mtex->tex) {
2436 float x, y, step = 2.0 / side, co[3];
2437
2438 texcache = MEM_callocN(sizeof(int) * side * side, "Brush texture cache");
2439
2440 /* do normalized canonical view coords for texture */
2441 for (y = -1.0, iy = 0; iy < side; iy++, y += step) {
2442 for (x = -1.0, ix = 0; ix < side; ix++, x += step) {
2443 co[0] = x;
2444 co[1] = y;
2445 co[2] = 0.0f;
2446
2447 /* This is copied from displace modifier code */
2448 /* TODO(sergey): brush are always caching with CM enabled for now. */
2449 RE_texture_evaluate(mtex, co, 0, NULL, false, false, &intensity, rgba_dummy);
2450 copy_v4_uchar((uchar *)&texcache[iy * side + ix], (char)(intensity * 255.0f));
2451 }
2452 }
2453 }
2454
2455 return texcache;
2456 }
2457
2458 /**** Radial Control ****/
BKE_brush_gen_radial_control_imbuf(Brush * br,bool secondary,bool display_gradient)2459 struct ImBuf *BKE_brush_gen_radial_control_imbuf(Brush *br, bool secondary, bool display_gradient)
2460 {
2461 ImBuf *im = MEM_callocN(sizeof(ImBuf), "radial control texture");
2462 unsigned int *texcache;
2463 int side = 512;
2464 int half = side / 2;
2465 int i, j;
2466
2467 BKE_curvemapping_init(br->curve);
2468 texcache = BKE_brush_gen_texture_cache(br, half, secondary);
2469 im->rect_float = MEM_callocN(sizeof(float) * side * side, "radial control rect");
2470 im->x = im->y = side;
2471
2472 if (display_gradient || texcache) {
2473 for (i = 0; i < side; i++) {
2474 for (j = 0; j < side; j++) {
2475 float magn = sqrtf(pow2f(i - half) + pow2f(j - half));
2476 im->rect_float[i * side + j] = BKE_brush_curve_strength_clamped(br, magn, half);
2477 }
2478 }
2479 }
2480
2481 if (texcache) {
2482 /* Modulate curve with texture */
2483 for (i = 0; i < side; i++) {
2484 for (j = 0; j < side; j++) {
2485 const int col = texcache[i * side + j];
2486 im->rect_float[i * side + j] *= (((char *)&col)[0] + ((char *)&col)[1] +
2487 ((char *)&col)[2]) /
2488 3.0f / 255.0f;
2489 }
2490 }
2491 MEM_freeN(texcache);
2492 }
2493
2494 return im;
2495 }
2496