41#include "RNA_prototypes.hh"
54 : region_(®ion), view3d_(&
view3d)
56 layer_space_to_world_space_ = (
layer !=
nullptr) ?
layer->to_world_space(eval_object) :
57 eval_object.object_to_world();
58 world_space_to_layer_space_ =
math::invert(layer_space_to_world_space_);
61 case GP_LOCKAXIS_VIEW:
62 plane_ = DrawingPlacementPlane::View;
65 plane_ = DrawingPlacementPlane::Front;
66 placement_normal_ = float3(0, 1, 0);
69 plane_ = DrawingPlacementPlane::Side;
70 placement_normal_ = float3(1, 0, 0);
73 plane_ = DrawingPlacementPlane::Top;
74 placement_normal_ = float3(0, 0, 1);
76 case GP_LOCKAXIS_CURSOR: {
77 plane_ = DrawingPlacementPlane::Cursor;
78 placement_normal_ = scene.cursor.matrix<float3x3>() * float3(0, 0, 1);
86 placement_normal_ = math::transform_direction(math::transpose(world_space_to_layer_space_),
91 const char align_flag = scene.toolsettings->gpencil_v3d_align;
95 surface_offset_ = 0.0f;
96 placement_loc_ =
float3(scene.cursor.location);
101 use_project_only_selected_ =
true;
103 surface_offset_ = scene.toolsettings->gpencil_surface_offset;
105 placement_loc_ = layer_space_to_world_space_.location();
109 surface_offset_ = 0.0f;
111 placement_loc_ = layer_space_to_world_space_.location();
115 surface_offset_ = 0.0f;
116 placement_loc_ = layer_space_to_world_space_.location();
121 surface_offset_ = 0.0f;
122 placement_loc_ =
float3(0.0f);
126 placement_plane_ =
float4();
134 const Object &eval_object,
137 const float surface_offset,
141 depth_cache_(view_depths),
142 surface_offset_(surface_offset)
144 layer_space_to_world_space_ = (
layer !=
nullptr) ?
layer->to_world_space(eval_object) :
145 eval_object.object_to_world();
146 world_space_to_layer_space_ =
math::invert(layer_space_to_world_space_);
154 placement_normal_ =
float3(0, 1, 0);
158 placement_normal_ =
float3(1, 0, 0);
162 placement_normal_ =
float3(0, 0, 1);
181 switch (reproject_mode) {
184 surface_offset_ = 0.0f;
189 surface_offset_ = 0.0f;
190 placement_loc_ = layer_space_to_world_space_.location();
194 placement_loc_ = layer_space_to_world_space_.location();
198 surface_offset_ = 0.0f;
199 placement_loc_ = layer_space_to_world_space_.location();
204 placement_plane_ =
float4();
211 region_ = other.region_;
212 view3d_ = other.view3d_;
214 depth_ = other.depth_;
215 plane_ = other.plane_;
217 if (other.depth_cache_ !=
nullptr) {
218 depth_cache_ = MEM_dupalloc(other.depth_cache_);
219 depth_cache_->depths = MEM_dupalloc(other.depth_cache_->
depths);
221 use_project_only_selected_ = other.use_project_only_selected_;
223 surface_offset_ = other.surface_offset_;
225 placement_loc_ = other.placement_loc_;
226 placement_normal_ = other.placement_normal_;
227 placement_plane_ = other.placement_plane_;
229 layer_space_to_world_space_ = other.layer_space_to_world_space_;
230 world_space_to_layer_space_ = other.world_space_to_layer_space_;
235 region_ = other.region_;
236 view3d_ = other.view3d_;
238 depth_ = other.depth_;
239 plane_ = other.plane_;
241 std::swap(depth_cache_, other.depth_cache_);
242 use_project_only_selected_ = other.use_project_only_selected_;
244 surface_offset_ = other.surface_offset_;
246 placement_loc_ = other.placement_loc_;
247 placement_normal_ = other.placement_normal_;
248 placement_plane_ = other.placement_plane_;
250 layer_space_to_world_space_ = other.layer_space_to_world_space_;
251 world_space_to_layer_space_ = other.world_space_to_layer_space_;
256 if (
this == &other) {
259 std::destroy_at(
this);
266 if (
this == &other) {
269 std::destroy_at(
this);
276 if (depth_cache_ !=
nullptr) {
297 if (use_project_only_selected_) {
312 view3d->gp_flag = previous_gp_flag;
317 std::optional<float> depth =
get_depth(co);
326 proj_point -= view_normal * surface_offset_;
341float3 DrawingPlacement::try_project_depth(
const float2 co)
const
343 if (std::optional<float3> proj_point = this->
project_depth(co)) {
358 proj_point = this->try_project_depth(co);
362 if (placement_plane_) {
374 [[maybe_unused]]
bool clipped_unused;
375 return this->
project(co, clipped_unused);
383 proj_point = this->try_project_depth(co);
386 if (placement_plane_) {
399 for (const int i : range) {
400 dst[i] = this->project(src[i]);
413 loc -= view_normal * surface_offset_;
431 proj_point = this->try_project_depth(co);
445 if (placement_plane_) {
446 plane = *placement_plane_;
454 proj_point = world_pos + ray_no * lambda;
466 for (const int i : range) {
467 dst[i] = this->reproject(src[i]);
474 return layer_space_to_world_space_;
478 const int frame_number,
479 const int active_frame,
483 if (!use_multi_frame_falloff || !frame_bounds.has_value() || falloff_curve ==
nullptr) {
487 const int min_frame = frame_bounds->min;
488 const int max_frame = frame_bounds->max;
491 if (frame_number < active_frame) {
492 const float frame_factor = 0.5f *
float(frame_number - min_frame) / (active_frame - min_frame);
496 if (frame_number > active_frame) {
497 const float frame_factor = 0.5f *
float(frame_number - active_frame) /
498 (max_frame - active_frame);
509 if (!
layer.is_editable()) {
513 for (
const auto [frame_number, frame] :
layer.frames().items()) {
514 if (frame.is_selected()) {
515 frame_numbers.
append(frame_number);
523 const int current_frame)
525 const std::optional<int> current_start_frame =
layer.start_frame_at(current_frame);
526 if (current_start_frame) {
527 return *current_start_frame;
530 return math::clamp(current_frame, frame_bounds->min, frame_bounds->max);
533 return current_frame;
538 const int frame_number,
539 const int frame_index,
540 const int current_frame,
541 const int current_frame_index,
542 const int last_frame,
543 const int last_frame_index,
544 const bool use_multi_frame_editing,
545 const bool do_onion_skinning,
546 const bool is_before_first,
549 if (use_multi_frame_editing) {
550 if (frame.is_selected()) {
551 if (do_onion_skinning) {
552 return (frame_number < current_frame) ? -1 : 1;
558 if (do_onion_skinning &&
layer.use_onion_skinning()) {
560 if (onion_settings.
filter != 0 && (onion_settings.
filter & (1 << frame.
type)) == 0) {
570 delta = frame_number - current_frame;
573 delta = frame_index - current_frame_index;
576 if (is_before_first) {
589 shift = last_frame_index;
591 delta += (delta < 0) ? (shift + 1) : -(shift + 1);
610 const int current_frame,
611 const bool use_multi_frame_editing,
612 const bool do_onion_skinning)
620 const int current_frame_index = std::max(
layer.sorted_keys_index_at(current_frame), 0);
621 const int last_frame = sorted_keys.
last();
623 const bool is_before_first = (current_frame < sorted_keys.
first());
624 const std::optional<int> current_start_frame =
layer.start_frame_at(current_frame);
625 for (
const int frame_i : sorted_keys.
index_range()) {
626 const int frame_number = sorted_keys[frame_i];
627 if (current_start_frame && *current_start_frame == frame_number) {
639 use_multi_frame_editing,
643 if (!frame_id.has_value()) {
648 frame_numbers.
append({frame_number, *frame_id});
651 frame_numbers.
append({current_frame, 0});
653 return frame_numbers.
as_span();
658 const int current_frame,
659 const bool use_multi_frame_editing)
664 if (use_multi_frame_editing) {
666 for (
const auto [frame_number, frame] :
layer.frames().items()) {
667 if (!frame.is_selected()) {
670 frame_numbers.
append(frame_number);
673 if (added_drawings.
contains(current_drawing)) {
674 return frame_numbers.
as_span();
678 frame_numbers.
append(current_frame);
679 return frame_numbers.
as_span();
686 const int current_frame = scene.
r.
cfra;
688 const bool use_multi_frame_editing = (toolsettings->
gpencil_flags &
695 if (!
layer.is_editable()) {
700 for (
const int frame_number : frame_numbers) {
702 editable_drawings.
append({*drawing, layer_i, frame_number, 1.0f});
707 return editable_drawings;
714 const int current_frame = scene.
r.
cfra;
716 const bool use_multi_frame_editing = (toolsettings->
gpencil_flags &
718 const bool use_multi_frame_falloff = use_multi_frame_editing &&
721 if (use_multi_frame_falloff) {
729 if (!
layer.is_editable()) {
736 for (
const int frame_number : frame_numbers) {
743 editable_drawings.
append({*drawing, layer_i, frame_number, falloff});
748 return editable_drawings;
755 int current_frame = scene.
r.
cfra;
757 const bool use_multi_frame_editing = (toolsettings->
gpencil_flags &
759 const bool use_multi_frame_falloff = use_multi_frame_editing &&
762 if (use_multi_frame_falloff) {
769 if (use_multi_frame_editing) {
772 if (!
layer.is_editable()) {
775 for (
const auto [frame_number, frame] :
layer.frames().items()) {
776 if (frame_number != current_frame && frame.is_selected()) {
777 selected_frames.
add(frame_number);
782 selected_frames.
add(current_frame);
789 if (!
layer.is_editable()) {
796 if (use_multi_frame_editing) {
797 for (
const auto [frame_number, frame] :
layer.frames().items()) {
799 if (!frame.is_selected() || drawing ==
nullptr || added_drawings.
contains(drawing)) {
807 const int frame_group = selected_frames.
index_of(frame_number);
808 drawings_grouped_per_frame[frame_group].append({*drawing, layer_i, frame_number, falloff});
809 added_drawings.
add_new(drawing);
815 if (current_drawing !=
nullptr && !added_drawings.
contains(current_drawing)) {
821 const int frame_group = selected_frames.
index_of(current_frame);
822 drawings_grouped_per_frame[frame_group].append(
823 {*current_drawing, layer_i, current_frame, falloff});
824 added_drawings.
add_new(current_drawing);
828 return drawings_grouped_per_frame;
835 const int current_frame = scene.
r.
cfra;
837 const bool use_multi_frame_editing = (toolsettings->
gpencil_flags &
844 for (
const int frame_number : frame_numbers) {
846 editable_drawings.
append({*drawing, layer_index, frame_number, 1.0f});
850 return editable_drawings;
857 const int current_frame = scene.
r.
cfra;
859 const bool use_multi_frame_editing = (toolsettings->
gpencil_flags &
861 const bool use_multi_frame_falloff = use_multi_frame_editing &&
865 std::optional<Bounds<int>> frame_bounds;
866 if (use_multi_frame_falloff) {
876 for (
const int frame_number : frame_numbers) {
883 editable_drawings.
append({*drawing, layer_index, frame_number, falloff});
887 return editable_drawings;
892 const bool do_onion_skinning)
897 const bool use_multi_frame_editing = (toolsettings->
gpencil_flags &
904 if (!
layer.is_visible()) {
909 for (
const auto &[frame_number, onion_id] : frames) {
911 visible_drawings.
append({*drawing, layer_i, frame_number, onion_id});
916 return visible_drawings;
923 for (
const int mat_i :
IndexRange(
object.totcol)) {
926 if (material !=
nullptr && material->gp_style !=
nullptr &&
930 locked_material_indices.
add_new(mat_i);
933 return locked_material_indices;
940 for (
const int mat_i :
IndexRange(
object.totcol)) {
942 if (material !=
nullptr && material->gp_style !=
nullptr &&
945 hidden_material_indices.
add_new(mat_i);
948 return hidden_material_indices;
959 if (
object.totcol == 0) {
967 if (
layer.ignore_locked_materials()) {
973 if (locked_material_indices.
is_empty()) {
982 if (locked_material_indices.
contains(0)) {
989 return !locked_material_indices.
contains(materials[curve_i]);
999 object, drawing, layer_index, memory);
1014 curves_range, memory, [&](
const int64_t curve_i) {
return fill_ids[curve_i] != 0; });
1035 if (locked_material_indices.
contains(0)) {
1038 return curves_range;
1042 const int material_index = materials[curve_i];
1043 if (material_index == mat_i) {
1044 return !locked_material_indices.
contains(material_index);
1058 if (
object.totcol == 0) {
1066 if (
layer.ignore_locked_materials()) {
1072 if (locked_material_indices.
is_empty()) {
1073 return points_range;
1082 if (locked_material_indices.
contains(0)) {
1085 return points_range;
1089 return !locked_material_indices.
contains(materials[point_i]);
1116 if (hidden_material_indices.
is_empty()) {
1128 const int material_index = materials[curve_i];
1129 return !hidden_material_indices.
contains(material_index);
1140 if (hidden_material_indices.
is_empty()) {
1151 if (
const std::optional<int> single_material = materials.
get_if_single()) {
1152 if (!hidden_material_indices.
contains(*single_material)) {
1153 return points_range;
1160 const int material_index = materials[point_i];
1161 return !hidden_material_indices.
contains(material_index);
1177 const std::array<int, CURVE_TYPES_NUM> type_counts =
curves.curve_type_counts();
1183 object, drawing, memory);
1199 object, drawing, memory);
1225 object, drawing, memory);
1228 return visible_bezier_strokes;
1242 const std::optional<GroupedSpan<int>> fills = drawing.
fills();
1247 if (hidden_material_indices.
is_empty()) {
1248 return fills->index_range();
1258 const Span<int> fill = (*fills)[fill_index];
1259 const int curve_i = fill.first();
1260 const int material_index = materials[curve_i];
1261 return !hidden_material_indices.contains(material_index);
1267 const int layer_index,
1296 object, drawing, layer_index, memory);
1300 const bool is_selected = selected_point[point_i] || selected_left[point_i] ||
1301 selected_right[point_i];
1302 const bool is_bezier = types[point_to_curve_map[point_i]] == CURVE_TYPE_BEZIER;
1303 return is_selected && is_bezier;
1311 const int layer_index,
1322 object, drawing, layer_index, handle_display, memory);
1335 object, drawing, layer_index, memory);
1349 object, drawing, layer_index, memory);
1376 object, drawing, layer_index, memory);
1380 object, drawing, layer_index, memory);
1387 const int layer_index,
1395 curves, handle_display, memory);
1404 if (
layer->is_editable()) {
1415 const bool keep_caps)
1421 int dst_points_num = 0;
1423 dst_points_num += src_transfer_data.size();
1425 if (dst_points_num == 0) {
1437 Array<int> src_pivot_point(src_curves_num, -1);
1438 Array<int> dst_interm_curves_offsets(src_curves_num + 1, 0);
1441 const IndexRange src_points = src_points_by_curve[src_curve];
1443 for (
const int src_point : src_points) {
1444 for (
const PointTransferData &dst_point_transfer : src_to_dst_points[src_point]) {
1445 if (dst_point_transfer.is_src_point) {
1446 dst_transfer_data[++dst_point] = dst_point_transfer;
1451 dst_transfer_data[++dst_point] = dst_point_transfer;
1456 if (src_cyclic[src_curve] && dst_point_transfer.is_cut) {
1457 src_pivot_point[src_curve] = dst_point;
1465 dst_interm_curves_offsets[src_curve + 1] = dst_point + 1;
1471 for (const int src_curve : src_curves) {
1472 const int pivot_point = src_pivot_point[src_curve];
1474 if (pivot_point == -1) {
1476 src_now_cyclic[src_curve] = src_cyclic[src_curve];
1484 src_now_cyclic[src_curve] = false;
1486 const int dst_interm_first = dst_interm_curves_offsets[src_curve];
1487 const int dst_interm_last = dst_interm_curves_offsets[src_curve + 1];
1488 std::rotate(dst_transfer_data.begin() + dst_interm_first,
1489 dst_transfer_data.begin() + pivot_point,
1490 dst_transfer_data.begin() + dst_interm_last);
1497 dst_curves_offset.
append(0);
1498 for (
int src_curve : src.curves_range()) {
1499 const IndexRange dst_points(dst_interm_curves_offsets[src_curve],
1500 dst_interm_curves_offsets[src_curve + 1] -
1501 dst_interm_curves_offsets[src_curve]);
1502 int length_of_current = 0;
1504 for (
int dst_point : dst_points) {
1506 if ((length_of_current > 0) && dst_transfer_data[dst_point].is_cut) {
1508 dst_curves_offset.
append(dst_point);
1509 dst_to_src_curve.
append(src_curve);
1510 length_of_current = 0;
1512 ++length_of_current;
1515 if (length_of_current != 0) {
1517 dst_curves_offset.
append(dst_points.one_after_last());
1518 dst_to_src_curve.
append(src_curve);
1521 const int dst_curves_num = dst_curves_offset.
size() - 1;
1522 if (dst_curves_num == 0) {
1524 return dst_transfer_data;
1528 dst.resize(dst_points_num, dst_curves_num);
1530 const OffsetIndices<int> dst_points_by_curve = dst.points_by_curve();
1533 BLI_assert(dst.vertex_group_names.count() == 0);
1537 const bke::AttributeAccessor src_attributes = src.attributes();
1538 bke::MutableAttributeAccessor dst_attributes = dst.attributes_for_write();
1547 if (src_cyclic.get_if_single().value_or(
true)) {
1549 src_now_cyclic.as_span(), dst_to_src_curve.as_span(), dst.cyclic_for_write());
1552 dst.update_curve_types();
1556 bke::SpanAttributeWriter<int8_t> dst_start_caps =
1558 bke::SpanAttributeWriter<int8_t> dst_end_caps =
1562 for (const int dst_curve : dst_curves) {
1563 const IndexRange dst_curve_points = dst_points_by_curve[dst_curve];
1564 const PointTransferData &start_point_transfer =
1565 dst_transfer_data[dst_curve_points.first()];
1566 const PointTransferData &end_point_transfer = dst_transfer_data[dst_curve_points.last()];
1568 if (dst_start_caps && start_point_transfer.is_cut) {
1569 dst_start_caps.span[dst_curve] = GP_STROKE_CAP_TYPE_FLAT;
1573 if (dst_end_caps && !end_point_transfer.is_src_end_point()) {
1574 dst_end_caps.span[dst_curve] = GP_STROKE_CAP_TYPE_FLAT;
1580 dst_end_caps.finish();
1588 if constexpr (!std::is_same_v<T, std::string>) {
1589 auto src_attr = attribute.src.typed<T>();
1590 auto dst_attr = attribute.dst.span.typed<T>();
1592 threading::parallel_for(dst.points_range(), 4096, [&](const IndexRange dst_points) {
1593 for (const int dst_point : dst_points) {
1594 const PointTransferData &point_transfer = dst_transfer_data[dst_point];
1595 if (point_transfer.is_src_point) {
1596 dst_attr[dst_point] = src_attr[point_transfer.src_point];
1599 dst_attr[dst_point] = bke::attribute_math::mix2<T>(
1600 point_transfer.factor,
1601 src_attr[point_transfer.src_point],
1602 src_attr[point_transfer.src_next_point]);
1612 return dst_transfer_data;
1619 const float pixel_radius)
1652 const float pressure,
1691 const bool is_stroke_visible = material->gp_style->stroke_rgba[3] > 0.0f;
1692 const bool is_fill_visible = material->gp_style->fill_rgba[3] > 0.0f;
1696 if (brush_uses_stroke && !brush_uses_fill && !is_stroke_visible) {
1699 if (!brush_uses_stroke && brush_uses_fill && !is_fill_visible) {
1702 if (brush_uses_stroke && brush_uses_fill && !is_stroke_visible && !is_fill_visible) {
1705 BLI_assert(brush_uses_stroke || brush_uses_fill);
1711 const bool use_duplicate_previous_key)
1727 if (
brush ==
nullptr) {
1733 if (!active_layer.is_editable()) {
1746 bool inserted_keyframe =
false;
1748 *scene,
grease_pencil, active_layer, use_duplicate_previous_key, inserted_keyframe))
1754 if (inserted_keyframe) {
1756 for (
auto [frame_number, frame] :
layer->frames_for_write().items()) {
1757 const bool select_keyframe = (frame_number == scene->
r.
cfra) && (
layer == &active_layer);
1767 switch (visibility_status) {
1800 u_dir =
float3(1.0f, 0.0f, 0.0f);
1801 v_dir =
float3(0.0f, 0.0f, 1.0f);
1804 u_dir =
float3(0.0f, 1.0f, 0.0f);
1805 v_dir =
float3(0.0f, 0.0f, 1.0f);
1808 u_dir =
float3(1.0f, 0.0f, 0.0f);
1809 v_dir =
float3(0.0f, 1.0f, 0.0f);
1813 u_dir = mat *
float3(1.0f, 0.0f, 0.0f);
1814 v_dir = mat *
float3(0.0f, 1.0f, 0.0f);
1842 const int num_old_curves =
curves.curves_num();
1843 const int num_old_points =
curves.points_num();
1845 curves.offsets_for_write().last(1) = num_old_points;
1858 [&](std::optional<bke::greasepencil::FillCache> &fill_cache) {
1860 fill_cache->fill_map.append(num_old_curves);
1861 fill_cache->fill_offsets.append(fill_cache->fill_offsets.last() + 1);
1869 offsets.
first() = 0;
1872 for (
int i =
curves.curves_num() - 2; i >= 0; i--) {
1873 offsets[i + 1] = offsets[i] + 1;
1892 const int curve_index = at_end ?
curves.curves_range().last() : 0;
1893 const int current_points_num = points_by_curve[curve_index].
size();
1894 if (new_points_num == current_points_num) {
1899 const int diff_points_num = new_points_num - current_points_num;
1901 curves.offsets_for_write().last() =
curves.points_num();
1905 if (current_points_num < new_points_num) {
1906 const int last_active_point = points_by_curve[0].last();
1908 const int added_points_num = new_points_num - current_points_num;
1912 for (
const int src_curve :
curves.curves_range().drop_front(1)) {
1913 offsets[src_curve] = offsets[src_curve] + added_points_num;
1934 const int removed_points_num = current_points_num - new_points_num;
1946 dst.
span, new_points_num + removed_points_num, dst.
span.
size(), new_points_num);
1952 for (
const int src_curve :
curves.curves_range().drop_front(1)) {
1953 offsets[src_curve] = offsets[src_curve] - removed_points_num;
1960 const int eval_frame,
1964 using namespace bke;
1969 const Layer &
layer = orig_grease_pencil.layer(layer_i);
1974 const int old_layers_num = eval_grease_pencil.layers().size();
1983 for (
Layer *
layer : orig_grease_pencil.layers_for_write()) {
1985 if (
layer->is_visible()) {
1989 for (
const TreeNode *node_eval : merged_layers_grease_pencil.nodes()) {
1991 TreeNode *node_orig = orig_grease_pencil.find_node_by_name(node_eval->name());
1994 if (!node_eval->is_layer()) {
1998 const bool has_valid_orig_layer = (node_orig !=
nullptr && node_orig->
is_layer());
1999 if (!has_valid_orig_layer) {
2001 Layer &layer_orig = orig_grease_pencil.add_layer(node_eval->name(),
true);
2002 orig_layers_to_apply.
add(&layer_orig);
2004 orig_grease_pencil.insert_frame(layer_orig, eval_frame);
2005 node_orig = &layer_orig.
as_node();
2010 orig_layers_to_clear.
remove(&layer_orig);
2012 if (orig_layers_to_apply.
contains(&layer_orig)) {
2014 const Layer &layer_eval = node_eval->as_layer();
2019 eval_to_orig_layer_map.add_new(&layer_eval, &layer_orig);
2025 for (
Layer *layer_orig : orig_layers_to_clear) {
2027 Drawing *drawing_orig = orig_grease_pencil.insert_frame(*layer_orig, eval_frame);
2028 if (drawing_orig ==
nullptr) {
2030 drawing_orig = orig_grease_pencil.get_drawing_at(*layer_orig, eval_frame);
2040 for (
bDeformGroup &dg : orig_grease_pencil.vertex_group_names) {
2041 orig_vgroup_names.
add(dg.
name);
2048 for (
auto [layer_eval, layer_orig] : eval_to_orig_layer_map.items()) {
2049 Drawing *drawing_eval = merged_layers_grease_pencil.get_drawing_at(*layer_eval, eval_frame);
2050 Drawing *drawing_orig = orig_grease_pencil.get_drawing_at(*layer_orig, eval_frame);
2052 if (drawing_orig && drawing_eval) {
2058 new_vgroup_names.
add(dg.
name);
2067 all_updated_drawings.
add_new(drawing_orig);
2072 for (
StringRef new_vgroup_name : new_vgroup_names) {
2074 new_vgroup_name.copy_utf8_truncated(dst->
name);
2075 BLI_addtail(&orig_grease_pencil.vertex_group_names, dst);
2081 eval_grease_pencil.material_array_num};
2082 for (
Material *eval_material : eval_materials) {
2083 if (!eval_material) {
2095 Array<int> material_indices_map(orig_grease_pencil.material_array_num, -1);
2096 for (
const int mat_i : orig_material_indices) {
2097 Material *material = orig_grease_pencil.material_array[mat_i];
2098 const int map_index = original_materials.
index_of_try(material);
2099 if (map_index != -1) {
2100 material_indices_map[mat_i] = map_index;
2105 if (!material_indices_map.
is_empty() &&
2113 if (all_updated_drawings.
contains(&drawing)) {
2118 if (!attributes.
contains(
"material_index")) {
2123 for (
int &material_index : material_indices.
span) {
2125 material_index = material_indices_map[material_index];
2128 material_indices.
finish();
2133 Array<int> eval_to_orig_layer_indices_map(orig_grease_pencil.layers().size(), -1);
2134 for (
const int layer_eval_i : merged_layers_grease_pencil.layers().index_range()) {
2135 const Layer *layer_eval = &merged_layers_grease_pencil.layer(layer_eval_i);
2136 if (eval_to_orig_layer_map.contains(layer_eval)) {
2137 const Layer *layer_orig = eval_to_orig_layer_map.lookup(layer_eval);
2138 const int layer_orig_index = *orig_grease_pencil.get_layer_index(*layer_orig);
2139 if (eval_to_orig_layer_indices_map[layer_orig_index] == -1) {
2141 eval_to_orig_layer_indices_map[layer_orig_index] = layer_eval_i;
2148 eval_to_orig_layer_indices_map.
index_range(), eval_to_orig_layer_indices_map, memory);
2163 src.
varray, eval_to_orig_layer_indices_map, mapped_orig_layers, dst.
span);
2168 BKE_id_free(
nullptr, &merged_layers_grease_pencil);
2173 if (!
curves.attributes().contains(
".is_fill_guide")) {
2183 curves.remove_curves(fill_guides, {});
2185 curves.attributes_for_write().remove(
".is_fill_guide");
Low-level operations for curves.
Low-level operations for grease pencil.
General operations, lookup, etc. for materials.
ID and Library types, which are fundamental for SDNA.
#define ID_IS_EDITABLE(_id)
#define ID_IS_OVERRIDE_LIBRARY(_id)
Object is a sort of wrapper for general info.
#define SET_FLAG_FROM_TEST(value, test, flag)
Array(Allocator allocator={}) noexcept
IndexRange index_range() 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)
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 last(const int64_t n=0) const
constexpr IndexRange()=default
constexpr bool contains(int64_t value) const
constexpr T & first() const
constexpr T & last(const int64_t n=0) const
bool contains(const Key &key) const
void add_new(const Key &key)
bool remove(const Key &key)
constexpr const T & first() const
constexpr const T & last(const int64_t n=0) const
constexpr IndexRange index_range() const
constexpr bool is_empty() const
std::optional< T > get_if_single() const
static VArray from_single(T value, const int64_t size)
int64_t index_of_try(const Key &key) const
int64_t index_of(const Key &key) const
bool contains(const Key &key) const
void add_new(const Key &key)
void append(const T &value)
Span< T > as_span() const
GAttributeReader lookup_or_default(StringRef name, AttrDomain domain, AttrType data_type, const void *default_value=nullptr) const
void foreach_attribute(const FunctionRef< void(const AttributeIter &)> fn) const
bool contains(StringRef name) const
GAttributeReader lookup(const StringRef name) const
std::optional< AttrStorageType > storage_type
GAttributeReader get() const
void resize(int points_num, int curves_num)
VArray< bool > cyclic() 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())
GSpanAttributeWriter lookup_for_write_span(StringRef name)
SharedCache< std::optional< FillCache > > fill_cache
SharedCache< Vector< float3 > > curve_plane_normals_cache
SharedCache< Vector< float4x2 > > curve_texture_matrices
std::optional< GroupedSpan< int > > fills() const
bke::CurvesGeometry & strokes_for_write()
const bke::CurvesGeometry & strokes() const
void tag_topology_changed()
void set_local_transform(const float4x4 &transform)
float4x4 local_transform() const
const TreeNode & as_node() const
const Layer & as_layer() const
DrawingPlacement & operator=(const DrawingPlacement &other)
bool use_project_to_surface() const
std::optional< float > get_depth(float2 co) const
void cache_viewport_depths(Depsgraph *depsgraph, ARegion *region, View3D *view3d)
float3 place(float2 co, float depth) const
bool use_project_to_stroke() const
std::optional< float3 > project_depth(float2 co) const
float4x4 to_world_space() const
float3 project_with_shift(float2 co) const
DrawingPlacement()=default
float3 reproject(float3 pos) const
float3 project(float2 co, bool &clipped) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
float3x3 scale(float3x3 mat, float2 scale)
void gather(const GVArray &src, const IndexMask &indices, GMutableSpan dst, exec_mode::Mode mode=exec_mode::parallel)
IndexMask indices_non_negative(const IndexMask &universe, Span< int > values, LinearAllocator<> &memory)
bool indices_are_range(Span< int > indices, IndexRange range)
void copy(const GVArray &src, GMutableSpan dst, exec_mode::Mode mode=exec_mode::parallel)
void gather(GSpan src, Span< int > map, GMutableSpan dst)
void shift_right(GMutableSpan data, int src_begin, int src_end, int dst_begin)
void shift_left(GMutableSpan data, int src_begin, int src_end, int dst_begin)
void to_static_type(const CPPType &cpp_type, Fn &&fn)
IndexMask indices_for_type(const VArray< int8_t > &types, const std::array< int, CURVE_TYPES_NUM > &type_counts, const CurveType type, const IndexMask &selection, LinearAllocator<> &memory)
auto attribute_filter_from_skip_ref(const Span< StringRef > skip)
Vector< AttributeTransferData > retrieve_attributes_for_transfer(const AttributeAccessor src_attributes, MutableAttributeAccessor dst_attributes, Span< AttrDomain > domains, const AttributeFilter &attribute_filter={})
void gather_attributes(AttributeAccessor src_attributes, AttrDomain src_domain, AttrDomain dst_domain, const AttributeFilter &attribute_filter, const IndexMask &selection, MutableAttributeAccessor dst_attributes)
std::optional< Bounds< T > > min_max(const std::optional< Bounds< T > > &a, const T &b)
IndexMask retrieve_selected_points(const bke::CurvesGeometry &curves, LinearAllocator<> &memory)
IndexMask retrieve_selected_curves(const bke::CurvesGeometry &curves, LinearAllocator<> &memory)
IndexMask retrieve_all_selected_points(const bke::CurvesGeometry &curves, const int handle_display, LinearAllocator<> &memory)
IndexMask retrieve_editable_and_selected_elements(Object &object, const bke::greasepencil::Drawing &drawing, int layer_index, const bke::AttrDomain selection_domain, IndexMaskMemory &memory)
bool grease_pencil_draw_operator_begin(bContext *C, wmOperator *op, const bool use_duplicate_previous_key)
IndexMask retrieve_editable_and_selected_strokes(Object &object, const bke::greasepencil::Drawing &drawing, int layer_index, IndexMaskMemory &memory)
float opacity_from_input_sample(const float pressure, const Paint &paint, const Brush *brush, const BrushGpencilSettings *settings)
static Array< int > get_editable_frames_for_layer(const GreasePencil &grease_pencil, const bke::greasepencil::Layer &layer, const int current_frame, const bool use_multi_frame_editing)
void resize_single_curve(bke::CurvesGeometry &curves, const bool at_end, const int new_points_num)
static float get_frame_falloff(const bool use_multi_frame_falloff, const int frame_number, const int active_frame, const std::optional< Bounds< int > > frame_bounds, const CurveMapping *falloff_curve)
static std::optional< int > get_frame_id(const bke::greasepencil::Layer &layer, const GreasePencilFrame &frame, const int frame_number, const int frame_index, const int current_frame, const int current_frame_index, const int last_frame, const int last_frame_index, const bool use_multi_frame_editing, const bool do_onion_skinning, const bool is_before_first, const GreasePencilOnionSkinningSettings onion_settings)
IndexMask retrieve_editable_points(Object &object, const bke::greasepencil::Drawing &drawing, int layer_index, IndexMaskMemory &memory)
bool ensure_active_keyframe(const Scene &scene, GreasePencil &grease_pencil, bke::greasepencil::Layer &layer, const bool duplicate_previous_key, bool &r_inserted_keyframe)
GreasePencil * from_context(bContext &C)
IndexMask retrieve_visible_bezier_handle_strokes(Object &object, const bke::greasepencil::Drawing &drawing, const eHandleDisplay handle_display, IndexMaskMemory &memory)
IndexMask retrieve_editable_fill_strokes(Object &object, const bke::greasepencil::Drawing &drawing, int layer_index, IndexMaskMemory &memory)
IndexMask retrieve_editable_elements(Object &object, const MutableDrawingInfo &info, const bke::AttrDomain selection_domain, IndexMaskMemory &memory)
IndexMask retrieve_visible_bezier_strokes(Object &object, const bke::greasepencil::Drawing &drawing, IndexMaskMemory &memory)
Vector< MutableDrawingInfo > retrieve_editable_drawings_from_layer(const Scene &scene, GreasePencil &grease_pencil, const bke::greasepencil::Layer &layer)
static StrokeVisibilityStatus get_visibility_status_for_draw_operator(Object *object, const Brush &brush)
Vector< MutableDrawingInfo > retrieve_editable_drawings_from_layer_with_falloff(const Scene &scene, GreasePencil &grease_pencil, const bke::greasepencil::Layer &layer)
IndexMask retrieve_visible_points(Object &object, const bke::greasepencil::Drawing &drawing, IndexMaskMemory &memory)
Vector< DrawingInfo > retrieve_visible_drawings(const Scene &scene, const GreasePencil &grease_pencil, const bool do_onion_skinning)
IndexMask retrieve_editable_strokes_by_material(Object &object, const bke::greasepencil::Drawing &drawing, const int mat_i, IndexMaskMemory &memory)
IndexMask retrieve_editable_and_selected_fill_strokes(Object &object, const bke::greasepencil::Drawing &drawing, int layer_index, IndexMaskMemory &memory)
bool check_brush_needs_new_material(Object *ob, const Brush *brush)
bool has_editable_layer(const GreasePencil &grease_pencil)
static float pixel_radius_to_world_space_radius(const RegionView3D *rv3d, const ARegion *region, const float3 center, const float4x4 to_world, const float pixel_radius)
IndexMask retrieve_visible_bezier_points(Object &object, const bke::greasepencil::Drawing &drawing, IndexMaskMemory &memory)
static Array< std::pair< int, int > > get_visible_frames_for_layer(const GreasePencil &grease_pencil, const bke::greasepencil::Layer &layer, const int current_frame, const bool use_multi_frame_editing, const bool do_onion_skinning)
Array< PointTransferData > compute_topology_change(const bke::CurvesGeometry &src, bke::CurvesGeometry &dst, const Span< Vector< PointTransferData > > src_to_dst_points, const bool keep_caps)
IndexMask retrieve_editable_and_all_selected_points(Object &object, const bke::greasepencil::Drawing &drawing, const int layer_index, const eHandleDisplay handle_display, IndexMaskMemory &memory)
static VectorSet< int > get_locked_material_indices(Object &object)
IndexMask retrieve_editable_and_selected_points(Object &object, const bke::greasepencil::Drawing &drawing, int layer_index, IndexMaskMemory &memory)
static std::optional< Bounds< int > > get_selected_frame_number_bounds(const bke::greasepencil::Layer &layer)
IndexMask retrieve_visible_bezier_handle_points(Object &object, const bke::greasepencil::Drawing &drawing, const int layer_index, const eHandleDisplay handle_display, IndexMaskMemory &memory)
static VectorSet< int > get_hidden_material_indices(Object &object)
static int get_active_frame_for_falloff(const bke::greasepencil::Layer &layer, const std::optional< Bounds< int > > frame_bounds, const int current_frame)
IndexMask retrieve_visible_strokes(Object &object, const bke::greasepencil::Drawing &drawing, IndexMaskMemory &memory)
IndexMask retrieve_visible_fills(Object &object, const bke::greasepencil::Drawing &drawing, IndexMaskMemory &memory)
Vector< MutableDrawingInfo > retrieve_editable_drawings_with_falloff(const Scene &scene, GreasePencil &grease_pencil)
eHandleDisplay view3d_handle_type_or_default(const View3D *v3d)
IndexMask retrieve_editable_strokes(Object &object, const bke::greasepencil::Drawing &drawing, int layer_index, IndexMaskMemory &memory)
bool remove_fill_guides(bke::CurvesGeometry &curves)
Vector< MutableDrawingInfo > retrieve_editable_drawings(const Scene &scene, GreasePencil &grease_pencil)
static float brush_radius_at_location(const RegionView3D *rv3d, const ARegion *region, const Paint *paint, const Brush *brush, const float3 location, const float4x4 to_world)
float4x2 calculate_texture_space(const Scene *scene, const ARegion *region, const float2 &mouse, const DrawingPlacement &placement)
void add_single_curve(bke::greasepencil::Drawing &drawing, const bool at_end)
Array< Vector< MutableDrawingInfo > > retrieve_editable_drawings_grouped_per_frame(const Scene &scene, GreasePencil &grease_pencil)
IndexMask retrieve_visible_bezier_handle_elements(Object &object, const bke::greasepencil::Drawing &drawing, const int layer_index, const bke::AttrDomain selection_domain, const eHandleDisplay handle_display, IndexMaskMemory &memory)
float radius_from_input_sample(const RegionView3D *rv3d, const ARegion *region, const Paint &paint, const Brush *brush, const float pressure, const float3 &location, const float4x4 &to_world, const BrushGpencilSettings *settings)
void apply_eval_grease_pencil_data(const GreasePencil &eval_grease_pencil, const int eval_frame, const IndexMask &orig_layers, GreasePencil &orig_grease_pencil)
GreasePencil * merge_layers_by_name(const GreasePencil &src_grease_pencil, const VArray< bool > &selection, const bke::AttributeFilter &attribute_filter)
BLI_INLINE Texture * wrap(MTLTexture *texture)
MatBase< T, NumCol, NumRow > transpose(const MatBase< T, NumRow, NumCol > &mat)
T clamp(const T &a, const T &min, const T &max)
T safe_divide(const T &a, const T &b)
T length(const VecBase< T, Size > &a)
T dot(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
CartesianBasis invert(const CartesianBasis &basis)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
VecBase< T, 3 > transform_direction(const MatBase< T, 3, 3 > &mat, const VecBase< T, 3 > &direction)
VecBase< T, 3 > transform_point(const CartesianBasis &basis, const VecBase< T, 3 > &v)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
@ GP_SCULPT_SETT_FLAG_FRAME_FALLOFF
void ED_view3d_win_to_3d_with_shift(const View3D *v3d, const ARegion *region, const float depth_pt[3], const float mval[2], float r_out[3])
void ED_view3d_depths_free(ViewDepths *depths)
@ GP_ONION_SKINNING_MODE_RELATIVE
@ GP_ONION_SKINNING_MODE_ABSOLUTE
@ GP_ONION_SKINNING_MODE_SELECTED
bool isect_ray_plane_v3(const float ray_origin[3], const float ray_direction[3], const float plane[4], float *r_lambda, bool clip)
@ GP_ONION_SKINNING_SHOW_LOOP
Material * BKE_object_material_get(Object *ob, short act)
float BKE_brush_radius_get(const Paint *paint, const Brush *brush)
MatBase< float, 4, 4 > float4x4
MatBase< float, 2, 4 > float2x4
void plane_from_point_normal_v3(float r_plane[4], const float plane_co[3], const float plane_no[3])
bool BKE_brush_use_alpha_pressure(const Brush *brush)
bool ED_view3d_unproject_v3(const ARegion *region, float regionx, float regiony, float regionz, float world[3])
float BKE_brush_unprojected_radius_get(const Paint *paint, const Brush *brush)
VecBase< float, 4 > float4
void BKE_curvemapping_init(CurveMapping *cumap)
@ GP_USE_MULTI_FRAME_EDITING
VecBase< int32_t, 2 > int2
VecBase< float, 2 > float2
void BKE_report(ReportList *reports, eReportType type, const char *message)
BMesh const char void * data
bool ED_view3d_win_to_3d_on_plane(const ARegion *region, const float plane[4], const float mval[2], bool do_clip, float r_out[3])
MatBase< float, 4, 2 > float4x2
eV3DProjStatus ED_view3d_project_float_global(const ARegion *region, const float co[3], float r_co[2], eV3DProjTest flag)
void ED_view3d_win_to_vector(const ARegion *region, const float mval[2], float r_out[3])
switch(BMIterType(itype))
@ V3D_GP_FORCE_STROKE_ORDER_3D
float ED_view3d_calc_zfac(const RegionView3D *rv3d, const float co[3])
MatBase< float, 3, 3 > float3x3
void BKE_id_free(Main *bmain, void *idv)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
bool BKE_brush_use_size_pressure(const Brush *brush)
const Brush * BKE_paint_brush_for_read(const Paint *paint)
T * DEG_get_original(T *id)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
float BKE_scene_ctime_get(const Scene *scene)
Paint * BKE_paint_get_active_from_context(const bContext *C)
void ED_view3d_depth_override(Depsgraph *depsgraph, ARegion *region, View3D *v3d, Object *obact, eV3DDepthOverrideMode mode, bool use_overlay, ViewDepths **r_depths)
bool ED_view3d_depth_read_cached(const ViewDepths *vd, const int mval[2], int margin, float *r_depth)
Material * BKE_grease_pencil_object_material_from_brush_get(Object *ob, const Brush *brush)
void BKE_defgroup_copy_list(ListBaseT< bDeformGroup > *outbase, const ListBaseT< bDeformGroup > *inbase)
@ V3D_DEPTH_SELECTED_ONLY
Scene * CTX_data_scene(const bContext *C)
@ GP_PROJECT_DEPTH_STROKE
@ GP_PROJECT_DEPTH_ONLY_SELECTED
bool ED_view3d_depth_unproject_v3(const ARegion *region, const int mval[2], double depth, float r_location_world[3])
VecBase< float, 3 > float3
void ED_view3d_win_to_3d(const View3D *v3d, const ARegion *region, const float depth_pt[3], const float mval[2], float r_out[3])
Object * CTX_data_active_object(const bContext *C)
float BKE_curvemapping_evaluateF(const CurveMapping *cumap, int cur, float value)
PointerRNA CTX_data_pointer_get_type(const bContext *C, const char *member, StructRNA *type)
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)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct CurveMapping * curve_sensitivity
struct CurveMapping * curve_strength
ListBaseT< struct bDeformGroup > vertex_group_names
eGP_Lockaxis_Types lock_axis
eGP_Sculpt_SettingsFlag flag
struct CurveMapping * cur_falloff
bke::greasepencil::DrawingRuntime * runtime
GreasePencilOnionSkinningFilter filter
int16_t num_frames_before
GreasePencilOnionSkinningFlag flag
GreasePencilOnionSkinningMode mode
static MatBase identity()
struct ToolSettings * toolsettings
eHandleDisplay handle_display
MutableVArraySpan< T > span
bke::greasepencil::Drawing & drawing
struct ReportList * reports