81 Image *ima_ =
nullptr;
82 ImBuf *ibuf_ =
nullptr;
83 void *lock_ =
nullptr;
90 return ibuf_ !=
nullptr;
103 size_ = {ibuf_->x, ibuf_->y};
105 reinterpret_cast<ColorGeometry4b *
>(ibuf_->byte_data_for_write()), ibuf_->x * ibuf_->y);
126 return this->size_.x;
131 return this->size_.y;
136 return c.x >= 0 && c.x < this->size_.x && c.y >= 0 && c.y < this->size_.y;
141 const div_t d = div(
index, this->size_.x);
142 return int2{d.rem, d.quot};
147 return c.x + c.y * this->size_.x;
173 return (
color.r & flag) != 0;
186 const bool is_stroke =
color.r > 0.0f;
187 const bool is_seed =
color.g > 0.0f;
198 constexpr const ColorGeometry4b output_stroke_color = {255, 0, 0, 255};
199 constexpr const ColorGeometry4b output_seed_color = {127, 127, 0, 255};
200 constexpr const ColorGeometry4b output_border_color = {0, 0, 255, 255};
201 constexpr const ColorGeometry4b output_fill_color = {127, 255, 0, 255};
204 constexpr const ColorGeometry4b output_debug_color = {255, 127, 0, 255};
208 std::min(
int(a.
g) +
int(
b.g), 255),
209 std::min(
int(a.
b) +
int(
b.b), 255),
210 std::min(
int(a.
a) +
int(
b.a), 255));
216 output_color = add_colors(output_color, output_debug_color);
219 output_color = add_colors(output_color, output_fill_color);
222 output_color = add_colors(output_color, output_stroke_color);
225 output_color = add_colors(output_color, output_border_color);
228 output_color = add_colors(output_color, output_seed_color);
230 color = std::move(output_color);
242 row_start += buffer.
width();
244 for ([[maybe_unused]]
const int i :
IndexRange(buffer.
height()).drop_front(1).drop_back(1)) {
247 row_start += buffer.
width();
267template<FillBorderMode border_mode>
271 const int width = buffer.
width();
272 const int height = buffer.
height();
278 active_pixels.
push(i);
282 enum FilterDirection {
287 bool border_contact =
false;
289 const int index = active_pixels.
pop();
295 border_contact =
true;
301 border_contact =
true;
321 std::min(width - 1 - coord.x, leak_filter_width));
324 std::min(height - 1 - coord.y, leak_filter_width));
325 bool is_boundary_horizontal =
false;
326 bool is_boundary_vertical =
false;
327 for (
const int filter_i : filter_y_neg) {
331 for (
const int filter_i : filter_y_pos) {
335 for (
const int filter_i : filter_x_neg) {
339 for (
const int filter_i : filter_x_pos) {
345 if (coord.x > 0 && !is_boundary_horizontal) {
348 if (coord.x < width - 1 && !is_boundary_horizontal) {
351 if (coord.y > 0 && !is_boundary_vertical) {
354 if (coord.y < height - 1 && !is_boundary_vertical) {
388 for ([[maybe_unused]]
const int iter :
IndexRange(iterations)) {
401 active_pixels.
push(i);
407 const int index = active_pixels.
pop();
418 for ([[maybe_unused]]
const int iter :
IndexRange(iterations)) {
431 active_pixels.
push(i);
437 const int index = active_pixels.
pop();
464 using BoundarySection = std::list<int>;
468 const int width = buffer.
width();
469 const int height = buffer.
height();
473 constexpr const uint8_t start_direction = 3;
474 auto find_start_coordinates = [&]() -> BoundaryStartMap {
475 BoundaryStartMap starts;
478 for (
const int x :
IndexRange(width).drop_back(1)) {
484 if (!filled_left && filled_right && !border_right) {
486 starts.add(index_right, {});
493 struct NeighborIterator {
499 auto find_next_neighbor = [&](NeighborIterator &iter) ->
bool {
504 const int neighbor_dir =
wrap_dir_3n(iter.direction + 5 + i);
515 iter.index = neighbor_index;
516 iter.direction = neighbor_dir;
523 BoundaryStartMap boundary_starts = find_start_coordinates();
526 for (
const int start_index : boundary_starts.keys()) {
528 if (!boundary_starts.contains(start_index)) {
531 BoundarySection §ion = boundary_starts.lookup(start_index);
532 section.push_back(start_index);
533 NeighborIterator iter = {start_index, start_direction};
534 while (find_next_neighbor(iter)) {
536 if (iter.index == start_index) {
541 if (boundary_starts.contains(iter.index)) {
542 BoundarySection &next_section = boundary_starts.lookup(iter.index);
543 if (next_section.empty()) {
545 boundary_starts.remove(iter.index);
549 section.splice(section.end(), next_section);
550 boundary_starts.remove(iter.index);
555 section.push_back(iter.index);
558 if (iter.index != start_index) {
559 boundary_starts.remove(start_index);
565 for (
const BoundarySection §ion : boundary_starts.values()) {
567 for (
const int index : section) {
573 return final_boundary;
594 for (
const int point_i :
curves.points_range()) {
595 const int pixel_index =
boundary.pixels[point_i];
597 const float2 region_coord =
611 const bool output_as_colors)
613 constexpr const int leak_filter_width = 3;
618 if (output_as_colors) {
648 const int dilate_pixels =
brush.gpencil_settings->dilate_pixels;
649 if (dilate_pixels > 0) {
650 dilate(buffer, dilate_pixels);
652 else if (dilate_pixels < 0) {
653 erode(buffer, -dilate_pixels);
668 const bool is_boundary_layer,
676 auto is_visible_curve = [&](
const int curve_i) {
679 if (points.
size() < 2) {
685 materials[curve_i] + 1);
688 if (gp_style ==
nullptr || is_hidden_material) {
696 if (is_boundary_layer) {
701 if (!is_visible_curve(curve_i)) {
704 const bool is_boundary_stroke = fill_guides[curve_i];
705 return is_boundary_stroke;
717 const std::optional<float> opacity_threshold)
719 if (!opacity_threshold) {
725 for (const int curve_i : range) {
726 const Material *material = BKE_object_material_get(const_cast<Object *>(&object),
727 materials[curve_i] + 1);
728 const float material_alpha = material && material->gp_style ?
729 material->gp_style->stroke_rgba[3] :
731 const IndexRange points = curves.points_by_curve()[curve_i];
732 for (const int point_i : points) {
733 const float alpha = (material_alpha * opacities[point_i] > *opacity_threshold ? 1.0f :
735 colors[point_i] = ColorGeometry4f(tint_color.r, tint_color.g, tint_color.b, alpha);
754 const Object &object_eval,
761 std::optional<Bounds<float2>> boundary_bounds;
770 const float4x4 layer_to_world =
layer.to_world_space(
object);
773 &object_eval,
object, info.drawing);
774 const bool only_boundary_strokes = boundary_layers[info.layer_index];
785 object, info, only_boundary_strokes, curve_mask_memory);
788 [&](
const int curve_i) {
791 if (points.
size() < 2) {
795 const int material_index = materials[curve_i];
803 if (only_boundary_strokes && !is_boundary_stroke[curve_i]) {
807 for (
const int point_i : points) {
816 boundary_bounds =
bounds::merge(boundary_bounds, {point_bounds});
823 return boundary_bounds;
831 const bool uniform_zoom,
832 const float max_zoom_factor,
834 const float pixel_scale)
839 const int2 min_image_size =
int2(128, 128);
841 switch (fit_method) {
855 if (!boundary_bounds) {
877 fill_bounds.
center() - 0.5f * region_bounds.
size() * zoom.x,
878 fill_bounds.
center() + 0.5f * region_bounds.
size() * zoom.y};
882 region_bounds.
size());
887 return std::make_tuple(zoom, offset, image_size, image_to_region);
900 const int2 &image_size,
901 const std::optional<float> opacity_threshold,
923 const float3 fill_point_layer = placement.
project(fill_point);
931 if (offscreen_buffer ==
nullptr) {
935 const bool use_xray =
false;
937 const float4x4 layer_to_world =
layer.to_world_space(
object);
939 const float4x4 layer_to_view = world_to_view * layer_to_world;
947 const float mouse_dot_size = 4.0f;
952 if (!
layer.is_visible()) {
955 const float4x4 layer_to_world =
layer.to_world_space(
object);
956 const bool is_boundary_layer = boundary_layers[info.layer_index];
965 object, info, is_boundary_layer, curve_mask_memory);
968 info.drawing.strokes(),
990 const float line_width = 1.0f;
994 extensions.
lines.starts,
995 extensions.
lines.ends,
1015 const std::optional<float> opacity_threshold,
1016 const float2 &fill_point,
1019 const bool keep_images)
1023 Depsgraph &depsgraph = *view_context.
depsgraph;
1030 const bool uniform_zoom =
true;
1031 const float max_zoom_factor = 5.0f;
1034 const float pixel_scale =
brush.gpencil_settings->fill_factor;
1035 const auto [zoom, offset, image_size, image_to_region] =
fit_strokes_to_view(view_context,
1068 *ima,
brush, placement, image_to_region,
invert, keep_images);
1122 auto get_next_unprocessed_edge = [&]() {
1125 const int empty_num = start_edge;
1126 const int first_segment = processed_edges.
as_span().drop_front(empty_num).first_index_try(
1129 if (first_segment == -1) {
1132 return first_segment + empty_num;
1137 if (!edges_to_keep[seg_i]) {
1138 processed_edges[seg_i] =
true;
1142 start_edge = get_next_unprocessed_edge();
1146 bool current_backwards =
false;
1147 int current_i = start_edge;
1148 const int first_segment = current_i;
1151 bool curve_done =
false;
1152 while (!curve_done) {
1153 if (processed_edges[current_i] ==
true) {
1158 const int current_edge = all_edges[current_i];
1159 processed_edges[current_i] =
true;
1161 edge_curves.
reversed.append(current_backwards);
1175 if (next_segment == first_segment) {
1185 current_i = next_segment;
1186 current_backwards = next_side ==
Side::End;
1191 start_edge = get_next_unprocessed_edge();
1202 for (
const int edge_index : edges.
index_range()) {
1203 edge_to_index.
add_new(edges[edge_index], edge_index);
1207 for (const int64_t tri_index : range) {
1208 const Vector<int> &face = tris[tri_index];
1209 tri_edges[tri_index] = int3(edge_to_index.lookup(OrderedEdge(face[0], face[1])),
1210 edge_to_index.lookup(OrderedEdge(face[1], face[2])),
1211 edge_to_index.lookup(OrderedEdge(face[2], face[0])));
1226 for (
const int tri_index : tris.index_range()) {
1228 const int edge_index = tri_edges[tri_index][j];
1232 if (edge_to_tris[edge_index].first ==
NULL_INDEX) {
1233 edge_to_tris[edge_index].
first = tri_index;
1236 edge_to_tris[edge_index].second = tri_index;
1242 for (const int64_t tri_index : range) {
1243 for (const int j : IndexRange(3)) {
1244 const int edge = tri_edges[tri_index][j];
1246 const int index_0 = edge_to_tris[edge].first;
1247 if (!ELEM(index_0, tri_index, NULL_INDEX)) {
1248 tri_adjacency[tri_index][j] = index_0;
1252 const int index_1 = edge_to_tris[edge].second;
1253 if (!ELEM(index_1, tri_index, NULL_INDEX)) {
1254 tri_adjacency[tri_index][j] = index_1;
1258 tri_adjacency[tri_index][j] = NULL_INDEX;
1263 return tri_adjacency;
1271 for (const int64_t edge_index : range) {
1272 const int2 &edge = edges[edge_index];
1273 const double2 &v1 = verts[edge[0]];
1274 const double2 &v2 = verts[edge[1]];
1275 edge_weights[edge_index] = math::distance(v1, v2);
1279 return edge_weights;
1291 for (
const int64_t tri_index : range) {
1293 const int next_tri = tri_adjacency[tri_index][j];
1294 const int edge_index = tri_edges[tri_index][j];
1300 if (is_source_edge[edge_index]) {
1304 tri_max_weight[tri_index] =
math::max(tri_max_weight[tri_index], edge_weights[edge_index]);
1309 return tri_max_weight;
1317 const int hint_tri_index,
1318 const int hint_index,
1322 r_tri_hint_index[hint_tri_index] = hint_index;
1323 r_tri_weights[hint_tri_index] = tri_max_weight[hint_tri_index];
1325 std::queue<int> tris_to_check;
1327 tris_to_check.push(hint_tri_index);
1329 while (!tris_to_check.empty()) {
1330 const int tri_index = tris_to_check.front();
1331 tris_to_check.pop();
1334 const int next_tri = tri_adjacency[tri_index][j];
1335 const int edge_index = tri_edges[tri_index][j];
1340 if (is_source_edge[edge_index]) {
1344 const float weight = std::min(edge_weights[edge_index], r_tri_weights[tri_index]);
1346 const float next_tri_weight = r_tri_weights[next_tri];
1347 const int next_tri_hint = r_tri_hint_index[next_tri];
1348 if (weight > next_tri_weight || (weight == next_tri_weight && next_tri_hint != hint_index)) {
1349 tris_to_check.push(next_tri);
1350 r_tri_hint_index[next_tri] = hint_index;
1351 r_tri_weights[next_tri] = weight;
1362 const std::optional<float> opacity_threshold,
1377 for (const int drawing_i : range) {
1378 const DrawingInfo &info = src_drawings[drawing_i];
1380 const Layer &layer = *grease_pencil.layers()[info.layer_index];
1381 const float4x4 layer_to_world = layer.to_world_space(object);
1382 const bke::CurvesGeometry &curves = info.drawing.strokes();
1383 const Span<float3> evaluated_positions = curves.evaluated_positions();
1384 const OffsetIndices<int> eval_points_by_curve = curves.evaluated_points_by_curve();
1385 const bool only_boundary_strokes = boundary_layers[info.layer_index];
1386 const VArray<float> radii = info.drawing.radii();
1387 const VArray<float> opacities = info.drawing.opacities();
1389 Array<float> opacities_array(curves.points_num());
1390 array_utils::copy(opacities, opacities_array.as_mutable_span());
1391 curves.ensure_can_interpolate_to_evaluated();
1393 Array<float> eval_opacities(eval_points_by_curve.total_size());
1394 curves.interpolate_to_evaluated(opacities_array.as_span(), eval_opacities.as_mutable_span());
1396 const bke::AttributeAccessor attributes = curves.attributes();
1397 const VArray<bool> cyclic = curves.cyclic();
1398 const VArray<int> materials = *attributes.lookup_or_default<int>(
1399 attr_material_index, bke::AttrDomain::Curve, 0);
1400 const VArray<bool> is_boundary_stroke = *attributes.lookup_or_default<bool>(
1401 attr_is_fill_guide, bke::AttrDomain::Curve, false);
1402 const VArray<int> fill_id = *attributes.lookup_or_default<int>(
1403 "fill_id", bke::AttrDomain::Curve, 0);
1404 const VArray<int> hide_stroke = *attributes.lookup_or_default<int>(
1405 "hide_stroke", bke::AttrDomain::Curve, 0);
1406 const VArray<float> fill_opacities = *attributes.lookup_or_default<float>(
1407 "fill_opacity", bke::AttrDomain::Curve, 1.0f);
1409 IndexMaskMemory curve_mask_memory;
1410 const IndexMask curve_mask = get_visible_boundary_strokes(
1411 object, info, only_boundary_strokes, curve_mask_memory);
1413 curve_mask.foreach_index([&](const int curve_i) {
1414 const IndexRange eval_points = eval_points_by_curve[curve_i];
1415 const bool is_fill = fill_id[curve_i];
1416 const bool is_stroke_hidden = hide_stroke[curve_i];
1417 const bool is_cyclic = cyclic[curve_i] || is_fill;
1419 if (eval_points.size() < 2) {
1424 const int material_index = materials[curve_i];
1425 Material *mat = BKE_object_material_get(const_cast<Object *>(&object), material_index + 1);
1426 if (mat == nullptr || (mat->gp_style->flag & GP_MATERIAL_HIDE)) {
1429 const float material_stroke_alpha = mat->gp_style->stroke_rgba[3];
1430 const float material_fill_alpha = mat->gp_style->fill_rgba[3];
1433 if (only_boundary_strokes && !is_boundary_stroke[curve_i]) {
1437 if (is_fill && is_stroke_hidden) {
1439 if (opacity_threshold &&
1440 (material_fill_alpha * fill_opacities[curve_i] < *opacity_threshold))
1446 const int first_point_offset = drawing_input_verts[drawing_i].size();
1447 int point_offset = first_point_offset;
1448 Array<bool> is_point_visible(eval_points.size(), false);
1449 for (const int point_i : eval_points) {
1452 if (opacity_threshold &&
1453 (material_stroke_alpha * eval_opacities[point_i] < *opacity_threshold))
1459 const float3 pos_world = math::transform_point(layer_to_world,
1460 evaluated_positions[point_i]);
1462 eV3DProjStatus result = ED_view3d_project_float_global(
1463 ®ion, pos_world, pos_view, V3D_PROJ_TEST_NOP);
1464 if (result == V3D_PROJ_RET_OK) {
1465 drawing_input_verts[drawing_i].append(double2(pos_view));
1466 is_point_visible[point_i - eval_points.first()] = true;
1470 for (const int local_i : eval_points.index_range().drop_back(is_cyclic ? 0 : 1)) {
1471 const int local_next = (local_i + 1) % eval_points.size();
1472 const int point_offset_next = local_next == local_i + 1 ? (point_offset + 1) :
1474 if (is_point_visible[local_i]) {
1475 if (is_point_visible[local_next]) {
1476 drawing_input_edges[drawing_i].append(OrderedEdge(point_offset, point_offset_next));
1485 Array<int> drawing_vert_offset_data(src_drawings.size() + 1);
1486 Array<int> drawing_edge_offset_data(src_drawings.size() + 1);
1489 for (const int i : range) {
1490 drawing_vert_offset_data[i] = drawing_input_verts[i].size();
1491 drawing_edge_offset_data[i] = drawing_input_edges[i].size();
1496 drawing_vert_offset_data);
1498 drawing_edge_offset_data);
1500 if (drawing_vert_offsets.
total_size() == 0) {
1501 return std::nullopt;
1505 r_cdt_verts = Array<double2>(drawing_vert_offsets.
total_size() + 4);
1506 r_cdt_edges = Array<int2>(drawing_edge_offsets.
total_size());
1508 meshintersect::CDT_input<double> input;
1509 input.needed_ids = CDT_ORIG_EDGES | CDT_ORIG_VERTS;
1510 input.vert = r_cdt_verts;
1511 input.edge = r_cdt_edges;
1513 MutableSpan<double2> verts_span = r_cdt_verts.as_mutable_span();
1514 threading::parallel_for(drawing_input_verts.index_range(), 512, [&](
const IndexRange range) {
1515 for (const int drawing_i : range) {
1516 const IndexRange drawing_range = drawing_vert_offsets[drawing_i];
1517 array_utils::copy(drawing_input_verts[drawing_i].as_span(), verts_span.slice(drawing_range));
1521 MutableSpan<int2> edges_span = r_cdt_edges.as_mutable_span();
1522 threading::parallel_for(drawing_input_edges.index_range(), 512, [&](
const IndexRange range) {
1523 for (const int drawing_i : range) {
1524 const IndexRange drawing_range = drawing_edge_offsets[drawing_i];
1525 MutableSpan<int2> edges_slice = edges_span.slice(drawing_range);
1526 array_utils::copy(drawing_input_edges[drawing_i].as_span().cast<int2>(), edges_slice);
1527 const IndexRange vert_range = drawing_vert_offsets[drawing_i];
1528 if (vert_range.is_empty()) {
1531 const int vert_offset = vert_range.first();
1532 for (const int edge_i : drawing_range.index_range()) {
1533 edges_slice[edge_i] = int2(edges_slice[edge_i][0] + vert_offset,
1534 edges_slice[edge_i][1] + vert_offset);
1539 Bounds<double2> bound = *bounds::min_max(r_cdt_verts.as_span().drop_back(4));
1543 bound.pad(math::max(bound.size().x, bound.size().y) * 1.1f);
1545 const std::array<double2, 4>
corners = bounds::corners(bound);
1546 r_cdt_verts.as_mutable_span().take_back(4).copy_from(corners);
1559 for (
const int tri_index : tri_to_fill.
index_range()) {
1560 if (!tri_to_fill[tri_index]) {
1565 const int next_tri = tri_adjacency[tri_index][j];
1566 const int edge_index = tri_edges[tri_index][j];
1571 return std::nullopt;
1577 if (tri_to_fill[next_tri]) {
1581 boundary_edges.
add_new(edge_index);
1591 for (
const int edge_index : boundary_edges) {
1592 edges_to_keep[edge_index] =
true;
1604 for (
const int edge_index : boundary_edges) {
1605 const int2 edge = edges[edge_index];
1610 vert_to_edge_ends.
add(edge[0], point_1);
1611 vert_to_edge_ends.
add(edge[1], point_2);
1616 for (
const int edge_pair_index :
IndexRange(edge_ends.size() / 2)) {
1620 connect(end_1, end_2);
1634 const std::optional<float> opacity_threshold,
1635 const bool internal_gaps,
1636 const float gap_factor,
1641 Depsgraph &depsgraph = *view_context.
depsgraph;
1654 src_drawings,
object, boundary_layers, region, opacity_threshold, cdt_verts, cdt_edges);
1656 return std::nullopt;
1665 for (const int64_t edge_index : range) {
1666 for (const uint32_t orig_id : result.edge_orig[edge_index]) {
1667 if (orig_id < result.face_edge_offset) {
1668 is_source_edge[edge_index] = true;
1676 const Array<int3> tri_adjacency = get_all_triangle_adjacency(
1680 auto get_tri_for_point = [&](
const float2 &
v) {
1681 for (
const int tri_index :
result.face.index_range()) {
1704 auto is_tri_connected_to_boundary = [&](
const int tri_index) {
1705 const Vector<int> &tri =
result.face[tri_index];
1707 for (
const int j : IndexRange(3)) {
1708 for (
const int orig_point :
result.vert_orig[tri[j]]) {
1709 if (src_boundary_points.contains(orig_point)) {
1719 auto get_first_boundary_tri = [&]() {
1720 for (
const int tri_index :
result.face.index_range()) {
1721 if (is_tri_connected_to_boundary(tri_index)) {
1733 is_source_edge.as_span());
1735 Array<int> tri_hint_index(
result.face.size(), NULL_INDEX);
1736 Array<float> tri_weights(
result.face.size(), 0.0f);
1745 Set<int> tris_for_hint;
1747 const int hint_tri_index = get_tri_for_point(hint_points[i]);
1748 if (hint_tri_index != NULL_INDEX && !is_tri_connected_to_boundary(hint_tri_index)) {
1749 tris_for_hint.add(hint_tri_index);
1754 if (tris_for_hint.is_empty()) {
1756 return std::nullopt;
1758 tris_for_hint.add(get_first_boundary_tri());
1761 if (internal_gaps && gap_factor > 0.0f) {
1762 for (
const int hint_tri_index : tris_for_hint) {
1766 tri_max_weight.as_span(),
1767 is_source_edge.as_span(),
1770 tri_hint_index.as_mutable_span(),
1771 tri_weights.as_mutable_span());
1776 Set<int> not_full_tris;
1777 for (
const int tri_index :
result.face.index_range()) {
1778 if (tri_weights[tri_index] < tri_max_weight[tri_index] * gap_factor) {
1779 not_full_tris.add_new(tri_index);
1783 auto get_next_max_tri_index = [&]() {
1784 if (not_full_tris.is_empty()) {
1789 float max_not_weight_tri_weight = 0.0f;
1791 for (
const int tri_index : not_full_tris) {
1792 const float tri_weight = tri_weights[tri_index];
1793 if (max_not_weight_tri_weight < tri_weight) {
1794 max_not_weight_tri_index = tri_index;
1795 max_not_weight_tri_weight = tri_weight;
1798 return max_not_weight_tri_index;
1801 int hint_tri_index = get_next_max_tri_index();
1804 while (hint_tri_index != NULL_INDEX) {
1808 tri_max_weight.as_span(),
1809 is_source_edge.as_span(),
1812 tri_hint_index.as_mutable_span(),
1813 tri_weights.as_mutable_span());
1815 hint_tri_index = get_next_max_tri_index();
1818 not_full_tris.remove_if([&](
const int tri_index) {
1819 return tri_weights[tri_index] >= tri_max_weight[tri_index] * gap_factor;
1824 int hint_tri_index = get_first_boundary_tri();
1828 tri_max_weight.as_span(),
1829 is_source_edge.as_span(),
1832 tri_hint_index.as_mutable_span(),
1833 tri_weights.as_mutable_span());
1839 for (
const int hint_tri_index : tris_for_hint) {
1844 tri_max_weight.as_span(),
1845 is_source_edge.as_span(),
1848 tri_hint_index.as_mutable_span(),
1849 tri_weights.as_mutable_span());
1853 Set<int> indices_to_fill({hint_index});
1855 Array<bool> tri_to_fill(
result.face.size(),
false);
1858 threading::parallel_for(
result.face.index_range(), 512, [&](
const IndexRange range) {
1859 for (const int64_t tri_index : range) {
1860 if (tri_hint_index[tri_index] != 0) {
1861 tri_to_fill[tri_index] = true;
1867 threading::parallel_for(
result.face.index_range(), 512, [&](
const IndexRange range) {
1868 for (const int64_t tri_index : range) {
1869 if (indices_to_fill.contains(tri_hint_index[tri_index])) {
1870 tri_to_fill[tri_index] = true;
1877 tri_to_fill,
invert, tri_adjacency, tri_edges,
result.edge.as_span());
1880 return std::nullopt;
1885 const OffsetIndices<int> output_verts_offset = OffsetIndices<int>(edge_curves->offset_data);
1887 if (output_verts_offset.total_size() == 0) {
1888 return std::nullopt;
1891 bke::CurvesGeometry
curves(output_verts_offset.total_size(), output_verts_offset.size());
1892 curves.offsets_for_write().copy_from(output_verts_offset.data());
1894 MutableSpan<float3> positions =
curves.positions_for_write();
1896 threading::parallel_for(output_verts_offset.index_range(), 512, [&](
const IndexRange range) {
1897 for (const int64_t curve_i : range) {
1898 const IndexRange edges_range = output_verts_offset[curve_i];
1900 for (const int point_i : edges_range) {
1901 const int edge_index = edge_curves->edges[point_i];
1902 const bool reversed = edge_curves->reversed[point_i];
1903 const int2 edge = result.edge[edge_index];
1904 const int vert_id = reversed ? edge[1] : edge[0];
1906 const float2 pos_2d = float2(result.vert[vert_id]);
1907 const float3 position = placement.project(pos_2d);
1908 positions[point_i] = position;
1913 curves.cyclic_for_write().fill(
true);
1915 curves.tag_topology_changed();
Camera data-block and utility functions.
Low-level operations for curves.
Low-level operations for grease pencil.
General operations, lookup, etc. for materials.
#define BLI_SCOPED_DEFER(function_to_defer)
Object is a sort of wrapper for general info.
#define BLI_assert_unreachable()
constexpr IndexRange index_range() const
Span< T > as_span() const
IndexRange index_range() const
static IndexMask from_predicate(const IndexMask &universe, LinearAllocator<> &memory, Fn &&predicate, exec_mode::Mode mode=exec_mode::parallel)
constexpr int64_t size() const
constexpr bool is_empty() const
constexpr IndexRange()=default
constexpr IndexRange take_back(int64_t n) const
constexpr IndexRange index_range() const
void add_new(const Key &key, const Value &value)
void add(const Key &key, const Value &value)
MapType::ValueIterator values() const
constexpr MutableSpan()=default
constexpr IndexRange index_range() const
void add_new(const Key &key)
constexpr int64_t size() const
constexpr IndexRange index_range() const
void push(const T &value)
static VArray from_single(T value, const int64_t size)
static VArray from_container(ContainerT container)
void append(const T &value)
GAttributeReader lookup_or_default(StringRef name, AttrDomain domain, AttrType data_type, const void *default_value=nullptr) const
AttributeAccessor attributes() const
IndexRange curves_range() const
OffsetIndices< int > points_by_curve() const
const bke::CurvesGeometry & strokes() const
bool use_project_to_surface() const
void cache_viewport_depths(Depsgraph *depsgraph, ARegion *region, View3D *view3d)
bool use_project_to_stroke() const
float3 project_with_shift(float2 co) const
float3 project(float2 co, bool &clipped) const
MutableSpan< ColorGeometry4b > pixels()
Span< ColorGeometry4b > pixels() const
ColorGeometry4b & pixel_from_coord(const int2 &c)
int2 coord_from_index(const int index) const
int index_from_coord(const int2 &c) const
bool is_valid_coord(const int2 &c) const
const ColorGeometry4b & pixel_from_coord(const int2 &c) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
float2x2 invert(float2x2 mat)
void fill_index_range(MutableSpan< T > span, const T start=0)
GeometryDeformation get_evaluated_grease_pencil_drawing_deformation(const Object *ob_eval, const Object &ob_orig, const bke::greasepencil::Drawing &drawing_orig)
void fill_points(OffsetIndices< int > points_by_curve, const IndexMask &curve_selection, GPointer value, GMutableSpan dst)
Bounds< T > merge(const Bounds< T > &a, const Bounds< T > &b)
std::array< VecBase< T, 3 >, 8 > corners(const Bounds< VecBase< T, 3 > > &bounds)
void compute_view_matrices(const ViewContext &view_context, const Scene &scene, const int2 &win_size, const float2 &zoom, const float2 &offset)
void region_reset(ARegion ®ion, const RegionViewData &data)
void draw_lines(const float4x4 &transform, IndexRange indices, Span< float3 > start_positions, Span< float3 > end_positions, const VArray< ColorGeometry4f > &colors, float line_width)
Image * image_render_end(Main &bmain, GPUOffScreen *buffer)
void draw_grease_pencil_strokes(const RegionView3D &rv3d, const int2 &win_size, const Object &object, const bke::greasepencil::Drawing &drawing, const float4x4 &transform, const IndexMask &strokes_mask, const VArray< ColorGeometry4f > &colors, const bool use_xray, const float radius_scale)
RegionViewData region_init(ARegion ®ion, const int2 &win_size)
void draw_dot(const float4x4 &transform, const float3 &position, const float point_size, const ColorGeometry4f &color)
GPUOffScreen * image_render_begin(const int2 &win_size)
void clear_projection_matrix()
void set_projection_matrix(const RegionView3D &rv3d)
static Side decode_side(const EncodedConnection encoded)
static IndexMask get_visible_boundary_strokes(const Object &object, const DrawingInfo &info, const bool is_boundary_layer, IndexMaskMemory &memory)
static const int2 offset_by_direction[num_directions]
static int decode_index(const EncodedConnection encoded)
VecBase< EncodedConnection, 2 > EdgeConnections
bke::CurvesGeometry pixel_fill_strokes(const ViewContext &view_context, const Brush &brush, const Scene &scene, const bke::greasepencil::Layer &layer, const VArray< bool > &boundary_layers, const Span< DrawingInfo > src_drawings, bool invert, const std::optional< float > opacity_threshold, const float2 &fill_point, const ExtensionData &extensions, FillToolFitMethod fit_method, bool keep_images)
static FillBoundary build_fill_boundary(const ImageBufferAccessor &buffer)
static Image * render_strokes(const ViewContext &view_context, const Brush &brush, const Scene &scene, const bke::greasepencil::Layer &layer, const VArray< bool > &boundary_layers, const Span< DrawingInfo > src_drawings, const int2 &image_size, const std::optional< float > opacity_threshold, const float2 &fill_point, const ExtensionData &extensions, const ed::greasepencil::DrawingPlacement &placement, const float2 &zoom, const float2 &offset)
std::optional< bke::CurvesGeometry > delaunay_fill_strokes(const ViewContext &view_context, const Scene &scene, const bke::greasepencil::Layer &layer, const VArray< bool > &boundary_layers, const Span< DrawingInfo > src_drawings, bool invert, std::optional< float > opacity_threshold, bool internal_gaps, float gap_factor, const GroupedSpan< float2 > &fill_points)
constexpr const char * attr_is_fill_guide
constexpr const char * attr_material_index
static Bounds< float2 > get_region_bounds(const ARegion ®ion)
static void dilate(ImageBufferAccessor &buffer, int iterations=1)
static std::optional< EdgeCurves > create_connected_edges_from_fill(const Span< bool > tri_to_fill, const bool invert, const Span< int3 > tri_adjacency, const Span< int3 > tri_edges, const Span< int2 > edges)
FillResult flood_fill(ImageBufferAccessor &buffer, const int leak_filter_width=0)
static void erode(ImageBufferAccessor &buffer, int iterations=1)
static Array< float > get_tri_max_weight(const int num_tris, const Span< int3 > tri_adjacency, const Span< int3 > tri_edges, const Span< float > edge_weights, const Span< bool > is_source_edge)
const ColorGeometry4f draw_boundary_color
static Array< int3 > get_all_triangle_edges(const Span< int2 > edges, const Span< Vector< int > > tris)
static int wrap_dir_3n(const int dir)
static Array< float > get_edge_weights(const Span< int2 > edges, const Span< double2 > verts)
constexpr const int num_directions
static VArray< ColorGeometry4f > get_stroke_colors(const Object &object, const bke::CurvesGeometry &curves, const VArray< float > &opacities, const VArray< int > materials, const ColorGeometry4f &tint_color, const std::optional< float > opacity_threshold)
static EdgeCurves follow_edge_connections(const Span< int > all_edges, const Span< bool > edges_to_keep, const Span< EdgeConnections > edge_connections)
static Array< int3 > get_all_triangle_adjacency(const int num_edges, const Span< Vector< int > > tris, const Span< int3 > tri_edges)
static bke::CurvesGeometry boundary_to_curves(const FillBoundary &boundary, const ImageBufferAccessor &buffer, const ed::greasepencil::DrawingPlacement &placement, const float3x3 &image_to_region)
static void mark_borders(ImageBufferAccessor &buffer)
static std::optional< Bounds< float2 > > get_boundary_bounds(const ARegion ®ion, const RegionView3D &rv3d, const Object &object, const Object &object_eval, const VArray< bool > &boundary_layers, const Span< DrawingInfo > src_drawings)
static constexpr EncodedConnection EDGE_CONNECTION_NULL
static void convert_colors_to_flags(ImageBufferAccessor &buffer)
static bke::CurvesGeometry process_image(Image &ima, const Brush &brush, const ed::greasepencil::DrawingPlacement &placement, const float3x3 &image_to_region, const bool invert, const bool output_as_colors)
static void add_weights_for_tri(const Span< int3 > tri_adjacency, const Span< int3 > tri_edges, const Span< float > edge_weights, const Span< float > tri_max_weight, const Span< bool > is_source_edge, const int hint_tri_index, const int hint_index, MutableSpan< int > r_tri_hint_index, MutableSpan< float > r_tri_weights)
static auto fit_strokes_to_view(const ViewContext &view_context, const VArray< bool > &boundary_layers, const Span< DrawingInfo > src_drawings, const FillToolFitMethod fit_method, const float2 fill_point, const bool uniform_zoom, const float max_zoom_factor, const float2 margin, const float pixel_scale)
static EncodedConnection encode_index_and_side(const int index, const Side side)
static std::optional< meshintersect::CDT_input< double > > get_input_from_drawings(const Span< DrawingInfo > src_drawings, const Object &object, const VArray< bool > &boundary_layers, const ARegion ®ion, const std::optional< float > opacity_threshold, Array< double2 > &r_cdt_verts, Array< int2 > &r_cdt_edges)
static void convert_flags_to_colors(ImageBufferAccessor &buffer)
static void set_flag(ColorGeometry4b &color, const ColorFlag flag, bool value)
const ColorGeometry4f draw_seed_color
static bool get_flag(const ColorGeometry4b &color, const ColorFlag flag)
static void invert_fill(ImageBufferAccessor &buffer)
ENUM_OPERATORS(AxisMutable)
constexpr ParallelGrainSize grain_size(int grain_size)
T clamp(const T &a, const T &min, const T &max)
T safe_divide(const T &a, const T &b)
T reduce_max(const VecBase< T, Size > &a)
MatT from_loc_scale(const typename MatT::loc_type &location, const VecBase< typename MatT::base_type, ScaleDim > &scale)
bool almost_equal_relative(const VecBase< T, Size > &a, const VecBase< T, Size > &b, const T &epsilon_factor)
T max(const T &a, const T &b)
VecBase< T, 3 > transform_point(const CartesianBasis &basis, const VecBase< T, 3 > &v)
OffsetIndices< int > accumulate_counts_to_offsets(MutableSpan< int > counts_to_offsets, int start_offset=0)
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)
float ED_view3d_pixel_size(const RegionView3D *rv3d, const float co[3])
Material * BKE_object_material_get(Object *ob, short act)
void GPU_depth_mask(bool depth)
ATTR_WARN_UNUSED_RESULT const BMVert * v
MatBase< float, 4, 4 > float4x4
int isect_point_tri_v2(const float pt[2], const float v1[2], const float v2[2], const float v3[2])
VecBase< int32_t, 2 > int2
VecBase< float, 2 > float2
VecBase< int32_t, 3 > int3
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)
MatBase< float, 3, 3 > float3x3
void BKE_id_free(Main *bmain, void *idv)
ImBuf * BKE_image_acquire_ibuf(Image *ima, ImageUser *iuser, void **r_lock)
ColorSceneLinear4f< eAlpha::Premultiplied > ColorGeometry4f
void GPU_blend(GPUBlend blend)
VecBase< float, 3 > float3
ColorSceneLinearByteEncoded4b< eAlpha::Premultiplied > ColorGeometry4b
void BKE_image_release_ibuf(Image *ima, ImBuf *ibuf, void *lock)
static MatBase identity()
eMaterialGPencilStyle_Flag flag
const bke::greasepencil::Drawing & drawing
Vector< int > offset_data
struct blender::ed::greasepencil::ExtensionData::@147343236172247015273153246111172323157377245354 lines
Vector< int > offset_indices