49 bool temp_eraser_ =
false;
51 bool keep_caps_ =
false;
53 float strength_ = 0.1f;
55 bool active_layer_only_ =
false;
60 EraseOperation(
bool temp_use_eraser =
false) : temp_eraser_(temp_use_eraser) {}
139 const int64_t c = d_s0_center - radius_2;
173 const float mu0_f = -
b / (2.0f * a);
180 const float mu0_f = (-
b + i_sqrt) / (2.0f * a);
181 const float mu1_f = (-
b - i_sqrt) / (2.0f * a);
211 const int2 &point_after,
224 point, point_after, this->mouse_position_pixels, squared_radius, mu0, mu1);
226 if (nb_intersections != 2) {
231 r_mu0 = r_mu1 = -1.0f;
246 const int8_t side_mu0 = (mu0 <= 0) ? (-1) : ((mu0 >= segment_length) ? 1 : 0);
247 const int8_t side_mu1 = (mu1 <= 0) ? (-1) : ((mu1 >= segment_length) ? 1 : 0);
254 r_point_after_side = (mu0 == segment_length) ?
260 r_mu0 = mu0 /
float(segment_length);
261 r_mu1 = mu1 /
float(segment_length);
263 const bool is_mu0_inside = (side_mu0 == 0);
264 const bool is_mu1_inside = (side_mu1 == 0);
265 if (!is_mu0_inside && !is_mu1_inside) {
268 if (side_mu0 == side_mu1) {
281 if (is_mu0_inside && is_mu1_inside) {
290 const int8_t side_outside_intersection = is_mu0_inside ? side_mu1 : side_mu0;
294 r_point_after_side = (side_outside_intersection == 1) ? r_point_after_side :
298 std::swap(r_mu0, r_mu1);
324 MutableSpan<std::pair<int, PointCircleSide>> r_point_ring,
329 const int intersections_max_per_segment = rings.
size() * 2;
335 for (const int src_point : src_points) {
336 const float2 pos = screen_space_positions[src_point];
337 screen_space_positions_pixel[src_point] = int2(round_fl_to_int(pos[0]),
338 round_fl_to_int(pos[1]));
343 for (const int src_curve : src_curves) {
344 const IndexRange src_curve_points = src_points_by_curve[src_curve];
346 if (src_curve_points.size() == 1) {
349 for (const EraserRing &eraser_point : rings) {
350 const int src_point = src_curve_points.first();
351 const int64_t squared_distance = math::distance_squared(
352 this->mouse_position_pixels, screen_space_positions_pixel[src_point]);
356 if ((r_point_ring[src_point].first == -1) &&
357 (squared_distance <= eraser_point.squared_radius))
359 r_point_ring[src_point] = {ring_index, PointCircleSide::Inside};
366 for (const int src_point : src_curve_points.drop_back(1)) {
368 int intersection_offset = src_point * intersections_max_per_segment - 1;
370 for (const EraserRing &eraser_point : rings) {
371 SegmentCircleIntersection inter0;
372 SegmentCircleIntersection inter1;
374 inter0.ring_index = ring_index;
375 inter1.ring_index = ring_index;
377 PointCircleSide point_side;
378 PointCircleSide point_after_side;
380 const int8_t nb_inter = segment_intersections_and_points_sides(
381 screen_space_positions_pixel[src_point],
382 screen_space_positions_pixel[src_point + 1],
383 eraser_point.squared_radius,
394 if ((r_point_ring[src_point].first == -1) &&
395 ELEM(point_side, PointCircleSide::Inside, PointCircleSide::InsideOutsideBoundary))
397 r_point_ring[src_point] = {ring_index, point_side};
400 if (src_point + 1 == src_curve_points.last()) {
401 if ((r_point_ring[src_point + 1].first == -1) &&
402 ELEM(point_after_side,
403 PointCircleSide::Inside,
404 PointCircleSide::InsideOutsideBoundary))
406 r_point_ring[src_point + 1] = {ring_index, point_after_side};
411 inter0.inside_outside_intersection = (inter0.factor > inter1.factor);
412 r_intersections[++intersection_offset] = inter0;
415 inter1.inside_outside_intersection = true;
416 r_intersections[++intersection_offset] = inter1;
424 if (src_cyclic[src_curve]) {
426 const int src_last_point = src_curve_points.last();
427 const int src_first_point = src_curve_points.first();
429 int intersection_offset = src_last_point * intersections_max_per_segment - 1;
431 for (const EraserRing &eraser_point : rings) {
432 SegmentCircleIntersection inter0;
433 SegmentCircleIntersection inter1;
435 inter0.ring_index = ring_index;
436 inter1.ring_index = ring_index;
438 PointCircleSide point_side;
439 PointCircleSide point_after_side;
441 const int8_t nb_inter = segment_intersections_and_points_sides(
442 screen_space_positions_pixel[src_last_point],
443 screen_space_positions_pixel[src_first_point],
444 eraser_point.squared_radius,
454 inter0.inside_outside_intersection = (inter0.factor > inter1.factor);
455 r_intersections[++intersection_offset] = inter0;
458 inter1.inside_outside_intersection = true;
459 r_intersections[++intersection_offset] = inter1;
470 int total_intersections = 0;
471 for (
const SegmentCircleIntersection &intersection : r_intersections) {
472 if (intersection.is_valid()) {
473 total_intersections++;
477 return total_intersections;
489 &ob, stroke_material[src_curve] + 1);
495 for (
const int src_point : src_points) {
496 const int src_next_point = (src_point == src_points.
last()) ? src_points.
first() :
498 src_to_dst_points[src_point].append(
499 {src_point, src_next_point, 0.0f,
true,
false, point_opacity[src_point]});
512 const bool keep_caps)
const
520 1, {this->eraser_radius, this->eraser_squared_radius_pixels, 0.0f,
true});
521 const int intersections_max_per_segment = eraser_rings.
size() * 2;
527 intersections_max_per_segment);
529 src, screen_space_positions, eraser_rings, src_point_ring, src_intersections);
540 const IndexRange src_points = src_points_by_curve[src_curve];
543 ob, src_curve, src_points, stroke_material, point_opacity, src_to_dst_points))
548 for (
const int src_point : src_points) {
550 const int src_next_point = (src_point == src_points.
last()) ? src_points.
first() :
556 dst_points.
append({src_point,
564 const IndexRange src_point_intersections(src_point * intersections_max_per_segment,
565 intersections_max_per_segment);
567 src_intersections.
as_span().slice(src_point_intersections))
569 if (!intersection.is_valid()) {
573 dst_points.
append({src_point,
577 intersection.inside_outside_intersection});
602 const int step_pixels = 2;
603 int nb_samples =
math::round(this->eraser_radius / step_pixels);
605 for (
const int sample_index : eraser_rings.
index_range()) {
606 const int64_t sampled_distance = (sample_index + 1) * step_pixels;
608 EraserRing &ring = eraser_rings[sample_index];
609 ring.
radius = sampled_distance;
611 ring.
opacity = 1.0 - this->eraser_strength *
613 this->brush_,
float(sampled_distance), this->eraser_radius);
618 for (
const int sample_index : eraser_rings.
index_range()) {
621 if (sample_index == nb_samples - 1) {
628 EraserRing next_sample = eraser_rings[sample_index + 1];
640 const EraserRing &sample_after = eraser_rings[sample_index + 1];
649 sample.squared_radius = radius * radius;
654 for (
const int rev_sample_index : eraser_rings.
index_range()) {
655 const int sample_index = nb_samples - rev_sample_index - 1;
656 if (prune_sample[sample_index]) {
657 eraser_rings.
remove(sample_index);
662 nb_samples = eraser_rings.
size();
668 const EraserRing &sample_first = eraser_rings[first_index];
669 const EraserRing &sample_last = eraser_rings[last_index];
683 const float distance_threshold = 0.1f;
685 eraser_rings.
index_range(), distance_threshold, opacity_distance, simplify_sample);
687 for (
const int rev_sample_index : eraser_rings.
index_range()) {
688 const int sample_index = nb_samples - rev_sample_index - 1;
689 if (simplify_sample[sample_index]) {
690 eraser_rings.
remove(sample_index);
708 const bool keep_caps)
711 const std::string opacity_attr =
"opacity";
716 const int intersections_max_per_segment = eraser_rings.
size() * 2;
724 intersections_max_per_segment);
726 src, screen_space_positions, eraser_rings, src_point_ring, src_intersections);
734 const auto compute_opacity = [&](
const int src_point) {
736 this->mouse_position);
737 const float brush_strength = this->eraser_strength *
739 this->brush_,
distance, this->eraser_radius);
740 return math::clamp(src_opacity[src_point] - brush_strength, 0.0f, 1.0f);
751 const IndexRange src_points = src_points_by_curve[src_curve];
754 ob, src_curve, src_points, stroke_material, src_opacity, src_to_dst_points))
758 for (
const int src_point : src_points) {
760 const int src_next_point = (src_point == src_points.
last()) ? src_points.
first() :
765 const int point_ring = src_point_ring[src_point].first;
766 const bool ring_is_cut = (point_ring != -1) && eraser_rings[point_ring].hard_erase;
769 const bool point_is_cut = ring_is_cut &&
774 {src_point, src_next_point, 0.0f,
true, point_is_cut, compute_opacity(src_point)});
777 const IndexRange src_point_intersections(src_point * intersections_max_per_segment,
778 intersections_max_per_segment);
780 std::sort(src_intersections.
begin() + src_point_intersections.
first(),
781 src_intersections.
begin() + src_point_intersections.
last() + 1,
783 return a.factor < b.factor;
788 src_intersections.
as_span().slice(src_point_intersections))
790 if (!intersection.is_valid()) {
795 const EraserRing &ring = eraser_rings[intersection.ring_index];
796 const bool is_cut = intersection.inside_outside_intersection && ring.
hard_erase;
798 src_opacity[src_point], src_opacity[src_next_point], intersection.factor);
803 if (is_cut && !dst_points.
is_empty() && dst_points.
last().is_cut) {
808 {src_point, src_next_point, intersection.factor,
false, is_cut, opacity});
814 src, dst, src_to_dst_points, keep_caps);
829 for (const int dst_point_index : dst_points_range) {
830 const ed::greasepencil::PointTransferData &dst_point = dst_points[dst_point_index];
831 dst_opacity.span[dst_point_index] = dst_point.opacity;
833 if (!dst_point.is_src_point || dst_point.opacity != src_opacity[dst_point.src_point]) {
834 opacity_modified.span[dst_point_index] = true;
838 dst_opacity.finish();
839 opacity_modified.finish();
847 for (const int dst_curve : dst_curves_range) {
848 IndexRange dst_points_range = dst_points_by_curve[dst_curve];
850 dst_inserted.span[dst_points_range.first()] = false;
851 dst_inserted.span[dst_points_range.last()] = false;
853 if (dst_points_range.size() < 3) {
857 for (const int dst_point_index : dst_points_range.drop_back(1).drop_front(1)) {
858 const ed::greasepencil::PointTransferData &dst_point = dst_points[dst_point_index];
859 dst_inserted.span[dst_point_index] |= !dst_point.is_src_point;
881 const MaterialGPencilStyle *mat = BKE_gpencil_material_settings(
882 &ob, stroke_materials[src_curve] + 1);
884 if (mat->flag & GP_MATERIAL_LOCKED) {
888 const IndexRange src_curve_points = src_points_by_curve[src_curve];
891 if (src_curve_points.size() == 1) {
892 const float2 &point_pos = screen_space_positions[src_curve_points.first()];
893 const float dist_to_eraser = math::distance(point_pos, this->mouse_position);
894 return !(dist_to_eraser < this->eraser_radius);
899 for (
const int src_point : src_curve_points.drop_back(1)) {
900 const float dist_to_eraser = dist_to_line_segment_v2(
901 this->mouse_position,
902 screen_space_positions[src_point],
903 screen_space_positions[src_point + 1]);
904 if (dist_to_eraser < this->eraser_radius) {
909 if (src_cyclic[src_curve]) {
911 this->mouse_position,
912 screen_space_positions[src_curve_points.first()],
913 screen_space_positions[src_curve_points.last()]);
914 if (dist_to_eraser < this->eraser_radius) {
922 if (strokes_to_keep.size() == src.curves_num()) {
941 this->eraser_radius = self.radius_;
942 this->eraser_strength = self.strength_;
952 this->brush_ = self.eraser_brush_;
957 this->eraser_squared_radius_pixels = eraser_radius_pixels * eraser_radius_pixels;
962 bool changed =
false;
963 const auto execute_eraser_on_drawing = [&](
const int layer_index,
Drawing &drawing) {
970 ob_eval, *obact, drawing);
975 for (const int src_point : src_points) {
976 const int result = ED_view3d_project_float_global(
978 math::transform_point(layer.to_world_space(*ob_eval),
979 deformation.positions[src_point]),
980 screen_space_positions[src_point],
981 V3D_PROJ_TEST_CLIP_NEAR | V3D_PROJ_TEST_CLIP_FAR);
982 if (result != V3D_PROJ_RET_OK) {
986 screen_space_positions[src_point] = float2(1e20);
994 switch (self.eraser_mode_) {
996 erased =
stroke_eraser(*obact, src, screen_space_positions, dst);
999 erased =
hard_eraser(*obact, src, screen_space_positions, dst, self.keep_caps_);
1002 erased =
soft_eraser(*obact, src, screen_space_positions, dst, self.keep_caps_);
1008 drawing.strokes_for_write() = std::move(dst);
1009 drawing.tag_topology_changed();
1011 self.affected_drawings_.add(&drawing);
1015 if (self.active_layer_only_) {
1023 if (drawing ==
nullptr) {
1027 execute_eraser_on_drawing(*
grease_pencil.get_layer_index(active_layer), *drawing);
1034 execute_eraser_on_drawing(info.layer_index, info.drawing);
1050 eraser_brush_ =
brush;
1061 std::optional<AssetWeakReference> asset_reference =
1065 if (asset_reference) {
1066 Brush *eraser_brush =
reinterpret_cast<Brush *
>(
1069 eraser_brush_ = eraser_brush;
1078 if (eraser_brush_->gpencil_settings ==
nullptr) {
1081 BLI_assert(eraser_brush_->gpencil_settings !=
nullptr);
1089 strength_ = eraser_brush_->alpha;
1095 executor.
execute(*
this,
C, extension_sample);
1100 const float epsilon)
1114 const float3 &s0 = positions[first_index];
1115 const float3 &s1 = positions[last_index];
1117 if (segment_length < 1
e-6) {
1122 opacities[first_index], opacities[last_index], t);
1130 range_to_simplify, epsilon, opacity_distance, dissolve_points);
1135 curves.remove_points(points_to_dissolve, {});
1140 const float epsilon)
1144 if (!point_was_modified) {
1151 return opacities[point] < epsilon && point_was_modified[point];
1183 affected_drawings_.clear();
1191 return std::make_unique<EraseOperation>(temp_eraser);
Low-level operations for curves.
Low-level operations for grease pencil.
General operations, lookup, etc. for materials.
#define IN_RANGE(a, b, c)
Span< T > as_span() const
static IndexMask from_predicate(const IndexMask &universe, LinearAllocator<> &memory, Fn &&predicate, exec_mode::Mode mode=exec_mode::parallel)
static IndexMask from_bools(Span< bool > bools, LinearAllocator<> &memory)
constexpr int64_t one_before_start() const
constexpr int64_t first() const
constexpr int64_t last(const int64_t n=0) const
constexpr int64_t size() const
constexpr int64_t size() const
void append(const T &value)
const T & last(const int64_t n=0) const
void remove(const int64_t index)
IndexRange index_range() const
GAttributeReader lookup_or_default(StringRef name, AttrDomain domain, AttrType data_type, const void *default_value=nullptr) const
bool contains(StringRef name) const
VArray< bool > cyclic() const
AttributeAccessor attributes() const
IndexRange curves_range() const
IndexRange points_range() const
OffsetIndices< int > points_by_curve() const
MutableAttributeAccessor attributes_for_write()
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
bool remove(const StringRef name)
bke::CurvesGeometry & strokes_for_write()
const bke::CurvesGeometry & strokes() const
void tag_topology_changed()
VArray< float > opacities() const
~EraseOperation() override=default
void on_stroke_done(const bContext &C) override
void on_stroke_extended(const bContext &C, const InputSample &extension_sample) override
EraseOperation(bool temp_use_eraser=false)
friend struct EraseOperationExecutor
void on_stroke_begin(const bContext &C, const InputSample &start_sample) override
void foreach_range(ForeachRangeFn auto &&fn) const
float distance(float, float) RET
GeometryDeformation get_evaluated_grease_pencil_drawing_deformation(const Object *ob_eval, const Object &ob_orig, const bke::greasepencil::Drawing &drawing_orig)
ID * asset_edit_id_from_weak_reference(Main &global_main, ID_Type id_type, const AssetWeakReference &weak_ref)
CurvesGeometry curves_copy_curve_selection(const CurvesGeometry &curves, const IndexMask &curves_to_copy, const AttributeFilter &attribute_filter)
int64_t ramer_douglas_peucker_simplify(const IndexRange range, const float epsilon, const FunctionRef< float(int64_t, int64_t, int64_t)> dist_function, MutableSpan< bool > points_to_delete)
Array< PointTransferData > compute_topology_change(const bke::CurvesGeometry &src, bke::CurvesGeometry &dst, const Span< Vector< PointTransferData > > src_to_dst_points, const bool keep_caps)
Vector< MutableDrawingInfo > retrieve_editable_drawings(const Scene &scene, GreasePencil &grease_pencil)
static void simplify_opacities(bke::CurvesGeometry &curves, const VArray< float > &opacities, const float epsilon)
std::unique_ptr< GreasePencilStrokeOperation > new_erase_operation(const bool temp_eraser)
static void remove_points_with_low_opacity(bke::CurvesGeometry &curves, const VArray< float > &opacities, const float epsilon)
bke::CurvesGeometry grease_pencil_remove_points_and_split(const bke::CurvesGeometry &curves, const IndexMask &mask)
T clamp(const T &a, const T &min, const T &max)
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)
T interpolate(const T &a, const T &b, const FactorT &t)
T distance_squared(const VecBase< T, Size > &a, const VecBase< T, Size > &b)
T max(const T &a, const T &b)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
float dist_to_line_segment_v2(const float p[2], const float l1[2], const float l2[2])
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
std::optional< AssetWeakReference > WM_toolsystem_last_brush_asset_from_brush_type(Scene *scene, const int brush_type, const PaintMode paint_mode)
MINLINE int round_fl_to_int(float a)
Depsgraph * CTX_data_depsgraph_pointer(const bContext *C)
float BKE_brush_radius_get(const Paint *paint, const Brush *brush)
void BKE_brush_init_gpencil_settings(Brush *brush)
bool BKE_brush_use_alpha_pressure(const Brush *brush)
MaterialGPencilStyle * BKE_gpencil_material_settings(Object *ob, short act)
void BKE_curvemapping_init(CurveMapping *cumap)
@ GPAINT_BRUSH_TYPE_ERASE
VecBase< int32_t, 2 > int2
VecBase< float, 2 > float2
void DEG_id_tag_update(ID *id, unsigned int flags)
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
float BKE_brush_curve_strength(eBrushCurvePreset preset, const CurveMapping *cumap, float distance, float brush_radius)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
bool BKE_brush_use_size_pressure(const Brush *brush)
Main * CTX_data_main(const bContext *C)
Paint * BKE_paint_get_active_from_context(const bContext *C)
Brush * BKE_paint_brush(Paint *paint)
Scene * CTX_data_scene(const bContext *C)
VecBase< float, 3 > float3
@ GP_BRUSH_ERASER_KEEP_CAPS
@ GP_BRUSH_ACTIVE_LAYER_ONLY
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)
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct CurveMapping * curve_strength
struct BrushGpencilSettings * gpencil_settings
eMaterialGPencilStyle_Flag flag
static int8_t intersections_segment_circle_integers(const int2 &s0, const int2 &s1, const int2 ¢er, const int64_t radius_2, int64_t &r_mu0, int64_t &r_mu1)
static constexpr float opacity_threshold
Vector< EraserRing > compute_piecewise_linear_falloff() const
int64_t eraser_squared_radius_pixels
bool hard_eraser(Object &ob, const bke::CurvesGeometry &src, const Span< float2 > screen_space_positions, bke::CurvesGeometry &dst, const bool keep_caps) const
void execute(EraseOperation &self, const bContext &C, const InputSample &extension_sample)
bool soft_eraser(Object &ob, const bke::CurvesGeometry &src, const Span< float2 > screen_space_positions, bke::CurvesGeometry &dst, const bool keep_caps)
static bool skip_strokes_with_locked_material(Object &ob, const int src_curve, const IndexRange &src_points, const VArray< int > stroke_material, const VArray< float > &point_opacity, Array< Vector< ed::greasepencil::PointTransferData > > &src_to_dst_points)
int2 mouse_position_pixels
int8_t segment_intersections_and_points_sides(const int2 &point, const int2 &point_after, const int64_t squared_radius, float &r_mu0, float &r_mu1, PointCircleSide &r_point_side, PointCircleSide &r_point_after_side) const
int curves_intersections_and_points_sides(const bke::CurvesGeometry &src, const Span< float2 > screen_space_positions, const Span< EraserRing > rings, MutableSpan< std::pair< int, PointCircleSide > > r_point_ring, MutableSpan< SegmentCircleIntersection > r_intersections) const
EraseOperationExecutor(const bContext &)
bool stroke_eraser(Object &ob, const bke::CurvesGeometry &src, const Span< float2 > screen_space_positions, bke::CurvesGeometry &dst) const
bool inside_outside_intersection