Blender V5.3
brush.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8#include <array>
9#include <optional>
10
11#include "MEM_guardedalloc.h"
12
13/* Allow using deprecated functionality for .blend file I/O. */
14#define DNA_DEPRECATED_ALLOW
15
16#include "DNA_ID.h"
17#include "DNA_brush_types.h"
18#include "DNA_material_types.h"
19#include "DNA_scene_types.h"
20
21#include "BLI_listbase.hh"
22#include "BLI_math_base.hh"
23#include "BLI_math_color_c.hh"
24#include "BLI_rand_c.hh"
25
26#include "BLT_translation.hh"
27
28#include "BKE_asset.hh"
29#include "BKE_bpath.hh"
30#include "BKE_brush.hh"
31#include "BKE_colorband.hh"
32#include "BKE_colortools.hh"
33#include "BKE_grease_pencil.hh"
34#include "BKE_idprop.hh"
35#include "BKE_idtype.hh"
36#include "BKE_lib_id.hh"
37#include "BKE_lib_query.hh"
38#include "BKE_lib_remap.hh"
39#include "BKE_main.hh"
40#include "BKE_material.hh"
41#include "BKE_paint.hh"
42#include "BKE_paint_types.hh"
43#include "BKE_preview_image.hh"
44#include "BKE_texture.h"
45
47#include "IMB_imbuf.hh"
48#include "IMB_imbuf_types.hh"
49
50#include "PRF_profile.hh"
51
52#include "RE_texture.h" /* RE_texture_evaluate */
53
54#include "BLO_read_write.hh"
55
56namespace blender {
57
58static void brush_init_data(ID *id)
59{
60 Brush *brush = reinterpret_cast<Brush *>(id);
62
63 /* enable fake user by default */
65
66 /* the default alpha falloff curve */
68
69 brush->curve_rand_hue = BKE_paint_default_curve();
70 brush->curve_rand_saturation = BKE_paint_default_curve();
71 brush->curve_rand_value = BKE_paint_default_curve();
72
73 brush->curve_size = BKE_paint_default_curve();
74 brush->curve_strength = BKE_paint_default_curve();
75 brush->curve_jitter = BKE_paint_default_curve();
76 brush->curve_hardness = BKE_paint_default_curve();
77 brush->curve_auto_smooth = BKE_paint_default_curve_inverted();
78 brush->curve_spacing = BKE_paint_default_curve();
79}
80
81static void brush_copy_data(Main * /*bmain*/,
82 std::optional<Library *> /*owner_library*/,
83 ID *id_dst,
84 const ID *id_src,
85 const int flag)
86{
87 Brush *brush_dst = reinterpret_cast<Brush *>(id_dst);
88 const Brush *brush_src = reinterpret_cast<const Brush *>(id_src);
89
90 if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
91 BKE_previewimg_id_copy(&brush_dst->id, &brush_src->id);
92 }
93 else {
94 brush_dst->preview = nullptr;
95 }
96
99
100 brush_dst->curve_rand_hue = BKE_curvemapping_copy(brush_src->curve_rand_hue);
103
104 brush_dst->curve_size = BKE_curvemapping_copy(brush_src->curve_size);
105 brush_dst->curve_strength = BKE_curvemapping_copy(brush_src->curve_strength);
106 brush_dst->curve_jitter = BKE_curvemapping_copy(brush_src->curve_jitter);
107 brush_dst->curve_hardness = BKE_curvemapping_copy(brush_src->curve_hardness);
109 brush_dst->curve_spacing = BKE_curvemapping_copy(brush_src->curve_spacing);
110
111 if (brush_src->gpencil_settings != nullptr) {
112 brush_dst->gpencil_settings = MEM_new<BrushGpencilSettings>(
113 __func__, dna::shallow_copy(*(brush_src->gpencil_settings)));
117 brush_src->gpencil_settings->curve_strength);
119 brush_src->gpencil_settings->curve_jitter);
120
126 brush_src->gpencil_settings->curve_rand_uv);
128 brush_src->gpencil_settings->curve_rand_hue);
133 }
134 if (brush_src->curves_sculpt_settings != nullptr) {
135 brush_dst->curves_sculpt_settings = MEM_new<BrushCurvesSculptSettings>(
136 __func__, *(brush_src->curves_sculpt_settings));
139 }
140 if (brush_src->mesh_automasking_settings != nullptr) {
141 brush_dst->mesh_automasking_settings = MEM_new<MeshAutomaskingSettings>(
142 __func__, dna::shallow_copy(*(brush_src->mesh_automasking_settings)));
145
146 /* The "operator" level cavity curve is never used for the brush. Ensure it is nullptr */
147 brush_dst->mesh_automasking_settings->cavity_curve_op = nullptr;
148 }
149
150 /* enable fake user by default */
151 id_fake_user_set(&brush_dst->id);
152}
153
154static void brush_free_data(ID *id)
155{
156 Brush *brush = reinterpret_cast<Brush *>(id);
157 BKE_curvemapping_free(brush->curve_distance_falloff);
158 BKE_curvemapping_free(brush->automasking_cavity_curve);
159
160 BKE_curvemapping_free(brush->curve_rand_hue);
161 BKE_curvemapping_free(brush->curve_rand_saturation);
162 BKE_curvemapping_free(brush->curve_rand_value);
163
164 BKE_curvemapping_free(brush->curve_size);
165 BKE_curvemapping_free(brush->curve_strength);
166 BKE_curvemapping_free(brush->curve_jitter);
167 BKE_curvemapping_free(brush->curve_hardness);
168 BKE_curvemapping_free(brush->curve_auto_smooth);
169 BKE_curvemapping_free(brush->curve_spacing);
170
171 if (brush->gpencil_settings != nullptr) {
172 BKE_curvemapping_free(brush->gpencil_settings->curve_sensitivity);
173 BKE_curvemapping_free(brush->gpencil_settings->curve_strength);
174 BKE_curvemapping_free(brush->gpencil_settings->curve_jitter);
175
176 BKE_curvemapping_free(brush->gpencil_settings->curve_rand_pressure);
177 BKE_curvemapping_free(brush->gpencil_settings->curve_rand_strength);
178 BKE_curvemapping_free(brush->gpencil_settings->curve_rand_uv);
179 BKE_curvemapping_free(brush->gpencil_settings->curve_rand_hue);
180 BKE_curvemapping_free(brush->gpencil_settings->curve_rand_saturation);
181 BKE_curvemapping_free(brush->gpencil_settings->curve_rand_value);
182
183 MEM_SAFE_DELETE(brush->gpencil_settings);
184 }
185 if (brush->curves_sculpt_settings != nullptr) {
186 BKE_curvemapping_free(brush->curves_sculpt_settings->curve_parameter_falloff);
187 MEM_delete(brush->curves_sculpt_settings);
188 }
189 if (brush->mesh_automasking_settings != nullptr) {
190 BKE_curvemapping_free(brush->mesh_automasking_settings->cavity_curve);
191 MEM_delete(brush->mesh_automasking_settings);
192 }
193
194 MEM_SAFE_DELETE(brush->gradient);
195
197}
198
199static void brush_make_local(Main *bmain, ID *id, const int flags)
200{
201 if (!ID_IS_LINKED(id)) {
202 return;
203 }
204
205 Brush *brush = reinterpret_cast<Brush *>(id);
206 const bool lib_local = (flags & LIB_ID_MAKELOCAL_FULL_LIBRARY) != 0;
207
208 bool force_local, force_copy;
209 BKE_lib_id_make_local_generic_action_define(bmain, id, flags, &force_local, &force_copy);
210
211 if (force_local) {
212 BKE_lib_id_clear_library_data(bmain, &brush->id, flags);
213 BKE_lib_id_expand_local(bmain, &brush->id, flags);
214
215 /* enable fake user by default */
217 }
218 else if (force_copy) {
219 Brush *brush_new = reinterpret_cast<Brush *>(
220 BKE_id_copy(bmain, &brush->id)); /* Ensures FAKE_USER is set */
221
222 id_us_min(&brush_new->id);
223
224 BLI_assert(brush_new->id.flag & ID_FLAG_FAKEUSER);
225 BLI_assert(brush_new->id.us == 1);
226
227 /* Setting `newid` is mandatory for complex #make_lib_local logic. */
228 ID_NEW_SET(brush, brush_new);
229
230 if (!lib_local) {
232 }
233 }
234}
235
237{
238 Brush *brush = reinterpret_cast<Brush *>(id);
239
241 if (brush->gpencil_settings) {
242 BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, brush->gpencil_settings->material, IDWALK_CB_USER);
243 BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, brush->gpencil_settings->material_alt, IDWALK_CB_USER);
244 }
248}
249
251{
252 Brush *brush = reinterpret_cast<Brush *>(id);
253
254 fn.single(brush->color);
255 fn.single(brush->secondary_color);
256 if (brush->gradient) {
258 }
259
261}
262
263static void brush_blend_write(BlendWriter *writer, ID *id, const void *id_address)
264{
265 Brush *brush = reinterpret_cast<Brush *>(id);
266
267 writer->write_id_struct(id_address, brush);
268 BKE_id_blend_write(writer, &brush->id);
269
270 if (brush->curve_distance_falloff) {
271 BKE_curvemapping_blend_write(writer, brush->curve_distance_falloff);
272 }
273
274 if (brush->automasking_cavity_curve) {
275 BKE_curvemapping_blend_write(writer, brush->automasking_cavity_curve);
276 }
277
278 if (brush->curve_rand_hue) {
279 BKE_curvemapping_blend_write(writer, brush->curve_rand_hue);
280 }
281 if (brush->curve_rand_saturation) {
282 BKE_curvemapping_blend_write(writer, brush->curve_rand_saturation);
283 }
284 if (brush->curve_rand_value) {
285 BKE_curvemapping_blend_write(writer, brush->curve_rand_value);
286 }
287
288 if (brush->curve_size) {
289 BKE_curvemapping_blend_write(writer, brush->curve_size);
290 }
291 if (brush->curve_strength) {
292 BKE_curvemapping_blend_write(writer, brush->curve_strength);
293 }
294 if (brush->curve_jitter) {
295 BKE_curvemapping_blend_write(writer, brush->curve_jitter);
296 }
297 if (brush->curve_hardness) {
298 BKE_curvemapping_blend_write(writer, brush->curve_hardness);
299 }
300 if (brush->curve_auto_smooth) {
301 BKE_curvemapping_blend_write(writer, brush->curve_auto_smooth);
302 }
303 if (brush->curve_spacing) {
304 BKE_curvemapping_blend_write(writer, brush->curve_spacing);
305 }
306
307 if (brush->gpencil_settings) {
308 writer->write_struct(brush->gpencil_settings);
309
310 if (brush->gpencil_settings->curve_sensitivity) {
311 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_sensitivity);
312 }
313 if (brush->gpencil_settings->curve_strength) {
314 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_strength);
315 }
316 if (brush->gpencil_settings->curve_jitter) {
317 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_jitter);
318 }
319 if (brush->gpencil_settings->curve_rand_pressure) {
320 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_pressure);
321 }
322 if (brush->gpencil_settings->curve_rand_strength) {
323 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_strength);
324 }
325 if (brush->gpencil_settings->curve_rand_uv) {
326 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_uv);
327 }
328 if (brush->gpencil_settings->curve_rand_hue) {
329 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_hue);
330 }
331 if (brush->gpencil_settings->curve_rand_saturation) {
332 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_saturation);
333 }
334 if (brush->gpencil_settings->curve_rand_value) {
335 BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_value);
336 }
337 }
338 if (brush->curves_sculpt_settings) {
339 writer->write_struct(brush->curves_sculpt_settings);
340 BKE_curvemapping_blend_write(writer, brush->curves_sculpt_settings->curve_parameter_falloff);
341 }
342 if (brush->mesh_automasking_settings) {
343 writer->write_struct(brush->mesh_automasking_settings);
344 BKE_curvemapping_blend_write(writer, brush->mesh_automasking_settings->cavity_curve);
345 }
346
347 if (brush->gradient) {
348 writer->write_struct(brush->gradient);
349 }
350
351 BKE_previewimg_blend_write(writer, brush->preview);
352}
353
354static void brush_blend_read_data(BlendDataReader *reader, ID *id)
355{
356 Brush *brush = reinterpret_cast<Brush *>(id);
357
358 /* Falloff curve. */
359 BLO_read_struct(reader, CurveMapping, &brush->curve_distance_falloff);
360
361 BLO_read_struct(reader, ColorBand, &brush->gradient);
362
363 if (brush->curve_distance_falloff) {
364 BKE_curvemapping_blend_read(reader, brush->curve_distance_falloff);
365 }
366 else {
368 }
369
370 BLO_read_struct(reader, CurveMapping, &brush->automasking_cavity_curve);
371 if (brush->automasking_cavity_curve) {
372 BKE_curvemapping_blend_read(reader, brush->automasking_cavity_curve);
373 }
374 else {
375 brush->automasking_cavity_curve = BKE_sculpt_default_cavity_curve();
376 }
377
378 BLO_read_struct(reader, CurveMapping, &brush->curve_rand_hue);
379 if (brush->curve_rand_hue) {
380 BKE_curvemapping_blend_read(reader, brush->curve_rand_hue);
381 }
382 else {
383 brush->curve_rand_hue = BKE_paint_default_curve();
384 }
385
386 BLO_read_struct(reader, CurveMapping, &brush->curve_rand_saturation);
387 if (brush->curve_rand_saturation) {
388 BKE_curvemapping_blend_read(reader, brush->curve_rand_saturation);
389 }
390 else {
391 brush->curve_rand_saturation = BKE_paint_default_curve();
392 }
393
394 BLO_read_struct(reader, CurveMapping, &brush->curve_rand_value);
395 if (brush->curve_rand_value) {
396 BKE_curvemapping_blend_read(reader, brush->curve_rand_value);
397 }
398 else {
399 brush->curve_rand_value = BKE_paint_default_curve();
400 }
401
402 BLO_read_struct(reader, CurveMapping, &brush->curve_size);
403 if (brush->curve_size) {
404 BKE_curvemapping_blend_read(reader, brush->curve_size);
405 }
406 else {
407 brush->curve_size = BKE_paint_default_curve();
408 }
409
410 BLO_read_struct(reader, CurveMapping, &brush->curve_strength);
411 if (brush->curve_strength) {
412 BKE_curvemapping_blend_read(reader, brush->curve_strength);
413 }
414 else {
415 brush->curve_strength = BKE_paint_default_curve();
416 }
417
418 BLO_read_struct(reader, CurveMapping, &brush->curve_jitter);
419 if (brush->curve_jitter) {
420 BKE_curvemapping_blend_read(reader, brush->curve_jitter);
421 }
422 else {
423 brush->curve_jitter = BKE_paint_default_curve();
424 }
425
426 BLO_read_struct(reader, CurveMapping, &brush->curve_hardness);
427 if (brush->curve_hardness) {
428 BKE_curvemapping_blend_read(reader, brush->curve_hardness);
429 }
430 else {
431 brush->curve_hardness = BKE_paint_default_curve();
432 }
433
434 BLO_read_struct(reader, CurveMapping, &brush->curve_auto_smooth);
435 if (brush->curve_auto_smooth) {
436 BKE_curvemapping_blend_read(reader, brush->curve_auto_smooth);
437 }
438 else {
439 brush->curve_auto_smooth = BKE_paint_default_curve_inverted();
440 }
441
442 BLO_read_struct(reader, CurveMapping, &brush->curve_spacing);
443 if (brush->curve_spacing) {
444 BKE_curvemapping_blend_read(reader, brush->curve_spacing);
445 }
446 else {
447 brush->curve_spacing = BKE_paint_default_curve();
448 }
449
450 /* grease pencil */
451 BLO_read_struct(reader, BrushGpencilSettings, &brush->gpencil_settings);
452 if (brush->gpencil_settings != nullptr) {
453 BLO_read_struct(reader, CurveMapping, &brush->gpencil_settings->curve_sensitivity);
454 BLO_read_struct(reader, CurveMapping, &brush->gpencil_settings->curve_strength);
455 BLO_read_struct(reader, CurveMapping, &brush->gpencil_settings->curve_jitter);
456
457 BLO_read_struct(reader, CurveMapping, &brush->gpencil_settings->curve_rand_pressure);
458 BLO_read_struct(reader, CurveMapping, &brush->gpencil_settings->curve_rand_strength);
459 BLO_read_struct(reader, CurveMapping, &brush->gpencil_settings->curve_rand_uv);
460 BLO_read_struct(reader, CurveMapping, &brush->gpencil_settings->curve_rand_hue);
461 BLO_read_struct(reader, CurveMapping, &brush->gpencil_settings->curve_rand_saturation);
462 BLO_read_struct(reader, CurveMapping, &brush->gpencil_settings->curve_rand_value);
463
464 if (brush->gpencil_settings->curve_sensitivity) {
465 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_sensitivity);
466 }
467
468 if (brush->gpencil_settings->curve_strength) {
469 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_strength);
470 }
471
472 if (brush->gpencil_settings->curve_jitter) {
473 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_jitter);
474 }
475
476 if (brush->gpencil_settings->curve_rand_pressure) {
477 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_pressure);
478 }
479
480 if (brush->gpencil_settings->curve_rand_strength) {
481 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_strength);
482 }
483
484 if (brush->gpencil_settings->curve_rand_uv) {
485 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_uv);
486 }
487
488 if (brush->gpencil_settings->curve_rand_hue) {
489 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_hue);
490 }
491
492 if (brush->gpencil_settings->curve_rand_saturation) {
493 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_saturation);
494 }
495
496 if (brush->gpencil_settings->curve_rand_value) {
497 BKE_curvemapping_blend_read(reader, brush->gpencil_settings->curve_rand_value);
498 }
499 }
500
501 BLO_read_struct(reader, BrushCurvesSculptSettings, &brush->curves_sculpt_settings);
502 if (brush->curves_sculpt_settings) {
503 BLO_read_struct(reader, CurveMapping, &brush->curves_sculpt_settings->curve_parameter_falloff);
504 if (brush->curves_sculpt_settings->curve_parameter_falloff) {
505 BKE_curvemapping_blend_read(reader, brush->curves_sculpt_settings->curve_parameter_falloff);
506 }
507 }
508
509 BLO_read_struct(reader, MeshAutomaskingSettings, &brush->mesh_automasking_settings);
510 if (brush->mesh_automasking_settings) {
511 BLO_read_struct(reader, CurveMapping, &brush->mesh_automasking_settings->cavity_curve);
512 if (brush->mesh_automasking_settings->cavity_curve) {
513 BKE_curvemapping_blend_read(reader, brush->mesh_automasking_settings->cavity_curve);
514 }
515
516 /* The "operator" level curve is never used on the brush, ensure it is nullptr */
517 brush->mesh_automasking_settings->cavity_curve_op = nullptr;
518 }
519
520 BLO_read_struct(reader, PreviewImage, &brush->preview);
521 BKE_previewimg_blend_read(reader, brush->preview);
522
523 brush->has_unsaved_changes = false;
524}
525
527{
528 Brush *brush = reinterpret_cast<Brush *>(id);
529
530 /* Update brush settings depending on availability of other IDs. */
531 if (brush->gpencil_settings != nullptr) {
532 if (brush->gpencil_settings->flag & GP_BRUSH_MATERIAL_PINNED) {
533 if (!brush->gpencil_settings->material) {
534 brush->gpencil_settings->flag &= ~GP_BRUSH_MATERIAL_PINNED;
535 }
536 }
537 else {
538 brush->gpencil_settings->material = nullptr;
539 }
540 }
541}
542
543static void brush_asset_metadata_ensure(void *asset_ptr, AssetMetaData *asset_data)
544{
545 using namespace blender::bke;
546
547 Brush *brush = reinterpret_cast<Brush *>(asset_ptr);
548 BLI_assert(GS(brush->id.name) == ID_BR);
549
550 /* Most names copied from brush RNA (not all are available there though). */
551 constexpr std::array mode_map{
552 std::tuple{"use_paint_sculpt", OB_MODE_SCULPT, "sculpt_brush_type"},
553 std::tuple{"use_paint_vertex", OB_MODE_VERTEX_PAINT, "vertex_brush_type"},
554 std::tuple{"use_paint_weight", OB_MODE_WEIGHT_PAINT, "weight_brush_type"},
555 std::tuple{"use_paint_image", OB_MODE_TEXTURE_PAINT, "image_brush_type"},
556 /* Sculpt UVs in the image editor while in edit mode. */
557 std::tuple{"use_paint_uv_sculpt", OB_MODE_EDIT, "image_brush_type"},
558 std::tuple{"use_paint_grease_pencil", OB_MODE_PAINT_GREASE_PENCIL, "gpencil_brush_type"},
559 /* Note: Not defined in brush RNA, own name. */
560 std::tuple{
561 "use_sculpt_grease_pencil", OB_MODE_SCULPT_GREASE_PENCIL, "gpencil_sculpt_brush_type"},
562 std::tuple{
563 "use_vertex_grease_pencil", OB_MODE_VERTEX_GREASE_PENCIL, "gpencil_vertex_brush_type"},
564 std::tuple{"use_weight_gpencil", OB_MODE_WEIGHT_GREASE_PENCIL, "gpencil_weight_brush_type"},
565 std::tuple{"use_paint_sculpt_curves", OB_MODE_SCULPT_CURVES, "curves_sculpt_brush_type"},
566 };
567
568 for (const auto &[prop_name, mode, tool_prop_name] : mode_map) {
569 /* Only add booleans for supported modes. */
570 if (!(brush->ob_mode & mode)) {
571 continue;
572 }
573 auto mode_property = idprop::create_bool(prop_name, true);
574 BKE_asset_metadata_idprop_ensure(asset_data, mode_property.release());
575
576 if (std::optional<int> brush_tool = BKE_paint_get_brush_type_from_obmode(brush, mode)) {
577 auto type_property = idprop::create(tool_prop_name, *brush_tool);
578 BKE_asset_metadata_idprop_ensure(asset_data, type_property.release());
579 }
580 else {
582 }
583 }
584}
585
587 /*pre_save_fn*/ brush_asset_metadata_ensure,
588 /*on_mark_asset_fn*/ brush_asset_metadata_ensure,
589};
590
592 .id_code = Brush::id_type,
593 .id_filter = FILTER_ID_BR,
594 .dependencies_id_types = (FILTER_ID_IM | FILTER_ID_PC | FILTER_ID_TE | FILTER_ID_MA),
595 .main_listbase_index = INDEX_ID_BR,
596 .struct_size = sizeof(Brush),
597 .name = "Brush",
598 .name_plural = N_("brushes"),
599 .translation_context = BLT_I18NCONTEXT_ID_BRUSH,
601 .asset_type_info = &AssetType_BR,
602
603 .init_data = brush_init_data,
604 .copy_data = brush_copy_data,
605 .free_data = brush_free_data,
606 .make_local = brush_make_local,
607 .foreach_id = brush_foreach_id,
608 .foreach_cache = nullptr,
609 .foreach_path = nullptr,
610 .foreach_working_space_color = brush_foreach_working_space_color,
611 .foreach_asset_weak_reference = nullptr,
612 .owner_pointer_get = nullptr,
613
614 .blend_write = brush_blend_write,
615 .blend_read_data = brush_blend_read_data,
616 .blend_read_after_liblink = brush_blend_read_after_liblink,
617
618 .blend_read_undo_preserve = nullptr,
619
620 .lib_override_apply_post = nullptr,
621};
622
624
626{
628 BLI_rng_srandom(brush_rng, 31415682);
629}
630
632{
633 if (brush_rng == nullptr) {
634 return;
635 }
637 brush_rng = nullptr;
638}
639
641{
642 const Brush brush_def = {};
643
644#define FROM_DEFAULT(member) \
645 memcpy((void *)&brush->member, (void *)&brush_def.member, sizeof(brush->member))
646#define FROM_DEFAULT_PTR(member) memcpy(brush->member, brush_def.member, sizeof(brush->member))
647
648 FROM_DEFAULT(blend);
649 FROM_DEFAULT(flag);
650 FROM_DEFAULT(weight);
651 FROM_DEFAULT(size);
652 FROM_DEFAULT(alpha);
653 FROM_DEFAULT(hardness);
654 FROM_DEFAULT(autosmooth_factor);
655 FROM_DEFAULT(topology_rake_factor);
656 FROM_DEFAULT(crease_pinch_factor);
657 FROM_DEFAULT(normal_radius_factor);
658 FROM_DEFAULT(wet_paint_radius_factor);
659 FROM_DEFAULT(area_radius_factor);
660 FROM_DEFAULT(disconnected_distance_max);
661 FROM_DEFAULT(sculpt_plane);
662 FROM_DEFAULT(plane_offset);
663 FROM_DEFAULT(normal_weight);
664 FROM_DEFAULT(fill_threshold);
665 FROM_DEFAULT(flag);
666 FROM_DEFAULT(sampling_flag);
668 FROM_DEFAULT_PTR(secondary_color);
669 FROM_DEFAULT(spacing);
670 FROM_DEFAULT(smooth_stroke_radius);
671 FROM_DEFAULT(smooth_stroke_factor);
672 FROM_DEFAULT(rate);
673 FROM_DEFAULT(jitter);
674 FROM_DEFAULT(texture_sample_bias);
675 FROM_DEFAULT(texture_overlay_alpha);
676 FROM_DEFAULT(mask_overlay_alpha);
677 FROM_DEFAULT(cursor_overlay_alpha);
678 FROM_DEFAULT(overlay_flags);
679 FROM_DEFAULT_PTR(add_col);
680 FROM_DEFAULT_PTR(sub_col);
681 FROM_DEFAULT(stencil_pos);
682 FROM_DEFAULT(stencil_dimension);
683 FROM_DEFAULT(mtex);
684 FROM_DEFAULT(mask_mtex);
685 FROM_DEFAULT(falloff_shape);
686 FROM_DEFAULT(tip_scale_x);
687 FROM_DEFAULT(tip_roundness);
688
689#undef FROM_DEFAULT
690#undef FROM_DEFAULT_PTR
691}
692
693/* Datablock add/copy/free/make_local */
694
695Brush *BKE_brush_add(Main *bmain, const char *name, const eObjectMode ob_mode)
696{
697 Brush *brush = BKE_id_new<Brush>(bmain, name);
698
699 brush->ob_mode = ob_mode;
700
701 if (ob_mode == OB_MODE_SCULPT_CURVES) {
703 }
704 else if (ELEM(ob_mode,
709 {
711 }
714 }
715
716 return brush;
717}
718
720{
721 if (brush->gpencil_settings == nullptr) {
722 brush->gpencil_settings = MEM_new<BrushGpencilSettings>("BrushGpencilSettings");
723 }
724
725 brush->gpencil_settings->draw_smoothlvl = 1;
726 brush->gpencil_settings->flag = eGPDbrush_Flag{};
727 brush->gpencil_settings->flag |= GP_BRUSH_USE_PRESSURE;
728 brush->gpencil_settings->draw_strength = 1.0f;
729 brush->gpencil_settings->draw_jitter = 0.0f;
730 brush->gpencil_settings->flag |= GP_BRUSH_USE_JITTER_PRESSURE;
731
732 /* curves */
733 brush->gpencil_settings->curve_sensitivity = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
734 brush->gpencil_settings->curve_strength = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
735 brush->gpencil_settings->curve_jitter = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
736
737 brush->gpencil_settings->curve_rand_pressure = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
738 brush->gpencil_settings->curve_rand_strength = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
739 brush->gpencil_settings->curve_rand_uv = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
740 brush->gpencil_settings->curve_rand_hue = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
741 brush->gpencil_settings->curve_rand_saturation = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
742 brush->gpencil_settings->curve_rand_value = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
743}
744
746{
747 if (brush->id.tag & ID_TAG_INDIRECT) {
748 return false;
749 }
750 if (ID_REAL_USERS(brush) <= 1 && ID_EXTRA_USERS(brush) == 0 &&
752 {
753 return false;
754 }
755
756 BKE_id_delete(bmain, brush);
757
758 return true;
759}
760
762 Brush *brush,
763 eDupli_ID_Flags /*dupflag*/,
764 /*eLibIDDuplicateFlags*/ uint duplicate_options)
765{
766 const bool is_subprocess = (duplicate_options & LIB_ID_DUPLICATE_IS_SUBPROCESS) != 0;
767 const bool is_root_id = (duplicate_options & LIB_ID_DUPLICATE_IS_ROOT_ID) != 0;
768
770
771 if (!is_subprocess) {
773 }
774 if (is_root_id) {
775 duplicate_options &= ~LIB_ID_DUPLICATE_IS_ROOT_ID;
776 }
777
778 constexpr int id_copy_flag = LIB_ID_COPY_DEFAULT;
779
780 Brush *new_brush = reinterpret_cast<Brush *>(
781 BKE_id_copy_for_duplicate(bmain, &brush->id, dupflag, id_copy_flag));
782
783 /* Currently this duplicates everything and the passed in value of `dupflag` is ignored. Ideally,
784 * this should both check user preferences and do further filtering based on eDupli_ID_Flags. */
785 auto dependencies_cb = [&](const LibraryIDLinkCallbackData *cb_data) -> int {
786 if (cb_data->cb_flag & (IDWALK_CB_EMBEDDED | IDWALK_CB_EMBEDDED_NOT_OWNING)) {
787 return IDWALK_NOP;
788 }
789 if (cb_data->cb_flag & IDWALK_CB_LOOPBACK) {
790 return IDWALK_NOP;
791 }
792
793 BKE_id_copy_for_duplicate(bmain, *cb_data->id_pointer, dupflag, id_copy_flag);
794 return IDWALK_NOP;
795 };
796
797 BKE_library_foreach_ID_link(bmain, &new_brush->id, dependencies_cb, nullptr, IDWALK_RECURSE);
798
799 if (!is_subprocess) {
800 /* This code will follow into all ID links using an ID tagged with ID_TAG_NEW. */
802
803#ifndef NDEBUG
804 /* Call to `BKE_libblock_relink_to_newid` above is supposed to have cleared all those flags. */
805 ID *id_iter;
806 FOREACH_MAIN_ID_BEGIN (bmain, id_iter) {
807 BLI_assert((id_iter->tag & ID_TAG_NEW) == 0);
808 }
810#endif
811
812 /* Cleanup. */
814 }
815
816 return new_brush;
817}
818
820{
821 if (brush->mesh_automasking_settings == nullptr) {
822 brush->mesh_automasking_settings = MEM_new<MeshAutomaskingSettings>(__func__);
823 brush->mesh_automasking_settings->cavity_curve = BKE_paint_default_curve();
824 }
825}
826
828{
829 if (brush->curves_sculpt_settings == nullptr) {
830 brush->curves_sculpt_settings = MEM_new<BrushCurvesSculptSettings>(__func__);
831 }
832 BrushCurvesSculptSettings *settings = brush->curves_sculpt_settings;
834 settings->add_amount = 1;
835 settings->points_per_curve = 8;
836 settings->minimum_length = 0.01f;
837 settings->curve_length = 0.3f;
838 settings->curve_radius = 0.01f;
839 settings->density_add_attempts = 100;
840 settings->curve_parameter_falloff = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
841}
842
844{
845 if (brush && ID_IS_LINKED(brush)) {
846 brush->has_unsaved_changes = true;
847 }
848}
849
851{
852 /* create a fake brush and set it to the defaults */
854 brush_defaults(&def);
855
856#define BR_TEST(field, t) \
857 if (br->field != def.field) { \
858 printf("br->" #field " = %" #t ";\n", br->field); \
859 } \
860 ((void)0)
861
862#define BR_TEST_FLAG(_f) \
863 if ((br->flag & _f) && !(def.flag & _f)) { \
864 printf("br->flag |= " #_f ";\n"); \
865 } \
866 else if (!(br->flag & _f) && (def.flag & _f)) { \
867 printf("br->flag &= ~" #_f ";\n"); \
868 } \
869 ((void)0)
870
871#define BR_TEST_FLAG_OVERLAY(_f) \
872 if ((br->overlay_flags & _f) && !(def.overlay_flags & _f)) { \
873 printf("br->overlay_flags |= " #_f ";\n"); \
874 } \
875 else if (!(br->overlay_flags & _f) && (def.overlay_flags & _f)) { \
876 printf("br->overlay_flags &= ~" #_f ";\n"); \
877 } \
878 ((void)0)
879
880 /* print out any non-default brush state */
881 BR_TEST(normal_weight, f);
882
883 BR_TEST(blend, d);
884 BR_TEST(size, d);
885
886 /* br->flag */
905
912
913 BR_TEST(jitter, f);
914 BR_TEST(spacing, d);
915 BR_TEST(smooth_stroke_radius, d);
916 BR_TEST(smooth_stroke_factor, f);
917 BR_TEST(rate, f);
918
919 BR_TEST(alpha, f);
920
921 BR_TEST(sculpt_plane, d);
922
923 BR_TEST(plane_offset, f);
924
925 BR_TEST(autosmooth_factor, f);
926
927 BR_TEST(topology_rake_factor, f);
928
929 BR_TEST(crease_pinch_factor, f);
930
931 BR_TEST(plane_trim, f);
932
933 BR_TEST(texture_sample_bias, f);
934 BR_TEST(texture_overlay_alpha, d);
935
936 BR_TEST(add_col[0], f);
937 BR_TEST(add_col[1], f);
938 BR_TEST(add_col[2], f);
939 BR_TEST(add_col[3], f);
940 BR_TEST(sub_col[0], f);
941 BR_TEST(sub_col[1], f);
942 BR_TEST(sub_col[2], f);
943 BR_TEST(sub_col[3], f);
944
945 printf("\n");
946
947#undef BR_TEST
948#undef BR_TEST_FLAG
949}
950
952{
953 CurveMapping *cumap = nullptr;
954 CurveMap *cuma = nullptr;
955
956 if (!b->curve_distance_falloff) {
957 b->curve_distance_falloff = BKE_curvemapping_add(1, 0, 0, 1, 1);
958 }
959 cumap = b->curve_distance_falloff;
961 cumap->preset = preset;
962
963 cuma = b->curve_distance_falloff->cm;
965 BKE_curvemapping_changed(cumap, false);
967}
968
969const MTex *BKE_brush_mask_texture_get(const Brush *brush, const PaintMode paint_mode)
970{
971 if (ELEM(paint_mode, PaintMode::Sculpt, PaintMode::Vertex)) {
972 return &brush->mtex;
973 }
974 return &brush->mask_mtex;
975}
976
977const MTex *BKE_brush_color_texture_get(const Brush *brush, const PaintMode paint_mode)
978{
979 if (ELEM(paint_mode, PaintMode::Sculpt, PaintMode::Vertex)) {
980 return &brush->mask_mtex;
981 }
982 return &brush->mtex;
983}
984
986 const Brush *br,
987 const MTex *mtex,
988 const float3 &point,
989 float4 &rgba,
990 const int thread,
991 ImagePool *pool)
992{
993 const bke::PaintRuntime *paint_runtime = paint->runtime;
994 float intensity = 1.0;
995 bool hasrgb = false;
996
997 if (mtex == nullptr || mtex->tex == nullptr) {
998 intensity = 1;
999 }
1000 else if (mtex->brush_map_mode == MTEX_MAP_MODE_3D) {
1001 /* Get strength by feeding the vertex
1002 * location directly into a texture */
1003 hasrgb = RE_texture_evaluate(mtex, point, thread, pool, false, false, &intensity, rgba);
1004 }
1005 else if (mtex->brush_map_mode == MTEX_MAP_MODE_STENCIL) {
1006 float rotation = -mtex->rot;
1007 const float2 point_2d = point.xy();
1008 float x, y;
1009
1010 x = point_2d[0] - br->stencil_pos[0];
1011 y = point_2d[1] - br->stencil_pos[1];
1012
1013 if (rotation > 0.001f || rotation < -0.001f) {
1014 const float angle = atan2f(y, x) + rotation;
1015 const float flen = sqrtf(x * x + y * y);
1016
1017 x = flen * cosf(angle);
1018 y = flen * sinf(angle);
1019 }
1020
1021 if (fabsf(x) > br->stencil_dimension[0] || fabsf(y) > br->stencil_dimension[1]) {
1022 zero_v4(rgba);
1023 return 0.0f;
1024 }
1025 x /= (br->stencil_dimension[0]);
1026 y /= (br->stencil_dimension[1]);
1027
1028 float3 co(x, y, 0.0f);
1029 hasrgb = RE_texture_evaluate(mtex, co, thread, pool, false, false, &intensity, rgba);
1030 }
1031 else {
1032 float rotation = -mtex->rot;
1033 const float2 point_2d = point.xy();
1034 float x = 0.0f, y = 0.0f; /* Quite warnings */
1035 float invradius = 1.0f; /* Quite warnings */
1036
1037 if (mtex->brush_map_mode == MTEX_MAP_MODE_VIEW) {
1038 /* keep coordinates relative to mouse */
1039
1040 rotation -= paint_runtime->brush_rotation;
1041
1042 x = point_2d[0] - paint_runtime->tex_mouse[0];
1043 y = point_2d[1] - paint_runtime->tex_mouse[1];
1044
1045 /* use pressure adjusted size for fixed mode */
1046 invradius = 1.0f / paint_runtime->pixel_radius;
1047 }
1048 else if (mtex->brush_map_mode == MTEX_MAP_MODE_TILED) {
1049 /* leave the coordinates relative to the screen */
1050
1051 /* use unadjusted size for tiled mode */
1052 invradius = 1.0f / paint_runtime->start_pixel_radius;
1053
1054 x = point_2d[0];
1055 y = point_2d[1];
1056 }
1057 else if (mtex->brush_map_mode == MTEX_MAP_MODE_RANDOM) {
1058 rotation -= paint_runtime->brush_rotation;
1059 /* these contain a random coordinate */
1060 x = point_2d[0] - paint_runtime->tex_mouse[0];
1061 y = point_2d[1] - paint_runtime->tex_mouse[1];
1062
1063 invradius = 1.0f / paint_runtime->pixel_radius;
1064 }
1065
1066 x *= invradius;
1067 y *= invradius;
1068
1069 /* it is probably worth optimizing for those cases where
1070 * the texture is not rotated by skipping the calls to
1071 * atan2, sqrtf, sin, and cos. */
1072 if (rotation > 0.001f || rotation < -0.001f) {
1073 const float angle = atan2f(y, x) + rotation;
1074 const float flen = sqrtf(x * x + y * y);
1075
1076 x = flen * cosf(angle);
1077 y = flen * sinf(angle);
1078 }
1079
1080 float3 co(x, y, 0.0f);
1081
1082 hasrgb = RE_texture_evaluate(mtex, co, thread, pool, false, false, &intensity, rgba);
1083 }
1084
1085 intensity += br->texture_sample_bias;
1086
1087 if (!hasrgb) {
1088 rgba[0] = intensity;
1089 rgba[1] = intensity;
1090 rgba[2] = intensity;
1091 rgba[3] = 1.0f;
1092 }
1093 /* For consistency, sampling always returns color in linear space */
1094 else if (paint_runtime->do_linear_conversion) {
1096 }
1097
1098 return intensity;
1099}
1100
1102 const Paint *paint, Brush *br, const float2 &point, const int thread, ImagePool *pool)
1103{
1104 const bke::PaintRuntime *paint_runtime = paint->runtime;
1105 MTex *mtex = &br->mask_mtex;
1106 float intensity;
1107 float4 dummy_rgba;
1108
1109 if (!mtex->tex) {
1110 return 1.0f;
1111 }
1113 float rotation = -mtex->rot;
1114 const float2 point_2d = point;
1115 float x, y;
1116 float co[3];
1117
1118 x = point_2d[0] - br->mask_stencil_pos[0];
1119 y = point_2d[1] - br->mask_stencil_pos[1];
1120
1121 if (rotation > 0.001f || rotation < -0.001f) {
1122 const float angle = atan2f(y, x) + rotation;
1123 const float flen = sqrtf(x * x + y * y);
1124
1125 x = flen * cosf(angle);
1126 y = flen * sinf(angle);
1127 }
1128
1129 if (fabsf(x) > br->mask_stencil_dimension[0] || fabsf(y) > br->mask_stencil_dimension[1]) {
1130 zero_v4(dummy_rgba);
1131 return 0.0f;
1132 }
1133 x /= (br->mask_stencil_dimension[0]);
1134 y /= (br->mask_stencil_dimension[1]);
1135
1136 co[0] = x;
1137 co[1] = y;
1138 co[2] = 0.0f;
1139
1140 RE_texture_evaluate(mtex, co, thread, pool, false, false, &intensity, dummy_rgba);
1141 }
1142 else {
1143 float rotation = -mtex->rot;
1144 const float2 point_2d = point;
1145 float x = 0.0f, y = 0.0f; /* Quite warnings */
1146 float invradius = 1.0f; /* Quite warnings */
1147 float co[3];
1148
1149 if (mtex->brush_map_mode == MTEX_MAP_MODE_VIEW) {
1150 /* keep coordinates relative to mouse */
1151
1152 rotation -= paint_runtime->brush_rotation_sec;
1153
1154 x = point_2d[0] - paint_runtime->mask_tex_mouse[0];
1155 y = point_2d[1] - paint_runtime->mask_tex_mouse[1];
1156
1157 /* use pressure adjusted size for fixed mode */
1158 invradius = 1.0f / paint_runtime->pixel_radius;
1159 }
1160 else if (mtex->brush_map_mode == MTEX_MAP_MODE_TILED) {
1161 /* leave the coordinates relative to the screen */
1162
1163 /* use unadjusted size for tiled mode */
1164 invradius = 1.0f / paint_runtime->start_pixel_radius;
1165
1166 x = point_2d[0];
1167 y = point_2d[1];
1168 }
1169 else if (mtex->brush_map_mode == MTEX_MAP_MODE_RANDOM) {
1170 rotation -= paint_runtime->brush_rotation_sec;
1171 /* these contain a random coordinate */
1172 x = point_2d[0] - paint_runtime->mask_tex_mouse[0];
1173 y = point_2d[1] - paint_runtime->mask_tex_mouse[1];
1174
1175 invradius = 1.0f / paint_runtime->pixel_radius;
1176 }
1177
1178 x *= invradius;
1179 y *= invradius;
1180
1181 /* it is probably worth optimizing for those cases where
1182 * the texture is not rotated by skipping the calls to
1183 * atan2, sqrtf, sin, and cos. */
1184 if (rotation > 0.001f || rotation < -0.001f) {
1185 const float angle = atan2f(y, x) + rotation;
1186 const float flen = sqrtf(x * x + y * y);
1187
1188 x = flen * cosf(angle);
1189 y = flen * sinf(angle);
1190 }
1191
1192 co[0] = x;
1193 co[1] = y;
1194 co[2] = 0.0f;
1195
1196 RE_texture_evaluate(mtex, co, thread, pool, false, false, &intensity, dummy_rgba);
1197 }
1198
1199 CLAMP(intensity, 0.0f, 1.0f);
1200
1201 switch (br->mask_pressure) {
1203 intensity = ((1.0f - intensity) < paint_runtime->size_pressure_value) ? 1.0f : 0.0f;
1204 break;
1206 intensity = paint_runtime->size_pressure_value +
1207 intensity * (1.0f - paint_runtime->size_pressure_value);
1208 break;
1209 default:
1210 break;
1211 }
1212
1213 return intensity;
1214}
1215
1216/* -------------------------------------------------------------------- */
1219
1220bool BKE_brush_use_unified_size(const Paint * /*paint*/, const Brush *brush)
1221{
1222 /* In the case of having no active brush (e.g. for non-brush tools), default to the scene level
1223 * settings */
1224 if (!brush) {
1225 return true;
1226 }
1227
1228 return brush->unified_paint_flags & BRUSH_USE_UNIFIED_PAINT_SIZE;
1229}
1230
1231bool BKE_brush_use_unified_strength(const Paint * /*paint*/, const Brush *brush)
1232{
1233 /* In the case of having no active brush (e.g. for non-brush tools), default to the scene level
1234 * settings */
1235 if (!brush) {
1236 return true;
1237 }
1238
1239 return brush->unified_paint_flags & BRUSH_USE_UNIFIED_PAINT_ALPHA;
1240}
1241
1242bool BKE_brush_use_unified_color(const Paint * /*paint*/, const Brush *brush)
1243{
1244 /* In the case of having no active brush (e.g. for non-brush tools), default to the scene level
1245 * settings */
1246 if (!brush) {
1247 return true;
1248 }
1249
1250 return brush->unified_paint_flags & BRUSH_USE_UNIFIED_PAINT_COLOR;
1251}
1252
1254{
1256 return paint->unified_paint_settings.color;
1257 }
1258 return brush->color;
1259}
1260
1262std::optional<BrushColorJitterSettings> BKE_brush_color_jitter_get_settings(const Paint *paint,
1263 const Brush *brush)
1264{
1266 if ((paint->unified_paint_settings.flag & UNIFIED_PAINT_COLOR_JITTER) == 0) {
1267 return std::nullopt;
1268 }
1269
1270 const UnifiedPaintSettings &settings = paint->unified_paint_settings;
1272 settings.color_jitter_flag,
1273 settings.hsv_jitter[0],
1274 settings.hsv_jitter[1],
1275 settings.hsv_jitter[2],
1276 settings.curve_rand_hue,
1277 settings.curve_rand_saturation,
1278 settings.curve_rand_value,
1279 };
1280 }
1281
1282 if ((brush->flag2 & BRUSH_JITTER_COLOR) == 0) {
1283 return std::nullopt;
1284 }
1285
1287 brush->color_jitter_flag,
1288 brush->hsv_jitter[0],
1289 brush->hsv_jitter[1],
1290 brush->hsv_jitter[2],
1291 brush->curve_rand_hue,
1292 brush->curve_rand_saturation,
1293 brush->curve_rand_value,
1294 };
1295}
1296
1298{
1300 return paint->unified_paint_settings.secondary_color;
1301 }
1302 return brush->secondary_color;
1303}
1304
1306{
1308 UnifiedPaintSettings *ups = &paint->unified_paint_settings;
1309 copy_v3_v3(ups->color, color);
1311 }
1312 else {
1313 copy_v3_v3(brush->color, color);
1316 }
1317}
1318
1320{
1321 /* For forward compatibility. */
1322 linearrgb_to_srgb_v3_v3(brush->rgb, brush->color);
1323 linearrgb_to_srgb_v3_v3(brush->secondary_rgb, brush->secondary_color);
1324}
1325
1327{
1328 /* For forward compatibility. */
1329 linearrgb_to_srgb_v3_v3(ups->rgb, ups->color);
1331}
1332
1333/* Be careful about setting size and unprojected size because they depend on one another these
1334 * functions do not set the other corresponding value this can lead to odd behavior if size and
1335 * unprojected radius become inconsistent. The biggest problem is that it isn't possible to change
1336 * unprojected radius because a view context is not available. My usual solution to this is to use
1337 * the ratio of change of the size to change the unprojected radius. Not completely convinced that
1338 * is correct. In any case, a better solution is needed to prevent inconsistency. */
1339
1341{
1342 UnifiedPaintSettings *ups = &paint->unified_paint_settings;
1343
1344 /* make sure range is sane */
1346
1348 ups->size = size;
1349 }
1350 else {
1351 brush->size = size;
1353 }
1354}
1355
1357{
1358 const UnifiedPaintSettings *ups = &paint->unified_paint_settings;
1359
1361 return ups->size;
1362 }
1363 return brush->size;
1364}
1365
1367{
1368 return BKE_brush_size_get(paint, brush) / 2.0f;
1369}
1370
1372{
1373 const short us_flag = paint->unified_paint_settings.flag;
1374
1375 return (brush->unified_paint_flags & BRUSH_USE_UNIFIED_PAINT_SIZE) ?
1376 (us_flag & UNIFIED_PAINT_BRUSH_LOCK_SIZE) != 0 :
1377 (brush->flag & BRUSH_LOCK_SIZE) != 0;
1378}
1379
1381{
1382 return brush->flag & BRUSH_SIZE_PRESSURE;
1383}
1384
1386{
1387 return brush->flag & BRUSH_ALPHA_PRESSURE;
1388}
1389
1390void BKE_brush_unprojected_size_set(Paint *paint, Brush *brush, float unprojected_size)
1391{
1392 UnifiedPaintSettings *ups = &paint->unified_paint_settings;
1393
1395 ups->unprojected_size = unprojected_size;
1396 }
1397 else {
1398 brush->unprojected_size = unprojected_size;
1400 }
1401}
1402
1404{
1405 const UnifiedPaintSettings *ups = &paint->unified_paint_settings;
1407 return ups->unprojected_size;
1408 }
1409 return brush->unprojected_size;
1410}
1411
1416
1417void BKE_brush_scale_unprojected_size(float *unprojected_size,
1418 int new_brush_size,
1419 int old_brush_size)
1420{
1421 float scale = new_brush_size;
1422 /* avoid division by zero */
1423 if (old_brush_size != 0) {
1424 scale /= float(old_brush_size);
1425 }
1426 (*unprojected_size) *= scale;
1427}
1428
1429void BKE_brush_scale_size(int *r_brush_size,
1430 float new_unprojected_size,
1431 float old_unprojected_size)
1432{
1433 float scale = new_unprojected_size;
1434 /* avoid division by zero */
1435 if (old_unprojected_size != 0) {
1436 scale /= new_unprojected_size;
1437 }
1438 (*r_brush_size) = int(float(*r_brush_size) * scale);
1439}
1440
1442{
1443 UnifiedPaintSettings *ups = &paint->unified_paint_settings;
1444
1446 ups->alpha = alpha;
1447 }
1448 else {
1449 brush->alpha = alpha;
1451 }
1452}
1453
1455{
1456 const UnifiedPaintSettings *ups = &paint->unified_paint_settings;
1457
1459 return ups->alpha;
1460 }
1461 return brush->alpha;
1462}
1463
1465{
1466 const UnifiedPaintSettings *ups = &paint->unified_paint_settings;
1467
1468 return (brush->unified_paint_flags & BRUSH_USE_UNIFIED_PAINT_WEIGHT) ? ups->weight :
1469 brush->weight;
1470}
1471
1473{
1474 UnifiedPaintSettings *ups = &paint->unified_paint_settings;
1475
1476 if (brush->unified_paint_flags & BRUSH_USE_UNIFIED_PAINT_WEIGHT) {
1477 ups->weight = value;
1478 }
1479 else {
1480 brush->weight = value;
1482 }
1483}
1484
1486{
1487 const UnifiedPaintSettings *ups = &paint->unified_paint_settings;
1488
1489 return (brush->unified_paint_flags & BRUSH_USE_UNIFIED_PAINT_INPUT_SAMPLES) ?
1490 ups->input_samples :
1491 brush->input_samples;
1492}
1493
1495{
1496 UnifiedPaintSettings *ups = &paint->unified_paint_settings;
1497
1498 if (brush->unified_paint_flags & BRUSH_USE_UNIFIED_PAINT_INPUT_SAMPLES) {
1499 ups->input_samples = value;
1500 }
1501 else {
1502 brush->input_samples = value;
1504 }
1505}
1506
1508
1510{
1511 float2 rand_pos;
1512 float spread;
1513 int diameter;
1514
1515 do {
1516 rand_pos[0] = BLI_rng_get_float(brush_rng) - 0.5f;
1517 rand_pos[1] = BLI_rng_get_float(brush_rng) - 0.5f;
1518 } while (len_squared_v2(rand_pos) > square_f(0.5f));
1519
1520 if (brush.flag & BRUSH_ABSOLUTE_JITTER) {
1521 diameter = 2 * brush.jitter_absolute;
1522 spread = 1.0;
1523 }
1524 else {
1525 diameter = 2 * BKE_brush_radius_get(&paint, &brush);
1526 spread = brush.jitter;
1527 }
1528 /* find random position within a circle of diameter 1 */
1529 return float2(pos[0] + 2 * rand_pos[0] * diameter * spread,
1530 pos[1] + 2 * rand_pos[1] * diameter * spread);
1531}
1532
1534{
1535 bke::PaintRuntime &paint_runtime = *paint->runtime;
1536 /* we multiply with brush radius as an optimization for the brush
1537 * texture sampling functions */
1538 if (mask) {
1539 paint_runtime.mask_tex_mouse[0] = BLI_rng_get_float(brush_rng) * paint_runtime.pixel_radius;
1540 paint_runtime.mask_tex_mouse[1] = BLI_rng_get_float(brush_rng) * paint_runtime.pixel_radius;
1541 }
1542 else {
1543 paint_runtime.tex_mouse[0] = BLI_rng_get_float(brush_rng) * paint_runtime.pixel_radius;
1544 paint_runtime.tex_mouse[1] = BLI_rng_get_float(brush_rng) * paint_runtime.pixel_radius;
1545 }
1546}
1547
1548namespace bke::brush {
1550{
1551 BKE_curvemapping_init(brush.curve_size);
1552 BKE_curvemapping_init(brush.curve_strength);
1553 BKE_curvemapping_init(brush.curve_jitter);
1554 BKE_curvemapping_init(brush.curve_hardness);
1555 BKE_curvemapping_init(brush.curve_auto_smooth);
1556 BKE_curvemapping_init(brush.curve_distance_falloff);
1557 BKE_curvemapping_init(brush.curve_spacing);
1558}
1559} // namespace bke::brush
1560
1562 const CurveMapping *cumap,
1563 const Span<float> distances,
1564 const float brush_radius,
1565 const MutableSpan<float> factors)
1566{
1568 BLI_assert(factors.size() == distances.size());
1569
1570 const float radius_rcp = math::rcp(brush_radius);
1571 switch (preset) {
1572 case BRUSH_CURVE_CUSTOM: {
1573 for (const int i : distances.index_range()) {
1574 const float distance = distances[i];
1575 if (distance >= brush_radius) {
1576 factors[i] = 0.0f;
1577 continue;
1578 }
1579 factors[i] *= BKE_curvemapping_evaluateF(cumap, 0, distance * radius_rcp);
1580 }
1581 break;
1582 }
1583 case BRUSH_CURVE_SHARP: {
1584 for (const int i : distances.index_range()) {
1585 const float distance = distances[i];
1586 if (distance >= brush_radius) {
1587 factors[i] = 0.0f;
1588 continue;
1589 }
1590 const float factor = 1.0f - distance * radius_rcp;
1591 factors[i] *= factor * factor;
1592 }
1593 break;
1594 }
1595 case BRUSH_CURVE_SMOOTH: {
1596 for (const int i : distances.index_range()) {
1597 const float distance = distances[i];
1598 if (distance >= brush_radius) {
1599 factors[i] = 0.0f;
1600 continue;
1601 }
1602 const float factor = 1.0f - distance * radius_rcp;
1603 factors[i] *= 3.0f * factor * factor - 2.0f * factor * factor * factor;
1604 }
1605 break;
1606 }
1607 case BRUSH_CURVE_SMOOTHER: {
1608 for (const int i : distances.index_range()) {
1609 const float distance = distances[i];
1610 if (distance >= brush_radius) {
1611 factors[i] = 0.0f;
1612 continue;
1613 }
1614 const float factor = 1.0f - distance * radius_rcp;
1615 factors[i] *= pow3f(factor) * (factor * (factor * 6.0f - 15.0f) + 10.0f);
1616 }
1617 break;
1618 }
1619 case BRUSH_CURVE_ROOT: {
1620 for (const int i : distances.index_range()) {
1621 const float distance = distances[i];
1622 if (distance >= brush_radius) {
1623 factors[i] = 0.0f;
1624 continue;
1625 }
1626 const float factor = 1.0f - distance * radius_rcp;
1627 factors[i] *= sqrtf(factor);
1628 }
1629 break;
1630 }
1631 case BRUSH_CURVE_LIN: {
1632 for (const int i : distances.index_range()) {
1633 const float distance = distances[i];
1634 if (distance >= brush_radius) {
1635 factors[i] = 0.0f;
1636 continue;
1637 }
1638 const float factor = 1.0f - distance * radius_rcp;
1639 factors[i] *= factor;
1640 }
1641 break;
1642 }
1643 case BRUSH_CURVE_CONSTANT: {
1644 for (const int i : distances.index_range()) {
1645 const float distance = distances[i];
1646 if (distance >= brush_radius) {
1647 factors[i] = 0.0f;
1648 }
1649 }
1650 break;
1651 }
1652 case BRUSH_CURVE_SPHERE: {
1653 for (const int i : distances.index_range()) {
1654 const float distance = distances[i];
1655 if (distance >= brush_radius) {
1656 factors[i] = 0.0f;
1657 continue;
1658 }
1659 const float factor = 1.0f - distance * radius_rcp;
1660 factors[i] *= sqrtf(2 * factor - factor * factor);
1661 }
1662 break;
1663 }
1664 case BRUSH_CURVE_POW4: {
1665 for (const int i : distances.index_range()) {
1666 const float distance = distances[i];
1667 if (distance >= brush_radius) {
1668 factors[i] = 0.0f;
1669 continue;
1670 }
1671 const float factor = 1.0f - distance * radius_rcp;
1672 factors[i] *= factor * factor * factor * factor;
1673 }
1674 break;
1675 }
1676 case BRUSH_CURVE_INVSQUARE: {
1677 for (const int i : distances.index_range()) {
1678 const float distance = distances[i];
1679 if (distance >= brush_radius) {
1680 factors[i] = 0.0f;
1681 continue;
1682 }
1683 const float factor = 1.0f - distance * radius_rcp;
1684 factors[i] *= factor * (2.0f - factor);
1685 }
1686 break;
1687 }
1688 }
1689}
1690
1692 const CurveMapping *cumap,
1693 const float distance,
1694 const float brush_radius)
1695{
1696 BLI_assert(distance >= 0.0f);
1697 BLI_assert(brush_radius >= 0.0f);
1698
1699 float p = distance;
1700 float strength = 1.0f;
1701
1702 if (p >= brush_radius) {
1703 return 0;
1704 }
1705
1706 p = p / brush_radius;
1707 p = 1.0f - p;
1708
1709 switch (preset) {
1710 case BRUSH_CURVE_CUSTOM:
1711 strength = BKE_curvemapping_evaluateF(cumap, 0, 1.0f - p);
1712 break;
1713 case BRUSH_CURVE_SHARP:
1714 strength = p * p;
1715 break;
1716 case BRUSH_CURVE_SMOOTH:
1717 strength = 3.0f * p * p - 2.0f * p * p * p;
1718 break;
1720 strength = pow3f(p) * (p * (p * 6.0f - 15.0f) + 10.0f);
1721 break;
1722 case BRUSH_CURVE_ROOT:
1723 strength = sqrtf(p);
1724 break;
1725 case BRUSH_CURVE_LIN:
1726 strength = p;
1727 break;
1729 strength = 1.0f;
1730 break;
1731 case BRUSH_CURVE_SPHERE:
1732 strength = sqrtf(2 * p - p * p);
1733 break;
1734 case BRUSH_CURVE_POW4:
1735 strength = p * p * p * p;
1736 break;
1738 strength = p * (2.0f - p);
1739 break;
1740 }
1741
1742 return strength;
1743}
1744
1745float BKE_brush_curve_strength(const Brush *br, float p, const float len)
1746{
1749}
1750
1751float BKE_brush_curve_strength_clamped(const Brush *br, float p, const float len)
1752{
1753 float strength = BKE_brush_curve_strength(br, p, len);
1754
1755 CLAMP(strength, 0.0f, 1.0f);
1756
1757 return strength;
1758}
1759
1760/* TODO: should probably be unified with BrushPainter stuff? */
1761static bool brush_gen_texture(const Brush *br,
1762 const int side,
1763 const bool use_secondary,
1764 float *rect)
1765{
1766 const MTex *mtex = (use_secondary) ? &br->mask_mtex : &br->mtex;
1767 if (mtex->tex == nullptr) {
1768 return false;
1769 }
1770
1771 const float step = 2.0 / side;
1772 int ix, iy;
1773 float x, y;
1774
1775 /* Do normalized canonical view coords for texture. */
1776 for (y = -1.0, iy = 0; iy < side; iy++, y += step) {
1777 for (x = -1.0, ix = 0; ix < side; ix++, x += step) {
1778 const float co[3] = {x, y, 0.0f};
1779
1780 float intensity;
1781 float rgba_dummy[4];
1782 RE_texture_evaluate(mtex, co, 0, nullptr, false, false, &intensity, rgba_dummy);
1783
1784 rect[iy * side + ix] = intensity;
1785 }
1786 }
1787
1788 return true;
1789}
1790
1791ImBuf *BKE_brush_gen_radial_control_imbuf(Brush *br, bool secondary, bool display_gradient)
1792{
1793 int side = 512;
1794 int half = side / 2;
1795
1797
1798 ImBuf *im = IMB_allocImBuf(side, side, ImBufFlags::FloatData);
1799
1800 const bool have_texture = brush_gen_texture(br, side, secondary, im->float_data_for_write());
1801
1802 if (display_gradient || have_texture) {
1803 float *float_data = im->float_data_for_write();
1804 for (int i = 0; i < side; i++) {
1805 for (int j = 0; j < side; j++) {
1806 const float magn = sqrtf(pow2f(i - half) + pow2f(j - half));
1807 const float strength = BKE_brush_curve_strength_clamped(br, magn, half);
1808 float_data[i * side + j] = (have_texture) ? float_data[i * side + j] * strength : strength;
1809 }
1810 }
1811 }
1812
1813 return im;
1814}
1815
1817{
1818 switch (paint_mode) {
1819 case PaintMode::Sculpt: {
1820 if (brush->sculpt_brush_type == SCULPT_BRUSH_TYPE_MULTIPLANE_SCRAPE) {
1821 return true;
1822 }
1823
1825 (brush->tip_roundness < 1.0f || brush->tip_scale_x != 1.0f))
1826 {
1827 return true;
1828 }
1829
1830 break;
1831 }
1832 default: {
1833 break;
1834 }
1835 }
1836
1837 return false;
1838}
1839
1840namespace bke::brush {
1841float normal_weight_get(const Brush &brush, const bool invert)
1842{
1844 if (!invert) {
1845 return brush.normal_weight;
1846 }
1847
1848 return brush.normal_weight == 0.0f;
1849}
1851{
1852 switch (brush.image_brush_type) {
1855 return true;
1856 default:
1857 return false;
1858 }
1859}
1860} // namespace bke::brush
1861
1862/* -------------------------------------------------------------------- */
1865
1866namespace bke::brush {
1867static bool is_paint_tool(const Brush &brush)
1868{
1869 return ELEM(brush.sculpt_brush_type,
1873}
1874
1880static bool is_grab_tool(const Brush &brush)
1881{
1882 return (brush.sculpt_brush_type == SCULPT_BRUSH_TYPE_CLOTH &&
1883 brush.cloth_deform_type == BRUSH_CLOTH_DEFORM_GRAB) ||
1884 ELEM(brush.sculpt_brush_type,
1892}
1894{
1895 return !ELEM(brush.sculpt_brush_type,
1896 /* These brushes, as currently coded, cannot support dynamic topology */
1909
1910 /* These brushes could handle dynamic topology,
1911 * but user feedback indicates it's better not to */
1915}
1944{
1945 /* TODO: Should this support face sets...? */
1946 return !ELEM(brush.sculpt_brush_type, SCULPT_BRUSH_TYPE_MASK, SCULPT_BRUSH_TYPE_SMOOTH) &&
1948}
1950{
1951 /* TODO: This setting is closely tied to #supports_sculpt_plane, they should be merged in some
1952 * way. Update after initial commit to avoid confusing PRs. */
1953 return !ELEM(brush.sculpt_brush_type, SCULPT_BRUSH_TYPE_POSE);
1954}
1956{
1958}
1960{
1961 return brush.sculpt_brush_type != SCULPT_BRUSH_TYPE_POSE;
1962}
1964{
1965 return brush.sculpt_brush_type == SCULPT_BRUSH_TYPE_LAYER;
1966}
1968{
1969 return ELEM(brush.sculpt_brush_type, SCULPT_BRUSH_TYPE_PLANE);
1970}
1972{
1973 return ELEM(brush.sculpt_brush_type, SCULPT_BRUSH_TYPE_PLANE);
1974}
1976{
1977 return !(ELEM(brush.stroke_method, BRUSH_STROKE_ANCHORED, BRUSH_STROKE_DRAG_DOT)) &&
1979}
1988{
1989 return ELEM(brush.sculpt_brush_type, SCULPT_BRUSH_TYPE_SNAKE_HOOK);
1990}
1992{
1993 return ELEM(brush.sculpt_brush_type, SCULPT_BRUSH_TYPE_LAYER, SCULPT_BRUSH_TYPE_CLOTH);
1994}
1996{
1997 return ELEM(brush.sculpt_brush_type,
2001}
2011{
2012 return !is_grab_tool(brush);
2013}
2015{
2016 /* TODO: Should the face set brush be here...? */
2017 return !ELEM(brush.sculpt_brush_type,
2023}
2025{
2026 return ELEM(brush.sculpt_brush_type, SCULPT_BRUSH_TYPE_PAINT);
2027}
2044{
2045 return !(ELEM(brush.stroke_method,
2051}
2058{
2059 return !is_grab_tool(brush);
2060}
2062{
2063 return !is_grab_tool(brush);
2064}
2066{
2067 return !is_grab_tool(brush);
2068}
2070{
2071 return !is_grab_tool(brush);
2072}
2111} // namespace bke::brush
2112
2114
2115} // namespace blender
Low-level operations for grease pencil.
#define BKE_LIB_FOREACHID_PROCESS_FUNCTION_CALL(data_, func_call_)
#define BKE_LIB_FOREACHID_PROCESS_IDSUPER(data_, id_super_, cb_flag_)
#define FOREACH_MAIN_ID_END
Definition BKE_main.hh:735
#define FOREACH_MAIN_ID_BEGIN(_bmain, _id)
Definition BKE_main.hh:729
General operations, lookup, etc. for materials.
Random number functions.
#define BLO_read_struct(reader, struct_name, ptr_p)
#define BLT_I18NCONTEXT_ID_BRUSH
ID and Library types, which are fundamental for SDNA.
#define ID_EXTRA_USERS(id)
Definition DNA_ID.h:665
#define FILTER_ID_MA
Definition DNA_ID.h:1210
#define FILTER_ID_BR
Definition DNA_ID.h:1201
#define ID_IS_LINKED(_id)
Definition DNA_ID.h:697
#define FILTER_ID_TE
Definition DNA_ID.h:1222
#define ID_REAL_USERS(id)
Definition DNA_ID.h:679
#define FILTER_ID_PC
Definition DNA_ID.h:1218
#define ID_NEW_SET(_id, _idn)
Definition DNA_ID.h:757
#define FILTER_ID_IM
Definition DNA_ID.h:1206
#define MAX_BRUSH_PIXEL_DIAMETER
Read Blender memory allocation and freeing.
#define PRF_scope(category)
#define CLAMP(a, b, c)
#define BLI_assert_unreachable()
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
#define ELEM(...)
#define BR_TEST(field, t)
#define FROM_DEFAULT(member)
#define BR_TEST_FLAG_OVERLAY(_f)
#define FROM_DEFAULT_PTR(member)
#define BR_TEST_FLAG(_f)
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
Definition btVector3.h:356
constexpr int64_t size() const
Definition BLI_span.hh:499
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
Definition half.h:29
float distance(float, float) RET
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
float2x2 invert(float2x2 mat)
float3x3 scale(float3x3 mat, float2 scale)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
bool supports_sculpt_plane(const Brush &brush)
Definition brush.cc:2014
bool supports_secondary_cursor_color(const Brush &brush)
Definition brush.cc:2028
bool supports_auto_smooth(const Brush &brush)
Definition brush.cc:1943
bool supports_jitter(const Brush &brush)
Definition brush.cc:1975
bool supports_space_attenuation(const Brush &brush)
Definition brush.cc:2052
bool supports_size_pressure(const Brush &brush)
Definition brush.cc:2061
bool supports_persistence(const Brush &brush)
Definition brush.cc:1991
bool supports_tilt(const Brush &brush)
Definition brush.cc:2103
bool supports_inverted_direction(const Brush &brush)
Definition brush.cc:2073
bool supports_hardness(const Brush &brush)
Definition brush.cc:1959
bool supports_auto_smooth_pressure(const Brush &brush)
Definition brush.cc:2065
bool supports_rake_factor(const Brush &brush)
Definition brush.cc:1987
bool supports_plane_depth(const Brush &brush)
Definition brush.cc:1971
static bool is_paint_tool(const Brush &brush)
Definition brush.cc:1867
bool supports_accumulate(const Brush &brush)
Definition brush.cc:1916
static bool is_grab_tool(const Brush &brush)
Definition brush.cc:1880
bool supports_gravity(const Brush &brush)
Definition brush.cc:2091
bool supports_hardness_pressure(const Brush &brush)
Definition brush.cc:2069
bool supports_smooth_stroke(const Brush &brush)
Definition brush.cc:2043
bool supports_plane_offset(const Brush &brush)
Definition brush.cc:2002
bool supports_pinch_factor(const Brush &brush)
Definition brush.cc:1995
float normal_weight_get(const Brush &brush, bool invert)
Definition brush.cc:1841
bool supports_normal_radius(const Brush &brush)
Definition brush.cc:1949
bool supports_color(const Brush &brush)
Definition brush.cc:2024
void common_pressure_curves_init(Brush &brush)
Definition brush.cc:1549
bool supports_random_texture_angle(const Brush &brush)
Definition brush.cc:2010
bool supports_strength_pressure(const Brush &brush)
Definition brush.cc:2057
bool supports_dyntopo(const Brush &brush)
Definition brush.cc:1893
bool supports_height(const Brush &brush)
Definition brush.cc:1963
bool supports_topology_rake(const Brush &brush)
Definition brush.cc:1932
bool implements_3d_texture_paint(const Brush &brush)
Definition brush.cc:1850
bool supports_plane_height(const Brush &brush)
Definition brush.cc:1967
bool supports_normal_weight(const Brush &brush)
Definition brush.cc:1980
bool supports_tip_roundness(const Brush &brush)
Definition brush.cc:1955
std::unique_ptr< IDProperty, IDPropertyDeleter > create_bool(StringRef prop_name, bool value, eIDPropertyFlag flags={})
Allocate a new IDProperty of type IDP_BOOLEAN, set its name and value.
std::unique_ptr< IDProperty, IDPropertyDeleter > create(StringRef prop_name, int32_t value, eIDPropertyFlag flags={})
Allocate a new IDProperty of type IDP_INT, set its name and value.
internal::ShallowZeroInitializeTag shallow_zero_initialize()
Definition DNA_defs.h:159
internal::ShallowDataConstRef< T > shallow_copy(const T &other)
Definition DNA_defs.h:147
uint32_t struct_size(Span< shader::ShaderCreateInfo::PushConst > push_constants)
T rcp(const T &a)
BMesh Iterators.
CurveMapping * BKE_curvemapping_add(int tot, float minx, float miny, float maxx, float maxy)
Definition colortools.cc:99
void BKE_brush_init_curves_sculpt_settings(Brush *brush)
Definition brush.cc:827
@ BRUSH_CURVE_INVSQUARE
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static void brush_free_data(ID *id)
Definition brush.cc:154
CurveMapping * BKE_curvemapping_copy(const CurveMapping *cumap)
const MTex * BKE_brush_color_texture_get(const Brush *brush, PaintMode paint_mode)
Definition brush.cc:977
void BKE_previewimg_id_free(ID *id)
void BKE_brush_system_init()
Definition brush.cc:625
IDTypeInfo IDType_ID_BR
Definition brush.cc:591
void linearrgb_to_srgb_v3_v3(float srgb[3], const float linear[3])
void BKE_asset_metadata_idprop_ensure(AssetMetaData *asset_data, IDProperty *prop)
Definition asset.cc:172
void BKE_id_delete(Main *bmain, void *idv, const BKEIDDeleteOptions &options={}) ATTR_NONNULL()
MINLINE void copy_v3_v3(float r[3], const float a[3])
unsigned int uint
Definition BKE_text.h:55
void BKE_previewimg_blend_read(BlendDataReader *reader, PreviewImage *prv)
@ BRUSH_STROKE_DRAG_DOT
@ BRUSH_STROKE_ANCHORED
void BKE_libblock_relink_to_newid(Main *bmain, ID *id, int remap_flag) ATTR_NONNULL()
Definition lib_remap.cc:932
float BKE_brush_sample_tex_3d(const Paint *paint, const Brush *br, const MTex *mtex, const float3 &point, float4 &rgba, int thread, ImagePool *pool)
Definition brush.cc:985
float BKE_brush_sample_masktex(const Paint *paint, Brush *br, const float2 &point, int thread, ImagePool *pool)
Definition brush.cc:1101
void BKE_brush_curve_preset(Brush *b, eCurveMappingPreset preset)
Definition brush.cc:951
static void brush_init_data(ID *id)
Definition brush.cc:58
void BKE_previewimg_blend_write(BlendWriter *writer, const PreviewImage *prv)
float BKE_brush_radius_get(const Paint *paint, const Brush *brush)
Definition brush.cc:1366
void void BKE_libblock_remap(Main *bmain, void *old_idv, void *new_idv, int remap_flags) ATTR_NONNULL(1
Definition lib_remap.cc:701
void BKE_curvemapping_blend_write(BlendWriter *writer, const CurveMapping *cumap)
void BKE_brush_init_gpencil_settings(Brush *brush)
Definition brush.cc:719
ID * BKE_id_copy_for_duplicate(Main *bmain, ID *id, eDupli_ID_Flags duplicate_flags, int copy_flags)
Definition lib_id.cc:861
Brush * BKE_brush_duplicate(Main *bmain, Brush *brush, eDupli_ID_Flags dupflag, uint duplicate_options)
Definition brush.cc:761
@ CURVE_PRESET_SMOOTH
@ ID_REMAP_SKIP_INDIRECT_USAGE
@ ID_REMAP_SKIP_USER_CLEAR
static void brush_blend_read_after_liblink(BlendLibReader *, ID *id)
Definition brush.cc:526
static void brush_defaults(Brush *brush)
Definition brush.cc:640
void BKE_brush_calc_curve_factors(eBrushCurvePreset preset, const CurveMapping *cumap, Span< float > distances, float brush_radius, MutableSpan< float > factors)
Definition brush.cc:1561
void BKE_brush_scale_size(int *r_brush_size, float new_unprojected_size, float old_unprojected_size)
Definition brush.cc:1429
ImBuf * BKE_brush_gen_radial_control_imbuf(Brush *br, bool secondary, bool display_gradient)
Definition brush.cc:1791
void BKE_brush_init_mesh_automasking_settings(Brush *brush)
Definition brush.cc:819
void BKE_curvemapping_free(CurveMapping *cumap)
void id_fake_user_set(ID *id)
Definition lib_id.cc:471
void BKE_id_blend_write(BlendWriter *writer, ID *id)
Definition lib_id.cc:2890
struct RNG * BLI_rng_new(unsigned int seed)
Definition rand.cc:41
@ BRUSH_CLOTH_DEFORM_GRAB
MINLINE float pow3f(float x)
bool BKE_brush_delete(Main *bmain, Brush *brush)
Definition brush.cc:745
bool BKE_brush_use_alpha_pressure(const Brush *brush)
Definition brush.cc:1385
@ LIB_ID_COPY_NO_PREVIEW
@ LIB_ID_COPY_DEFAULT
static void brush_make_local(Main *bmain, ID *id, const int flags)
Definition brush.cc:199
MINLINE float pow2f(float x)
@ BRUSH_CURVES_SCULPT_FLAG_INTERPOLATE_RADIUS
@ SCULPT_BRUSH_TYPE_INFLATE
@ SCULPT_BRUSH_TYPE_SMEAR
@ SCULPT_BRUSH_TYPE_CLOTH
@ SCULPT_BRUSH_TYPE_SIMPLIFY
@ SCULPT_BRUSH_TYPE_SMOOTH
@ SCULPT_BRUSH_TYPE_CLAY_STRIPS
@ SCULPT_BRUSH_TYPE_CREASE
@ SCULPT_BRUSH_TYPE_DRAW_FACE_SETS
@ SCULPT_BRUSH_TYPE_GRAB
@ SCULPT_BRUSH_TYPE_BLUR
@ SCULPT_BRUSH_TYPE_PAINT
@ SCULPT_BRUSH_TYPE_BLOB
@ SCULPT_BRUSH_TYPE_PLANE
@ SCULPT_BRUSH_TYPE_SLIDE_RELAX
@ SCULPT_BRUSH_TYPE_PINCH
@ SCULPT_BRUSH_TYPE_POSE
@ SCULPT_BRUSH_TYPE_ROTATE
@ SCULPT_BRUSH_TYPE_LAYER
@ SCULPT_BRUSH_TYPE_DISPLACEMENT_ERASER
@ SCULPT_BRUSH_TYPE_BOUNDARY
@ SCULPT_BRUSH_TYPE_MASK
@ SCULPT_BRUSH_TYPE_DISPLACEMENT_SMEAR
@ SCULPT_BRUSH_TYPE_DRAW_SHARP
@ SCULPT_BRUSH_TYPE_SNAKE_HOOK
@ SCULPT_BRUSH_TYPE_CLAY
@ SCULPT_BRUSH_TYPE_CLAY_THUMB
@ SCULPT_BRUSH_TYPE_MULTIPLANE_SCRAPE
@ SCULPT_BRUSH_TYPE_SCENE_PROJECT
@ SCULPT_BRUSH_TYPE_THUMB
@ SCULPT_BRUSH_TYPE_ELASTIC_DEFORM
@ SCULPT_BRUSH_TYPE_DRAW
@ BRUSH_MASK_PRESSURE_CUTOFF
@ BRUSH_MASK_PRESSURE_RAMP
float BKE_brush_unprojected_radius_get(const Paint *paint, const Brush *brush)
Definition brush.cc:1412
void BKE_colorband_foreach_working_space_color(ColorBand *coba, const IDTypeForeachColorFunctionCallback &fn)
Definition colorband.cc:655
void BKE_brush_tag_unsaved_changes(Brush *brush)
Definition brush.cc:843
void BKE_brush_unprojected_size_set(Paint *paint, Brush *brush, float unprojected_size)
Definition brush.cc:1390
void BKE_lib_id_make_local_generic_action_define(Main *bmain, ID *id, int flags, bool *r_force_local, bool *r_force_copy)
Definition lib_id.cc:577
VecBase< float, 4 > float4
@ LIB_ID_DUPLICATE_IS_SUBPROCESS
@ LIB_ID_DUPLICATE_IS_ROOT_ID
MINLINE void zero_v4(float r[4])
void BKE_curvemapping_init(CurveMapping *cumap)
float2 BKE_brush_jitter_pos(const Paint &paint, const Brush &brush, const float2 &pos)
Definition brush.cc:1509
void BKE_curvemapping_blend_read(BlendDataReader *reader, CurveMapping *cumap)
bool BKE_brush_use_unified_strength(const Paint *paint, const Brush *brush)
Definition brush.cc:1231
void IMB_colormanagement_colorspace_to_scene_linear_v3(float pixel[3], const ColorSpace *colorspace)
static void brush_asset_metadata_ensure(void *asset_ptr, AssetMetaData *asset_data)
Definition brush.cc:543
VecBase< float, 2 > float2
static void brush_blend_write(BlendWriter *writer, ID *id, const void *id_address)
Definition brush.cc:263
@ OB_MODE_VERTEX_GREASE_PENCIL
@ OB_MODE_TEXTURE_PAINT
@ OB_MODE_SCULPT_GREASE_PENCIL
@ OB_MODE_SCULPT_CURVES
@ OB_MODE_WEIGHT_GREASE_PENCIL
@ OB_MODE_PAINT_GREASE_PENCIL
BMesh const char void * data
void BKE_curvemap_reset(CurveMap *cuma, const rctf *clipr, int preset, CurveMapSlopeType slope)
void BLI_rng_srandom(struct RNG *rng, unsigned int seed) ATTR_NONNULL(1)
Definition rand.cc:65
void BKE_lib_id_clear_library_data(Main *bmain, ID *id, int flags)
Definition lib_id.cc:210
void BKE_brush_color_set(Paint *paint, Brush *brush, const float3 &color)
Definition brush.cc:1305
void BKE_curvemapping_changed(CurveMapping *cumap, bool rem_doubles)
CurveMapping * BKE_paint_default_curve_inverted()
Definition scene.cc:166
@ IMAGE_PAINT_BRUSH_TYPE_DRAW
@ IMAGE_PAINT_BRUSH_TYPE_MASK
float BKE_brush_curve_strength(eBrushCurvePreset preset, const CurveMapping *cumap, float distance, float brush_radius)
Definition brush.cc:1691
CurveMapping * BKE_sculpt_default_cavity_curve()
Definition scene.cc:142
int BKE_brush_size_get(const Paint *paint, const Brush *brush)
Definition brush.cc:1356
void BLI_rng_free(struct RNG *rng) ATTR_NONNULL(1)
Definition rand.cc:55
bool BKE_brush_use_locked_size(const Paint *paint, const Brush *brush)
Definition brush.cc:1371
void BKE_brush_color_sync_legacy(Brush *brush)
Definition brush.cc:1319
void BKE_brush_size_set(Paint *paint, Brush *brush, int size)
Definition brush.cc:1340
const MTex * BKE_brush_mask_texture_get(const Brush *brush, PaintMode paint_mode)
Definition brush.cc:969
void BKE_brush_randomize_texture_coords(Paint *paint, bool mask)
Definition brush.cc:1533
void BKE_brush_scale_unprojected_size(float *unprojected_size, int new_brush_size, int old_brush_size)
Definition brush.cc:1417
float BLI_rng_get_float(struct RNG *rng) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition rand.cc:90
ImBuf * IMB_allocImBuf(unsigned int x, unsigned int y, ImBufFlags flags)
bool RE_texture_evaluate(const MTex *mtex, const float vec[3], const int thread, ImagePool *pool, const bool skip_load_image, const bool texnode_preview, float *r_intensity, float r_rgba[4])
bool BKE_brush_use_unified_size(const Paint *paint, const Brush *brush)
Definition brush.cc:1220
void BKE_brush_debug_print_state(Brush *br)
Definition brush.cc:850
void BKE_lib_id_expand_local(Main *bmain, ID *id, int flags)
Definition lib_id.cc:556
bool BKE_brush_use_size_pressure(const Brush *brush)
Definition brush.cc:1380
float BKE_brush_curve_strength_clamped(const Brush *br, float p, float len)
Definition brush.cc:1751
void BKE_main_id_newptr_and_tag_clear(Main *bmain)
Definition lib_id.cc:2097
MINLINE float len_squared_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
void BKE_previewimg_id_copy(ID *new_id, const ID *old_id)
@ BRUSH_USE_UNIFIED_PAINT_INPUT_SAMPLES
@ BRUSH_USE_UNIFIED_PAINT_WEIGHT
@ BRUSH_USE_UNIFIED_PAINT_SIZE
@ BRUSH_USE_UNIFIED_PAINT_ALPHA
@ BRUSH_USE_UNIFIED_PAINT_COLOR
void BKE_brush_system_exit()
Definition brush.cc:631
@ INDEX_ID_BR
Definition DNA_ID.h:1348
void BKE_brush_input_samples_set(Paint *paint, Brush *brush, int value)
Definition brush.cc:1494
bool BKE_brush_has_cube_tip(const Brush *brush, PaintMode paint_mode)
Definition brush.cc:1816
void BKE_brush_weight_set(Paint *paint, Brush *brush, float value)
Definition brush.cc:1472
ID_Type GS(const char *name)
Definition DNA_ID.h:410
void BKE_texture_mtex_foreach_id(struct LibraryForeachIDData *data, struct MTex *mtex)
Definition texture.cc:217
@ ID_TAG_INDIRECT
Definition DNA_ID.h:851
@ ID_TAG_NEW
Definition DNA_ID.h:922
float BKE_brush_unprojected_size_get(const Paint *paint, const Brush *brush)
Definition brush.cc:1403
MINLINE float square_f(float a)
std::optional< int > BKE_paint_get_brush_type_from_obmode(const Brush *brush, eObjectMode ob_mode)
CurveMapping * BKE_paint_default_curve()
Definition scene.cc:157
std::optional< BrushColorJitterSettings > BKE_brush_color_jitter_get_settings(const Paint *paint, const Brush *brush)
Definition brush.cc:1262
@ BRUSH_SPACING_PRESSURE
@ BRUSH_ORIGINAL_NORMAL
@ BRUSH_JITTER_PRESSURE
@ BRUSH_ABSOLUTE_JITTER
@ BRUSH_OFFSET_PRESSURE
@ BRUSH_SMOOTH_PRESSURE
float3 BKE_brush_color_get(const Paint *paint, const Brush *brush)
Definition brush.cc:1253
@ ID_FLAG_FAKEUSER
Definition DNA_ID.h:770
static void brush_foreach_working_space_color(ID *id, const IDTypeForeachColorFunctionCallback &fn)
Definition brush.cc:250
static void brush_copy_data(Main *, std::optional< Library * >, ID *id_dst, const ID *id_src, const int flag)
Definition brush.cc:81
@ LIB_ID_MAKELOCAL_FULL_LIBRARY
@ UNIFIED_PAINT_BRUSH_LOCK_SIZE
@ UNIFIED_PAINT_COLOR_JITTER
float BKE_brush_weight_get(const Paint *paint, const Brush *brush)
Definition brush.cc:1464
bool BKE_library_ID_is_indirectly_used(Main *bmain, void *idv)
Definition lib_query.cc:652
@ IDWALK_CB_LOOPBACK
@ IDWALK_CB_EMBEDDED_NOT_OWNING
@ IDWALK_CB_EMBEDDED
VecBase< float, 3 > float3
@ BRUSH_OVERLAY_SECONDARY
@ BRUSH_OVERLAY_CURSOR_OVERRIDE_ON_STROKE
@ BRUSH_OVERLAY_PRIMARY
@ BRUSH_OVERLAY_SECONDARY_OVERRIDE_ON_STROKE
@ BRUSH_OVERLAY_PRIMARY_OVERRIDE_ON_STROKE
@ GP_BRUSH_USE_PRESSURE
@ GP_BRUSH_USE_JITTER_PRESSURE
@ GP_BRUSH_MATERIAL_PINNED
static RNG * brush_rng
Definition brush.cc:623
static void brush_foreach_id(ID *id, LibraryForeachIDData *data)
Definition brush.cc:236
void BKE_brush_alpha_set(Paint *paint, Brush *brush, float alpha)
Definition brush.cc:1441
static AssetTypeInfo AssetType_BR
Definition brush.cc:586
ID * BKE_id_copy(Main *bmain, const ID *id)
Definition lib_id.cc:856
void id_us_min(ID *id)
Definition lib_id.cc:441
Brush * BKE_brush_add(Main *bmain, const char *name, eObjectMode ob_mode)
Definition brush.cc:695
void BKE_library_foreach_ID_link(Main *bmain, ID *id, FunctionRef< LibraryIDLinkCallback > callback, void *user_data, LibraryForeachIDFlag flag)
Definition lib_query.cc:449
float BKE_curvemapping_evaluateF(const CurveMapping *cumap, int cur, float value)
void * BKE_id_new(Main *bmain, short type, const char *name)
Definition lib_id.cc:1612
float BKE_brush_alpha_get(const Paint *paint, const Brush *brush)
Definition brush.cc:1454
static bool brush_gen_texture(const Brush *br, const int side, const bool use_secondary, float *rect)
Definition brush.cc:1761
@ CUMA_EXTEND_EXTRAPOLATE
bool BKE_brush_use_unified_color(const Paint *paint, const Brush *brush)
Definition brush.cc:1242
static void brush_blend_read_data(BlendDataReader *reader, ID *id)
Definition brush.cc:354
float3 BKE_brush_secondary_color_get(const Paint *paint, const Brush *brush)
Definition brush.cc:1297
int BKE_brush_input_samples_get(const Paint *paint, const Brush *brush)
Definition brush.cc:1485
@ IDTYPE_FLAGS_NO_MEMFILE_UNDO
Definition BKE_idtype.hh:59
@ IDTYPE_FLAGS_NO_ANIMDATA
Definition BKE_idtype.hh:52
#define fabsf
#define sqrtf
#define sinf
#define cosf
#define atan2f
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
The meta-data of an asset. By creating and giving this for a data-block (ID.asset_data),...
void write_id_struct(const void *id_address, const T *id, BlendStructWriterTypedFn< T > fn=nullptr)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
struct CurveMapping * curve_parameter_falloff
struct CurveMapping * curve_rand_saturation
struct CurveMapping * curve_sensitivity
struct CurveMapping * curve_jitter
struct CurveMapping * curve_rand_strength
struct CurveMapping * curve_rand_uv
struct CurveMapping * curve_rand_hue
struct CurveMapping * curve_rand_pressure
struct CurveMapping * curve_strength
struct CurveMapping * curve_rand_value
float mask_stencil_dimension[2]
struct CurveMapping * curve_rand_value
struct CurveMapping * curve_rand_saturation
struct BrushGpencilSettings * gpencil_settings
struct MTex mask_mtex
struct CurveMapping * curve_jitter
eBrushCurvePreset curve_distance_falloff_preset
PreviewImage * preview
DNA_DEPRECATED struct CurveMapping * automasking_cavity_curve
struct CurveMapping * curve_distance_falloff
struct CurveMapping * curve_spacing
struct CurveMapping * curve_auto_smooth
float stencil_dimension[2]
BrushMaskPressureFlags mask_pressure
struct MeshAutomaskingSettings * mesh_automasking_settings
struct CurveMapping * curve_hardness
float mask_stencil_pos[2]
struct CurveMapping * curve_size
struct CurveMapping * curve_rand_hue
struct BrushCurvesSculptSettings * curves_sculpt_settings
struct CurveMapping * curve_strength
eCurveMappingFlags flag
eCurveMappingPreset preset
short flag
Definition DNA_ID.h:439
float * float_data_for_write()
Definition allocimbuf.cc:79
eMTex_BrushMapMode brush_map_mode
struct CurveMapping * cavity_curve_op
DNA_DEPRECATED float rgb[3]
struct CurveMapping * curve_rand_saturation
DNA_DEPRECATED float secondary_rgb[3]
struct CurveMapping * curve_rand_value
struct CurveMapping * curve_rand_hue
const ocio::ColorSpace * colorspace
#define N_(msgid)