Blender V5.3
paint_common.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include "BKE_brush.hh"
6#include "BKE_colortools.hh"
7#include "BKE_context.hh"
8#include "BKE_crazyspace.hh"
9#include "BKE_curves.hh"
10#include "BKE_grease_pencil.hh"
12#include "BKE_paint.hh"
13
14#include "BLI_array_utils.hh"
15#include "BLI_index_mask.hh"
16#include "BLI_math_vector.hh"
17#include "BLI_task.hh"
18
20
21#include "DNA_brush_types.h"
22#include "DNA_screen_types.h"
23#include "DNA_view3d_types.h"
24
25#include "ED_grease_pencil.hh"
26#include "ED_view3d.hh"
27
29
31
33{
34 using namespace blender::bke::greasepencil;
35
36 const Scene &scene = *CTX_data_scene(&C);
37 Object &ob_orig = *CTX_data_active_object(&C);
38 GreasePencil &grease_pencil = *id_cast<GreasePencil *>(ob_orig.data);
39
40 /* Apply to all editable drawings. */
42}
43
45 const bContext &C)
46{
47 using namespace blender::bke::greasepencil;
48
49 const Scene &scene = *CTX_data_scene(&C);
51 Object &ob_orig = *CTX_data_active_object(&C);
52 GreasePencil &grease_pencil = *id_cast<GreasePencil *>(ob_orig.data);
53
54 const bool active_layer_masking = (ts.gp_sculpt.flag &
56
57 if (active_layer_masking) {
58 /* Apply only to the drawing at the current frame of the active layer. */
59 if (!grease_pencil.has_active_layer()) {
60 return {};
61 }
62 const Layer &active_layer = *grease_pencil.get_active_layer();
64 scene, grease_pencil, active_layer);
65 }
66
67 /* Apply to all editable drawings. */
69}
70
72{
73 if (brush.gpencil_settings == nullptr) {
75 }
76 BLI_assert(brush.gpencil_settings != nullptr);
77 BKE_curvemapping_init(brush.curve_distance_falloff);
78 BKE_curvemapping_init(brush.gpencil_settings->curve_strength);
79 BKE_curvemapping_init(brush.gpencil_settings->curve_sensitivity);
80 BKE_curvemapping_init(brush.gpencil_settings->curve_jitter);
81 BKE_curvemapping_init(brush.gpencil_settings->curve_rand_pressure);
82 BKE_curvemapping_init(brush.gpencil_settings->curve_rand_strength);
83 BKE_curvemapping_init(brush.gpencil_settings->curve_rand_uv);
84 BKE_curvemapping_init(brush.curve_rand_hue);
85 BKE_curvemapping_init(brush.curve_rand_saturation);
86 BKE_curvemapping_init(brush.curve_rand_value);
87}
88
89float brush_radius(const Paint &paint, const Brush &brush, const float pressure = 1.0f)
90{
91 float radius = BKE_brush_radius_get(&paint, &brush);
93 radius *= BKE_curvemapping_evaluateF(brush.gpencil_settings->curve_sensitivity, 0, pressure);
94 }
95 return radius;
96}
97
99 const Brush &brush,
100 const float2 &co,
101 const InputSample &sample,
102 const float multi_frame_falloff)
103{
104 const float radius = brush_radius(paint, brush, sample.pressure);
105 /* Basic strength factor from brush settings. */
106 const float brush_pressure = BKE_brush_use_alpha_pressure(&brush) ? sample.pressure : 1.0f;
107 const float influence_base = BKE_brush_alpha_get(&paint, &brush) * brush_pressure *
108 multi_frame_falloff;
109
110 /* Distance falloff. */
111 const float distance = math::distance(sample.mouse_position, co);
112 /* Apply Brush curve. */
113 const float brush_falloff = BKE_brush_curve_strength(&brush, distance, radius);
114
115 return influence_base * brush_falloff;
116}
117
119{
120 int j = verts.size() - 1;
121 bool isect = false;
122 float distance = FLT_MAX;
123 for (int i = 0; i < verts.size(); i++) {
124 /* Based on implementation of #isect_point_poly_v2. */
125 if (((verts[i].y > pt.y) != (verts[j].y > pt.y)) &&
126 (pt.x <
127 (verts[j].x - verts[i].x) * (pt.y - verts[i].y) / (verts[j].y - verts[i].y) + verts[i].x))
128 {
129 isect = !isect;
130 }
131 distance = math::min(distance, math::distance(pt, verts[i]));
132 j = i;
133 }
134 return isect ? 0.0f : distance;
135}
136
138 const Brush &brush,
139 const Span<float2> fill_positions,
140 const InputSample &sample,
141 const float multi_frame_falloff)
142{
143 const float radius = brush_radius(paint, brush, sample.pressure);
144 /* Basic strength factor from brush settings. */
145 const float brush_pressure = BKE_brush_use_alpha_pressure(&brush) ? sample.pressure : 1.0f;
146 const float influence_base = BKE_brush_alpha_get(&paint, &brush) * brush_pressure *
147 multi_frame_falloff;
148
149 /* Distance falloff. */
150 const float distance = closest_distance_to_surface_2d(sample.mouse_position, fill_positions);
151 /* Apply Brush curve. */
152 const float brush_falloff = BKE_brush_curve_strength(&brush, distance, radius);
153
154 return influence_base * brush_falloff;
155}
156
158 const Brush &brush,
159 const float2 &mouse_position,
160 const float pressure,
161 const float multi_frame_falloff,
162 const IndexMask &selection,
163 const Span<float2> view_positions,
164 Vector<float> &influences,
165 IndexMaskMemory &memory)
166{
167 if (selection.is_empty() || view_positions.is_empty()) {
168 return {};
169 }
170
171 const float radius = brush_radius(paint, brush, pressure);
172 const float radius_squared = radius * radius;
173 const float brush_pressure = BKE_brush_use_alpha_pressure(&brush) ? pressure : 1.0f;
174 const float influence_base = BKE_brush_alpha_get(&paint, &brush) * brush_pressure *
175 multi_frame_falloff;
176 const int2 mval_i = int2(math::round(mouse_position));
177
178 Array<float> all_influences(selection.min_array_size());
179 const IndexMask influence_mask = IndexMask::from_predicate(
180 selection, memory, [&](const int point) {
181 const float2 &co = view_positions[point];
182
183 if (co == float2(invalid_screen_position)) {
184 return false;
185 }
186
187 /* Distance falloff. */
188 const float distance_squared = math::distance_squared(int2(co), mval_i);
189 if (distance_squared > radius_squared) {
190 all_influences[point] = 0.0f;
191 return false;
192 }
193 /* Apply Brush curve. */
194 const float brush_falloff = BKE_brush_curve_strength(
196 all_influences[point] = influence_base * brush_falloff;
197 return all_influences[point] > 0.0f;
198 });
199 influences.resize(influence_mask.size());
200 array_utils::gather(all_influences.as_span(), influence_mask, influences.as_mutable_span());
201
202 return influence_mask;
203}
204
205bool brush_using_vertex_color(const GpPaint *gp_paint, const Brush *brush)
206{
207 const int brush_draw_mode = brush->gpencil_settings->brush_draw_mode;
208 const bool brush_use_pinned_mode = (brush_draw_mode != GP_BRUSH_MODE_ACTIVE);
209 if (brush_use_pinned_mode) {
210 return (brush_draw_mode == GP_BRUSH_MODE_VERTEXCOLOR);
211 }
212 return (gp_paint->mode == GPPAINT_FLAG_USE_VERTEXCOLOR);
213}
214
215bool is_brush_inverted(const Brush &brush, const BrushStrokeMode stroke_mode)
216{
217 /* The basic setting is the brush's setting. During runtime, the user can hold down the Ctrl key
218 * to invert the basic behavior. */
219 return bool(brush.flag & BRUSH_DIR_IN) ^ (stroke_mode == BrushStrokeMode::Invert);
220}
221
223 const Object &object,
225{
226 const float4x4 view_to_world = float4x4(params.rv3d.viewinv);
227 const float4x4 layer_to_world = layer.to_world_space(object);
228 const float4x4 world_to_layer = math::invert(layer_to_world);
229
230 auto screen_to_world = [=](const float3 &world_pos, const float2 &screen_delta) {
231 const float zfac = ED_view3d_calc_zfac(&params.rv3d, world_pos);
232 float3 world_delta;
233 ED_view3d_win_to_delta(&params.region, screen_delta, zfac, world_delta);
234 return world_delta;
235 };
236
237 float3 world_normal;
238 switch (params.toolsettings.gp_sculpt.lock_axis) {
239 case GP_LOCKAXIS_VIEW: {
240 world_normal = view_to_world.z_axis();
241 break;
242 }
243 case GP_LOCKAXIS_X: {
244 world_normal = layer_to_world.x_axis();
245 break;
246 }
247 case GP_LOCKAXIS_Y: {
248 world_normal = layer_to_world.y_axis();
249 break;
250 }
251 case GP_LOCKAXIS_Z: {
252 world_normal = layer_to_world.z_axis();
253 break;
254 }
255 case GP_LOCKAXIS_CURSOR: {
256 world_normal = params.scene.cursor.matrix<float3x3>().z_axis();
257 break;
258 }
259 default: {
261 return [](const float3 &, const float2 &) { return float3(); };
262 }
263 }
264
265 return [=](const float3 &position, const float2 &screen_delta) {
266 const float3 world_pos = math::transform_point(layer_to_world, position);
267 const float3 world_delta = screen_to_world(world_pos, screen_delta);
268 const float3 layer_delta = math::transform_direction(
269 world_to_layer, world_delta - world_normal * math::dot(world_delta, world_normal));
270 return position + layer_delta;
271 };
272}
273
275 const bke::crazyspace::GeometryDeformation &deformation,
276 const int index,
277 const float2 &screen_delta)
278{
279 const float3 old_position_eval = deformation.positions[index];
280 const float3 new_position_eval = projection_fn(old_position_eval, screen_delta);
281 const float3 translation_eval = new_position_eval - old_position_eval;
282 const float3 translation_orig = deformation.translation_from_deformed_to_original(
283 index, translation_eval);
284 return translation_orig;
285}
286
288 const Scene &scene,
289 Depsgraph &depsgraph,
292 Object &object,
293 const int layer_index,
294 const int frame_number,
295 const float multi_frame_falloff,
297{
298 Object &ob_eval = *DEG_get_evaluated(&depsgraph, &object);
299 GreasePencil &grease_pencil = *id_cast<GreasePencil *>(object.data);
300
302 return {*scene.toolsettings,
303 region,
304 rv3d,
305 scene,
306 object,
307 ob_eval,
308 layer,
312 drawing};
313}
314
316 const bool use_selection_masking,
317 IndexMaskMemory &memory)
318{
319 return use_selection_masking ? ed::greasepencil::retrieve_editable_and_selected_points(
320 params.ob_orig, params.drawing, params.layer_index, memory) :
322 params.ob_orig, params.drawing, params.layer_index, memory);
323}
324
326 const bool use_selection_masking,
327 IndexMaskMemory &memory)
328{
330 params.ob_orig, params.drawing, params.layer_index, memory) :
332 params.ob_orig, params.drawing, params.layer_index, memory);
333}
334
336 const bool use_selection_masking,
337 IndexMaskMemory &memory)
338{
339 if (!params.drawing.fills().has_value()) {
340 return {};
341 }
342 const GroupedSpan<int> fills = *params.drawing.fills();
343 if (!use_selection_masking) {
344 return fills.index_range();
345 }
347 params.ob_orig, params.drawing, params.layer_index, memory);
348 /* TODO: write dedicated function for this that doesn't use `contains`. */
350 fills.index_range(),
351 memory,
352 [&](const int64_t i) {
353 for (const int curve_i : fills[i]) {
354 if (!editable_strokes.contains(curve_i)) {
355 return false;
356 }
357 }
358 return true;
359 },
361}
362
369
371 const IndexMask &point_mask)
372{
374
375 Array<float2> view_positions(deformation.positions.size());
376
377 /* Compute screen space positions. */
378 const float4x4 transform = params.layer.to_world_space(params.ob_eval);
379 point_mask.foreach_index(
380 [&](const int64_t point_i) {
382 &params.region,
383 math::transform_point(transform, deformation.positions[point_i]),
384 view_positions[point_i],
386 if (result != V3D_PROJ_RET_OK) {
387 view_positions[point_i] = float2(invalid_screen_position);
388 }
389 },
391
392 return view_positions;
393}
394
396 const IndexMask &curve_mask)
397{
399
400 Array<float2> view_positions(deformation.positions.size());
401
402 /* Compute screen space positions. */
403 const OffsetIndices points_by_curve = params.drawing.strokes().points_by_curve();
404 const float4x4 transform = params.layer.to_world_space(params.ob_eval);
405 curve_mask.foreach_index(
406 [&](const int64_t curve_i) {
407 const IndexRange points = points_by_curve[curve_i];
408 for (const int point_i : points) {
410 &params.region,
411 math::transform_point(transform, deformation.positions[point_i]),
412 view_positions[point_i],
414 if (result != V3D_PROJ_RET_OK) {
415 view_positions[point_i] = float2(invalid_screen_position);
416 }
417 }
418 },
420
421 return view_positions;
422}
423
425 const IndexMask &selection)
426{
427 const Span<float3> handle_positions_left =
428 params.drawing.strokes().handle_positions_left().value_or(Span<float3>());
429 Array<float2> view_positions(handle_positions_left.size());
430
431 if (handle_positions_left.is_empty()) {
432 return view_positions;
433 }
434
435 /* Compute screen space positions. */
436 const float4x4 transform = params.layer.to_world_space(params.ob_eval);
437 selection.foreach_index(
438 [&](const int64_t point_i) {
440 &params.region,
441 math::transform_point(transform, handle_positions_left[point_i]),
442 view_positions[point_i],
444 if (result != V3D_PROJ_RET_OK) {
445 view_positions[point_i] = float2(invalid_screen_position);
446 }
447 },
449
450 return view_positions;
451}
452
454 const IndexMask &selection)
455{
456 const Span<float3> handle_positions_right =
457 params.drawing.strokes().handle_positions_right().value_or(Span<float3>());
458 Array<float2> view_positions(handle_positions_right.size());
459
460 if (handle_positions_right.is_empty()) {
461 return view_positions;
462 }
463
464 /* Compute screen space positions. */
465 const float4x4 transform = params.layer.to_world_space(params.ob_eval);
466 selection.foreach_index(
467 [&](const int64_t point_i) {
469 &params.region,
470 math::transform_point(transform, handle_positions_right[point_i]),
471 view_positions[point_i],
473 if (result != V3D_PROJ_RET_OK) {
474 view_positions[point_i] = float2(invalid_screen_position);
475 }
476 },
478
479 return view_positions;
480}
481
483 const IndexMask &selection)
484{
485 const RegionView3D *rv3d = static_cast<RegionView3D *>(params.region.regiondata);
487
488 const VArray<float> radii = params.drawing.radii();
489 Array<float> view_radii(radii.size());
490 /* Compute screen space radii. */
491 const float4x4 transform = params.layer.to_world_space(params.ob_eval);
492 selection.foreach_index(
493 [&](const int64_t point_i) {
494 const float pixel_size = ED_view3d_pixel_size(
495 rv3d, math::transform_point(transform, deformation.positions[point_i]));
496 view_radii[point_i] = radii[point_i] / pixel_size;
497 },
499
500 return view_radii;
501}
502
504{
505 return brush.gpencil_settings != nullptr &&
506 ELEM(brush.gpencil_settings->vertex_mode, GPPAINT_MODE_STROKE, GPPAINT_MODE_BOTH);
507}
508
510{
511 return brush.gpencil_settings != nullptr &&
512 ELEM(brush.gpencil_settings->vertex_mode, GPPAINT_MODE_FILL, GPPAINT_MODE_BOTH);
513}
514
519
521{
522 return input_sample.mouse_position - this->prev_mouse_position;
523}
524
526 const bContext &C,
527 FunctionRef<bool(const GreasePencilStrokeParams &params, const IndexMask &point_mask)> fn)
528 const
529{
530 using namespace blender::bke::greasepencil;
531
532 const Scene &scene = *CTX_data_scene(&C);
533 Depsgraph &depsgraph = *CTX_data_depsgraph_pointer(&C);
534 ARegion &region = *CTX_wm_region(&C);
536 Object &object = *CTX_data_active_object(&C);
537 GreasePencil &grease_pencil = *id_cast<GreasePencil *>(object.data);
538
539 std::atomic<bool> changed = false;
541 for (const int64_t i : drawings.index_range()) {
542 const MutableDrawingInfo &info = drawings[i];
543 const AutoMaskingInfo &auto_mask_info = this->auto_masking_info_per_drawing[i];
545 scene,
546 depsgraph,
547 region,
548 rv3d,
549 object,
550 info.layer_index,
551 info.frame_number,
553 info.drawing);
554
555 if (fn(params, auto_mask_info.point_mask)) {
556 changed = true;
557 }
558 }
559
560 if (changed) {
563 }
564}
565
566void GreasePencilStrokeOperationCommon::foreach_editable_drawing_with_automask(
567 const bContext &C,
568 FunctionRef<bool(const GreasePencilStrokeParams &params,
569 const IndexMask &point_mask,
570 const DeltaProjectionFunc &projection_fn)> fn) const
571{
572 using namespace blender::bke::greasepencil;
573
574 const Scene &scene = *CTX_data_scene(&C);
575 Depsgraph &depsgraph = *CTX_data_depsgraph_pointer(&C);
576 ARegion &region = *CTX_wm_region(&C);
578 Object &object = *CTX_data_active_object(&C);
579 Object &object_eval = *DEG_get_evaluated(&depsgraph, &object);
580 GreasePencil &grease_pencil = *id_cast<GreasePencil *>(object.data);
581
582 std::atomic<bool> changed = false;
583 const Vector<MutableDrawingInfo> drawings = get_drawings_with_masking_for_stroke_operation(C);
584 threading::parallel_for_each(drawings.index_range(), [&](const int i) {
585 const MutableDrawingInfo &info = drawings[i];
586 const Layer &layer = grease_pencil.layer(info.layer_index);
587 const AutoMaskingInfo &auto_mask_info = this->auto_masking_info_per_drawing[i];
588 const GreasePencilStrokeParams params = GreasePencilStrokeParams::from_context(
589 scene,
590 depsgraph,
591 region,
592 rv3d,
593 object,
594 info.layer_index,
595 info.frame_number,
596 info.multi_frame_falloff,
597 info.drawing);
598
599 const DeltaProjectionFunc projection_fn = get_screen_projection_fn(params, object_eval, layer);
600 if (fn(params, auto_mask_info.point_mask, projection_fn)) {
601 changed = true;
602 }
603 });
604
605 if (changed) {
606 DEG_id_tag_update(&grease_pencil.id, ID_RECALC_GEOMETRY);
607 WM_event_add_notifier(&C, NC_GEOM | ND_DATA, &grease_pencil);
608 }
609}
610
612 const bContext &C,
613 FunctionRef<bool(const GreasePencilStrokeParams &params)> fn,
614 const exec_mode::Mode &mode) const
615{
616 using namespace blender::bke::greasepencil;
617
618 const Scene &scene = *CTX_data_scene(&C);
619 Depsgraph &depsgraph = *CTX_data_depsgraph_pointer(&C);
620 ARegion &region = *CTX_wm_region(&C);
622 Object &object = *CTX_data_active_object(&C);
623 GreasePencil &grease_pencil = *id_cast<GreasePencil *>(object.data);
624
625 std::atomic<bool> changed = false;
627
628 if (mode.is_parallel) {
630 drawings.index_range(), mode.grain_size(16), [&](const IndexRange range) {
631 for (const int64_t i : range) {
632 const MutableDrawingInfo &info = drawings[i];
633 GreasePencilStrokeParams params = GreasePencilStrokeParams::from_context(
634 scene,
635 depsgraph,
636 region,
637 rv3d,
638 object,
639 info.layer_index,
640 info.frame_number,
641 info.multi_frame_falloff,
642 info.drawing);
643 if (fn(params)) {
644 changed = true;
645 }
646 }
647 });
648 }
649 else {
650 for (const int64_t i : drawings.index_range()) {
651 const MutableDrawingInfo &info = drawings[i];
653 scene,
654 depsgraph,
655 region,
656 rv3d,
657 object,
658 info.layer_index,
659 info.frame_number,
661 info.drawing);
662 if (fn(params)) {
663 changed = true;
664 }
665 }
666 }
667
668 if (changed) {
671 }
672}
673
675 const bContext &C,
676 FunctionRef<bool(const GreasePencilStrokeParams &params,
677 const DeltaProjectionFunc &projection_fn)> fn) const
678{
679 using namespace blender::bke::greasepencil;
680
681 const Scene &scene = *CTX_data_scene(&C);
682 Depsgraph &depsgraph = *CTX_data_depsgraph_pointer(&C);
683 ARegion &region = *CTX_wm_region(&C);
685 Object &object = *CTX_data_active_object(&C);
686 Object &object_eval = *DEG_get_evaluated(&depsgraph, &object);
687 GreasePencil &grease_pencil = *id_cast<GreasePencil *>(object.data);
688
689 bool changed = false;
691 for (const int64_t i : drawings.index_range()) {
692 const MutableDrawingInfo &info = drawings[i];
693 const Layer &layer = grease_pencil.layer(info.layer_index);
695 scene,
696 depsgraph,
697 region,
698 rv3d,
699 object,
700 info.layer_index,
701 info.frame_number,
703 info.drawing);
704
705 const DeltaProjectionFunc projection_fn = get_screen_projection_fn(params, object_eval, layer);
706 if (fn(params, projection_fn)) {
707 changed = true;
708 }
709 }
710
711 if (changed) {
714 }
715}
716
718 const InputSample &start_sample)
719{
722
724
725 this->start_mouse_position = start_sample.mouse_position;
726 this->prev_mouse_position = start_sample.mouse_position;
727}
728
730 const InputSample &start_sample)
731{
732 const Scene &scene = *CTX_data_scene(&C);
733 ARegion &region = *CTX_wm_region(&C);
735 Object &object = *CTX_data_active_object(&C);
736 Depsgraph &depsgraph = *CTX_data_depsgraph_pointer(&C);
737
738 const eGP_Sculpt_SelectMaskFlag sculpt_selection_flag = eGP_Sculpt_SelectMaskFlag(
740 const bool use_sculpt_selection_masking = (sculpt_selection_flag &
744
745 const eGP_Sculpt_SettingsFlag sculpt_settings_flag = eGP_Sculpt_SettingsFlag(
747 const bool use_auto_mask_stroke = (sculpt_settings_flag & GP_SCULPT_SETT_FLAG_AUTOMASK_STROKE);
748 const bool use_auto_mask_layer = (sculpt_settings_flag &
750 const bool use_auto_mask_material = (sculpt_settings_flag &
752 const bool use_auto_mask_active_material = (sculpt_settings_flag &
754
755 const float stroke_distance_threshold = 20.0f;
756 const int2 mval_i = int2(math::round(start_sample.mouse_position));
757 const int active_material_index = math::max(object.actcol - 1, 0);
758
760 this->auto_masking_info_per_drawing.reinitialize(drawings.size());
761
762 VectorSet<int> masked_layer_indices;
763 VectorSet<int> masked_material_indices;
764 for (const int drawing_i : drawings.index_range()) {
765 const MutableDrawingInfo &drawing_info = drawings[drawing_i];
766 AutoMaskingInfo &automask_info = this->auto_masking_info_per_drawing[drawing_i];
768 scene,
769 depsgraph,
770 region,
771 rv3d,
772 object,
773 drawing_info.layer_index,
774 drawing_info.frame_number,
775 drawing_info.multi_frame_falloff,
776 drawing_info.drawing);
778 params, use_sculpt_selection_masking, automask_info.memory);
779 if (automask_info.point_mask.is_empty()) {
780 continue;
781 }
782
783 const bke::CurvesGeometry &curves = drawing_info.drawing.strokes();
784 const OffsetIndices<int> points_by_curve = curves.points_by_curve();
785 const bke::AttributeAccessor attributes = curves.attributes();
786
787 if (use_auto_mask_active_material) {
788 IndexMaskMemory memory;
789 const VArraySpan<int> materials = *attributes.lookup_or_default<int>(
790 "material_index", bke::AttrDomain::Point, 0);
791 const IndexMask active_material_mask = IndexMask::from_predicate(
792 curves.points_range(), memory, [&](const int64_t point_i) {
793 return active_material_index == materials[point_i];
794 });
796 automask_info.point_mask, active_material_mask, automask_info.memory);
797 if (automask_info.point_mask.is_empty()) {
798 continue;
799 }
800 }
801
802 if (use_auto_mask_layer || use_auto_mask_stroke || use_auto_mask_material) {
803 IndexMaskMemory memory;
804 const IndexMask stroke_selection = curve_mask_for_stroke_operation(
805 params, use_sculpt_selection_masking, memory);
806 const Array<float2> view_positions = view_positions_from_curve_mask(params,
807 stroke_selection);
808 const IndexMask strokes_under_brush = IndexMask::from_predicate(
809 stroke_selection, memory, [&](const int curve_i) {
810 for (const int point_i : points_by_curve[curve_i]) {
811 const float distance = math::distance(mval_i, int2(view_positions[point_i]));
812 if (distance <= stroke_distance_threshold) {
813 return true;
814 }
815 }
816 return false;
817 });
818
819 if (use_auto_mask_layer && !strokes_under_brush.is_empty()) {
820 masked_layer_indices.add(drawing_info.layer_index);
821 }
822
823 if (use_auto_mask_stroke) {
825 automask_info.point_mask,
826 IndexMask::from_ranges(curves.points_by_curve(), strokes_under_brush, memory),
827 automask_info.memory);
828 }
829
830 if (use_auto_mask_material) {
831 const VArraySpan<int> material_indices = *attributes.lookup_or_default<int>(
832 "material_index", bke::AttrDomain::Curve, 0);
833 strokes_under_brush.foreach_index(
834 [&](const int curve_i) { masked_material_indices.add(material_indices[curve_i]); });
835 }
836 }
837 }
838
839 /* When we mask by the initial strokes under the cursor, the other masking options don't affect
840 * the resulting mask. So we can skip the second loop. */
841 if (use_auto_mask_stroke) {
842 return;
843 }
844
845 threading::parallel_for_each(drawings.index_range(), [&](const int drawing_i) {
846 const MutableDrawingInfo &drawing_info = drawings[drawing_i];
847 AutoMaskingInfo &automask_info = this->auto_masking_info_per_drawing[drawing_i];
848
849 if (use_auto_mask_layer && !masked_layer_indices.contains(drawing_info.layer_index)) {
850 automask_info.point_mask = {};
851 return;
852 }
853
854 if (use_auto_mask_material) {
855 const bke::CurvesGeometry &curves = drawing_info.drawing.strokes();
856 const VArraySpan<int> material_indices = *curves.attributes().lookup_or_default<int>(
857 "material_index", bke::AttrDomain::Curve, 0);
858 IndexMaskMemory memory;
859 const IndexMask masked_curves = IndexMask::from_predicate(
860 curves.curves_range(), memory, [&](const int curve_i) {
861 return masked_material_indices.contains(material_indices[curve_i]);
862 });
863
864 automask_info.point_mask = IndexMask::from_intersection(
865 automask_info.point_mask,
866 IndexMask::from_ranges(curves.points_by_curve(), masked_curves, memory),
867 automask_info.memory);
868 }
869 });
870}
871
873{
874 this->prev_mouse_position = extension_sample.mouse_position;
875}
876
877} // namespace blender::ed::sculpt_paint::greasepencil
Low-level operations for curves.
Low-level operations for grease pencil.
#define C
Definition RandGen.cpp:29
#define NC_GEOM
Definition WM_types.hh:406
#define ND_DATA
Definition WM_types.hh:552
#define BLI_assert_unreachable()
#define ELEM(...)
Definition scene.h:133
Span< T > as_span() const
Definition BLI_array.hh:254
static IndexMask from_predicate(const IndexMask &universe, LinearAllocator<> &memory, Fn &&predicate, exec_mode::Mode mode=exec_mode::parallel)
static IndexMask from_ranges(OffsetIndices< T > offsets, const IndexMask &mask, LinearAllocator<> &memory)
static IndexMask from_intersection(const IndexMask &mask_a, const IndexMask &mask_b, LinearAllocator<> &memory)
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr bool is_empty() const
Definition BLI_span.hh:264
bool add(const Key &key)
int64_t size() const
IndexRange index_range() const
void resize(const int64_t new_size)
MutableSpan< T > as_mutable_span()
GAttributeReader lookup_or_default(StringRef name, AttrDomain domain, AttrType data_type, const void *default_value=nullptr) const
std::optional< Span< float3 > > handle_positions_right() const
std::optional< Span< float3 > > handle_positions_left() const
OffsetIndices< int > points_by_curve() const
std::optional< GroupedSpan< int > > fills() const
const bke::CurvesGeometry & strokes() const
float4x4 to_world_space(const Object &object) const
void foreach_editable_drawing_with_automask(const bContext &C, FunctionRef< bool(const GreasePencilStrokeParams &params, const IndexMask &points)> fn) const
void init_stroke(const bContext &C, const InputSample &start_sample)
void init_auto_masking(const bContext &C, const InputSample &start_sample)
void foreach_editable_drawing(const bContext &C, FunctionRef< bool(const GreasePencilStrokeParams &params, const DeltaProjectionFunc &projection_fn)> fn) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
#define FLT_MAX
#define position
#define layer
float distance(float, float) RET
float distance_squared(VecT a, VecT b)
void gather(const GVArray &src, const IndexMask &indices, GMutableSpan dst, exec_mode::Mode mode=exec_mode::parallel)
GeometryDeformation get_evaluated_grease_pencil_drawing_deformation(const Object *ob_eval, const Object &ob_orig, const bke::greasepencil::Drawing &drawing_orig)
IndexMask retrieve_editable_and_selected_strokes(Object &object, const bke::greasepencil::Drawing &drawing, int layer_index, IndexMaskMemory &memory)
IndexMask retrieve_editable_points(Object &object, const bke::greasepencil::Drawing &drawing, int layer_index, IndexMaskMemory &memory)
Vector< MutableDrawingInfo > retrieve_editable_drawings_from_layer_with_falloff(const Scene &scene, GreasePencil &grease_pencil, const bke::greasepencil::Layer &layer)
IndexMask retrieve_editable_and_selected_points(Object &object, const bke::greasepencil::Drawing &drawing, int layer_index, IndexMaskMemory &memory)
Vector< MutableDrawingInfo > retrieve_editable_drawings_with_falloff(const Scene &scene, GreasePencil &grease_pencil)
IndexMask retrieve_editable_strokes(Object &object, const bke::greasepencil::Drawing &drawing, int layer_index, IndexMaskMemory &memory)
IndexMask curve_mask_for_stroke_operation(const GreasePencilStrokeParams &params, bool use_selection_masking, IndexMaskMemory &memory)
Vector< ed::greasepencil::MutableDrawingInfo > get_drawings_for_stroke_operation(const bContext &C)
Array< float2 > view_positions_left_from_point_mask(const GreasePencilStrokeParams &params, const IndexMask &selection)
bool is_brush_inverted(const Brush &brush, BrushStrokeMode stroke_mode)
float closest_distance_to_surface_2d(const float2 pt, const Span< float2 > verts)
Array< float2 > view_positions_right_from_point_mask(const GreasePencilStrokeParams &params, const IndexMask &selection)
IndexMask fill_mask_for_stroke_operation(const GreasePencilStrokeParams &params, bool use_selection_masking, IndexMaskMemory &memory)
bool do_vertex_color_fill(const Brush &brush)
Array< float2 > view_positions_from_curve_mask(const GreasePencilStrokeParams &params, const IndexMask &curve_mask)
IndexMask point_mask_for_stroke_operation(const GreasePencilStrokeParams &params, bool use_selection_masking, IndexMaskMemory &memory)
IndexMask brush_point_influence_mask(const Paint &paint, const Brush &brush, const float2 &mouse_position, float pressure, float multi_frame_falloff, const IndexMask &selection, Span< float2 > view_positions, Vector< float > &influences, IndexMaskMemory &memory)
float brush_point_influence(const Paint &paint, const Brush &brush, const float2 &co, const InputSample &sample, float multi_frame_falloff)
Array< float2 > view_positions_from_point_mask(const GreasePencilStrokeParams &params, const IndexMask &point_mask)
bool brush_using_vertex_color(const GpPaint *gp_paint, const Brush *brush)
Vector< ed::greasepencil::MutableDrawingInfo > get_drawings_with_masking_for_stroke_operation(const bContext &C)
float brush_fill_influence(const Paint &paint, const Brush &brush, Span< float2 > fill_positions, const InputSample &sample, float multi_frame_falloff)
bke::crazyspace::GeometryDeformation get_drawing_deformation(const GreasePencilStrokeParams &params)
Array< float > view_radii_from_point_selection(const GreasePencilStrokeParams &params, const IndexMask &selection)
DeltaProjectionFunc get_screen_projection_fn(const GreasePencilStrokeParams &params, const Object &object, const bke::greasepencil::Layer &layer)
bool do_vertex_color_points(const Brush &brush)
float3 compute_orig_delta(const DeltaProjectionFunc &projection_fn, const bke::crazyspace::GeometryDeformation &deformation, int index, const float2 &screen_delta)
float brush_radius(const Paint &paint, const Brush &brush, float pressure)
std::function< float3(const float3 position, const float2 &screen_delta)> DeltaProjectionFunc
constexpr ParallelGrainSize grain_size(int grain_size)
T sqrt(const T &a)
T distance(const T &a, const T &b)
T dot(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
T min(const T &a, const T &b)
CartesianBasis invert(const CartesianBasis &basis)
T distance_squared(const VecBase< T, Size > &a, const VecBase< T, Size > &b)
T max(const T &a, const T &b)
VecBase< T, 3 > transform_direction(const MatBase< T, 3, 3 > &mat, const VecBase< T, 3 > &direction)
T round(const T &a)
VecBase< T, 3 > transform_point(const CartesianBasis &basis, const VecBase< T, 3 > &v)
void parallel_for_each(Range &&range, const Function &function)
Definition BLI_task.hh:31
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
Definition BLI_task.hh:69
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
@ GP_SCULPT_SETT_FLAG_AUTOMASK_LAYER_ACTIVE
@ GP_SCULPT_SETT_FLAG_AUTOMASK_STROKE
@ GP_SCULPT_SETT_FLAG_AUTOMASK_MATERIAL_ACTIVE
@ GP_SCULPT_SETT_FLAG_AUTOMASK_LAYER_STROKE
@ GP_SCULPT_SETT_FLAG_AUTOMASK_MATERIAL_STROKE
@ V3D_PROJ_RET_OK
Definition ED_view3d.hh:273
__int64 int64_t
Definition BKE_text.h:90
@ GP_BRUSH_MODE_VERTEXCOLOR
@ GP_SCULPT_MASK_SELECTMODE_POINT
@ GP_SCULPT_MASK_SELECTMODE_STROKE
@ GP_SCULPT_MASK_SELECTMODE_SEGMENT
Depsgraph * CTX_data_depsgraph_pointer(const bContext *C)
float ED_view3d_pixel_size(const RegionView3D *rv3d, const float co[3])
float BKE_brush_radius_get(const Paint *paint, const Brush *brush)
Definition brush.cc:1366
void BKE_brush_init_gpencil_settings(Brush *brush)
Definition brush.cc:719
MatBase< float, 4, 4 > float4x4
bool BKE_brush_use_alpha_pressure(const Brush *brush)
Definition brush.cc:1385
void BKE_curvemapping_init(CurveMapping *cumap)
VecBase< int32_t, 2 > int2
VecBase< float, 2 > float2
void DEG_id_tag_update(ID *id, unsigned int flags)
BMesh const char void * data
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
eV3DProjStatus ED_view3d_project_float_global(const ARegion *region, const float co[3], float r_co[2], eV3DProjTest flag)
float BKE_brush_curve_strength(eBrushCurvePreset preset, const CurveMapping *cumap, float distance, float brush_radius)
Definition brush.cc:1691
float ED_view3d_calc_zfac(const RegionView3D *rv3d, const float co[3])
RegionView3D * CTX_wm_region_view3d(const bContext *C)
ToolSettings * CTX_data_tool_settings(const bContext *C)
MatBase< float, 3, 3 > float3x3
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
bool BKE_brush_use_size_pressure(const Brush *brush)
Definition brush.cc:1380
Paint * BKE_paint_get_active_from_context(const bContext *C)
@ ID_RECALC_GEOMETRY
Definition DNA_ID.h:1074
@ V3D_PROJ_TEST_CLIP_FAR
Definition ED_view3d.hh:299
@ V3D_PROJ_TEST_CLIP_NEAR
Definition ED_view3d.hh:298
Brush * BKE_paint_brush(Paint *paint)
@ GPPAINT_FLAG_USE_VERTEXCOLOR
Scene * CTX_data_scene(const bContext *C)
VecBase< float, 3 > float3
Object * CTX_data_active_object(const bContext *C)
ARegion * CTX_wm_region(const bContext *C)
float BKE_curvemapping_evaluateF(const CurveMapping *cumap, int cur, float value)
void ED_view3d_win_to_delta(const ARegion *region, const float xy_delta[2], float zfac, float r_out[3], bool precise=false)
float BKE_brush_alpha_get(const Paint *paint, const Brush *brush)
Definition brush.cc:1454
eGP_Sculpt_SettingsFlag flag
View3DCursor cursor
struct ToolSettings * toolsettings
eGP_Sculpt_SelectMaskFlag gpencil_selectmode_sculpt
struct GP_Sculpt_Settings gp_sculpt
float3 translation_from_deformed_to_original(const int position_i, const float3 &translation) const
static GreasePencilStrokeParams from_context(const Scene &scene, Depsgraph &depsgraph, ARegion &region, RegionView3D &rv3d, Object &object, int layer_index, int frame_number, float multi_frame_falloff, bke::greasepencil::Drawing &drawing)
constexpr int grain_size(const int fallback) const