11#include <fmt/format.h>
76#define USE_NET_ISLAND_CONNECT
78#define KMAXDIST (10 * UI_SCALE_FAC)
83#define KNIFE_FLT_EPS 0.00001f
84#define KNIFE_FLT_EPS_SQUARED (KNIFE_FLT_EPS * KNIFE_FLT_EPS)
85#define KNIFE_FLT_EPSBIG 0.0005f
87#define KNIFE_FLT_EPS_PX_VERT 0.5f
88#define KNIFE_FLT_EPS_PX_EDGE 0.05f
89#define KNIFE_FLT_EPS_PX_FACE 0.05f
91#define KNIFE_DEFAULT_ANGLE_SNAPPING_INCREMENT 30.0f
92#define KNIFE_MIN_ANGLE_SNAPPING_INCREMENT 0.0f
93#define KNIFE_MAX_ANGLE_SNAPPING_INCREMENT 180.0f
173 return this->ob_index == -1;
241#ifdef USE_NET_ISLAND_CONNECT
444 float numstr_size[2];
447 const float font_size = 14.0f;
448 const int distance_precision = 4;
459 numstr,
sizeof(numstr), cut_len, distance_precision,
B_UNIT_LENGTH, unit,
false,
true);
469 posit[0] -= numstr_size[0] / 2.0f;
470 posit[1] -= numstr_size[1] / 2.0f;
473 float color_back[4] = {0.0f, 0.0f, 0.0f, 0.5f};
478 posit[0] - bg_margin,
479 posit[1] - bg_margin,
480 posit[0] + bg_margin + numstr_size[0],
481 posit[1] + bg_margin + numstr_size[1]);
499 const float start[3],
502 const float start_ss[2],
503 const float mid_ss[2],
504 const float end_ss[2],
508 const int arc_steps = 24;
512 const float font_size = 14.0f;
513 const int angle_precision = 3;
533 const float inverse_average_scale = 1 / (ob->object_to_world().ptr()[0][0] +
534 ob->object_to_world().ptr()[1][1] +
535 ob->object_to_world().ptr()[2][2]);
537 const float px_scale =
538 3.0f * inverse_average_scale *
540 std::min({arc_size,
len_v2v2(start_ss, mid_ss) / 2.0f,
len_v2v2(end_ss, mid_ss) / 2.0f}));
558 for (
int j = 0; j <= arc_steps; j++) {
580 float numstr_size[2];
603 posit[0] = mid_ss[0] + (cap_size * 2.0f);
604 posit[1] = mid_ss[1] - (numstr_size[1] / 2.0f);
607 float color_back[4] = {0.0f, 0.0f, 0.0f, 0.5f};
612 posit[0] - bg_margin,
613 posit[1] - bg_margin,
614 posit[0] + bg_margin + numstr_size[0],
615 posit[1] + bg_margin + numstr_size[1]);
652 if (tempkfe->
v1 != kfv) {
653 tempkfv = tempkfe->
v1;
656 tempkfv = tempkfe->
v2;
659 if (
angle < min_angle) {
694 if (angle1 < angle2) {
721 if (kfe->
v1 != kfv) {
735 if (tempkfe->
v1 != kfv) {
736 tempkfv = tempkfe->
v1;
739 tempkfv = tempkfe->
v2;
742 if (
angle < min_angle) {
784 if (angle1 < angle2) {
990 if (total_hits > 0) {
993 gpu::VertBuf *vert = GPU_vertbuf_create_with_format(*format);
996 int other_verts_count = 0;
997 int snapped_verts_count = 0;
1016 if (snapped_verts_count > 0) {
1025 if (other_verts_count > 0) {
1065 auto get_modal_key_str = [&](
int id) {
1089 const std::string
angle = fmt::format(
1090 "{}: {:.2f}({:.2f}) ({}{}{}{})",
1091 IFACE_(
"Angle Constraint"),
1120 int tri_index_buf[3])
1126 const std::array<BMLoop *, 3> <ri = obinfo->
em->
looptris[tri_index];
1127 for (
int i = 0; i < 3; i++) {
1130 return tri_index_buf;
1141 for (
int i = 0; i < 3; i++) {
1153 for (
int i = 0; i < 3; i++) {
1180 bool (*test_fn)(
BMFace *);
1193 BMFace *f_test =
nullptr, *f_test_prev =
nullptr;
1194 bool test_fn_ret =
false;
1201 for (
int i = 0; i < em->
looptris.size(); i++) {
1203 if (f_test != f_test_prev) {
1204 test_fn_ret = test_fn(f_test);
1205 f_test_prev = f_test;
1213 tottri += ob_tottri;
1218 f_test_prev =
nullptr;
1219 test_fn_ret =
false;
1227 for (
const int ob_index : kcd->
objects.index_range()) {
1232 for (
int i = 0; i < em->
looptris.size(); i++) {
1234 f_test = looptris[i][0]->f;
1235 if (f_test != f_test_prev) {
1236 test_fn_ret = test_fn(f_test);
1237 f_test_prev = f_test;
1244 float tri_cos[3][3];
1274 BMLoop *
const *ltri =
nullptr;
1284 for (; ob_index < kcd->
objects.size(); ob_index++) {
1289 if (
index < tottri) {
1302 float tri_cos[3][3];
1304 isect = (ray->
radius > 0.0f ?
1307#ifdef USE_KDOPBVH_WATERTIGHT
1314 if (isect && dist < hit->dist) {
1345 const float dist = r_dist ? *r_dist :
FLT_MAX;
1352 if (hit.
index != -1 && hit.
dist != dist) {
1380 bool (*filter_cb)(
BMFace *f,
void *userdata),
1381 void *filter_userdata)
1407 const float mval[2],
1422 float origin_ofs[3];
1423 float ray[3], ray_normal[3];
1435 bool v1_inside, v2_inside;
1436 bool v1_inface, v2_inface;
1439 if (!f || !v1 || !
v2) {
1452 v1_inface = (l1 !=
nullptr);
1453 v2_inface = (l2 !=
nullptr);
1458 if ((v1_inface && v2_inside) || (v2_inface && v1_inside) || (v1_inside && v2_inside)) {
1462 if (v1_inface && v2_inface) {
1494 ele_test =
reinterpret_cast<BMElem *
>(kfv->
v);
1496 if (r_kfe || ele_test ==
nullptr) {
1497 if (kfv->
v ==
nullptr) {
1511 if (ele_test ==
nullptr) {
1513 ele_test =
reinterpret_cast<BMElem *
>(kfe->
e);
1518 if (ele_test ==
nullptr) {
1519 if (kfe->
faces.is_single()) {
1531 ele_test =
reinterpret_cast<BMElem *
>(kfe->
e);
1533 if (ele_test ==
nullptr) {
1534 ele_test =
reinterpret_cast<BMElem *
>(kfe->
basef);
1548 ListBaseT<LinkData> *
list;
1550 list =
static_cast<ListBaseT<LinkData> *
>(
1552 list->clear_no_delete();
1568 if (ref1.data == ref) {
1606 if (ref1.data == ref2.data) {
1607 return static_cast<BMFace *
>(ref1.data);
1643 const float *cageco;
1658 mul_v3_m4v3(cageco_ws, ob->object_to_world().ptr(), cageco);
1727 const float cageco[3],
1734 newkfe->
v1 = kfe->
v1;
1755 kfe->
v1 = newkfe->
v2;
1787 kfe->
v1 = newkfe->
v1;
1804 const float3 *curr_cage_constrain,
1844 if (lh1.
l < lh2.
l) {
1847 if (lh1.
l > lh2.
l) {
1850 if (lh1.
m < lh2.
m) {
1853 if (lh1.
m > lh2.
m) {
1856 if (lh1.
v < lh2.
v) {
1859 if (lh1.
v > lh2.
v) {
1872 bool is_double =
false;
1885 for (
int i = 0; i < total_hits; i++) {
1887 if (lhi->
v ==
nullptr) {
1891 for (
int j = i - 1; j >= 0; j--) {
1899 if (lhi->
kfe == lhj->
kfe) {
1904 for (
int j = i + 1; j < total_hits; j++) {
1909 if ((lhj->
kfe && (lhi->
kfe == lhj->
kfe)) || (lhi->
v == lhj->
v)) {
1920 while (j < total_hits) {
1923 if (lhj->
l == -1.0f) {
1928 if (lhi->
l == -1.0f) {
1947 Map<
BMFace *, ListBaseT<LinkData> *> &facehits,
1951 ListBaseT<LinkData> *
list = facehits.lookup_or_add_cb(f,
1965 if (lh->
v && lh->
v->
v) {
1973 else if (lh->
kfe && lh->
kfe->
e) {
1993 if ((lh1->
v && lh1->
v == lh2->
v) || (lh1->
kfe && lh1->
kfe == lh2->
kfe)) {
1998 if ((lh1->
v && lh2->
v) && (lh1->
v->
v && lh2->
v && lh2->
v->
v) &&
2010 if ((lh1->
v && !lh1->
kfe) && (lh2->
v && !lh2->
kfe)) {
2023 else if (lh1->
kfe) {
2039 else if (lh2->
kfe) {
2074 for (r = hits->first(); r->
next; r = r->
next) {
2083 ListBaseT<LinkData> *kfedges)
2086 int edge_array_len = kfedges->count();
2100 bool is_new_edge =
false;
2101 kfe =
static_cast<KnifeEdge *
>(ref.data);
2107 if (kfe->
e ==
nullptr) {
2108 if (kfe->
v1->
v && kfe->
v2->
v) {
2120 if (kfe->
v1->
v ==
nullptr) {
2123 if (kfe->
v2->
v ==
nullptr) {
2138 if (kcd->
edgenet.edge_visit->add(kfe->
e)) {
2139 kfe_array[i] = is_new_edge ? kfe :
nullptr;
2140 edge_array[i] = kfe->
e;
2146 const int edge_array_len_orig = i;
2149#ifdef USE_NET_ISLAND_CONNECT
2150 uint edge_array_holes_len;
2151 BMEdge **edge_array_holes;
2159 &edge_array_holes_len))
2162 for (i = edge_array_len; i < edge_array_holes_len; i++) {
2167 edge_array_len = edge_array_holes_len;
2168 edge_array = edge_array_holes;
2177 for (i = 0; i < edge_array_len_orig; i++) {
2178 if (kfe_array[i] ==
nullptr) {
2183 kfe_array[i]->
e =
nullptr;
2187#ifdef USE_NET_ISLAND_CONNECT
2192 kcd->
edgenet.edge_visit->clear();
2198 (
static_cast<const LinkData *
>(cur_a_p))->data);
2200 (
static_cast<const LinkData *
>(cur_b_p))->data);
2201 const float *co =
static_cast<const float *
>(co_p);
2222 ListBaseT<LinkData> *
list;
2287 kfv =
static_cast<KnifeVert *
>(ref.data);
2362 for (
const auto &item : facehits.
items()) {
2364 ListBaseT<LinkData> *
list = item.value;
2415 for (i =
index - 1; i >= 0; i--) {
2453 const float face_tol_sq,
2455 float hit_cageco[3])
2462 float tri_norm[3], tri_plane[4];
2463 float se1[2], se2[2];
2465 ListBaseT<LinkData> *
list;
2474 for (; tri_i < tottri; tri_i++) {
2475 float tri_cos[3][3];
2476 float ray_tri_uv[2];
2478 const std::array<BMLoop *, 3> <ri = em->
looptris[tri_i];
2479 if (ltri[0]->f != f) {
2503 kfe =
static_cast<KnifeEdge *
>(ref.data);
2510 if (d < face_tol_sq) {
2534 for (
int ob_index = 0; ob_index < kcd->
objects.size(); ob_index++) {
2542 mul_m4_v3(ob->object_to_world().ptr(), ws);
2549 mul_m4_v3(ob->object_to_world().ptr(), ws);
2562 const float *co11, *co12, *co21, *co22;
2587 switch ((
static_cast<BMElem *
>(user_data))->head.htype) {
2589 ans =
static_cast<BMFace *
>(user_data) != f;
2592 e =
static_cast<BMEdge *
>(user_data);
2645 float view[3], p_ofs[3];
2661 float view_clip[2][3];
2667 view_clip[0], view_clip[1], kcd->
vc.
rv3d->
clip_local, 6, view_clip[0], view_clip[1]))
2669 dist =
len_v3v3(p_ofs, view_clip[1]);
2725 memset(r_hit, 0,
sizeof(*r_hit));
2782 ListBaseT<LinkData> *
list;
2784 float s[2], se1[2], se2[2];
2786 float vert_tol, vert_tol_sq;
2787 float line_tol, line_tol_sq;
2788 float face_tol, face_tol_sq;
2843 for (i = 0,
result = results; i < tot; i++,
result++) {
2845 BMLoop *
const *ltri =
nullptr;
2846 for (ob_index = 0; ob_index < kcd->
objects.size(); ob_index++) {
2869 fobs.
add(f, ob_index);
2900 vert_tol = line_tol = face_tol = 0.5f;
2903 vert_tol_sq = vert_tol * vert_tol;
2904 line_tol_sq = line_tol * line_tol;
2905 face_tol_sq = face_tol * face_tol;
2914 bool kfv_is_in_cut =
false;
2921 kfv_is_in_cut =
true;
2926 if ((d <= vert_tol_sq) &&
2929 kfv_is_in_cut =
true;
2933 if (kfv_is_in_cut) {
2956 bool kfe_is_in_cut =
false;
2961 kfe_is_in_cut =
true;
2967 kfe_is_in_cut =
true;
2971 if (isect_kind == -1) {
2984 if (isect_kind == 1) {
2987 if (!(d1 <= line_tol || d2 <= line_tol ||
fabsf(d1 - d2) <= line_tol)) {
2991 float3 kfe_dir = kfe->v2->cageco - kfe->v1->cageco;
2993 p_cage = kfe->v1->cageco + kfe_dir * lambda;
2997 mid_v3_v3v3(p_cage, kfe->v1->cageco, kfe->v2->cageco);
3000 kfe_is_in_cut =
true;
3006 if (kfe_is_in_cut) {
3007 knife_linehit_set(kcd, s1, s2, p_cage_ss, p_cage, kfe->v1->ob_index,
nullptr, kfe, &hit);
3015 const bool use_hit_prev = (kcd->
prev.
vert ==
nullptr && kcd->
prev.
edge ==
nullptr) ||
3017 const bool use_hit_curr = ((kcd->
curr.
vert ==
nullptr && kcd->
curr.
edge ==
nullptr) ||
3020 if (use_hit_prev || use_hit_curr) {
3044 for (
BMFace *f : faces) {
3045 int ob_index = fobs.
lookup(f);
3060 kcd->
linehits = std::move(linehits);
3062 MEM_delete(results);
3074 kpd->
vert =
nullptr;
3075 kpd->
edge =
nullptr;
3112 vc.
mval[0] = int(mval[0]);
3113 vc.
mval[1] = int(mval[1]);
3123 cage = ray_orig + ray_dir;
3151 const float radius_sq = radius * radius;
3152 ListBaseT<LinkData> *
list;
3168 for (i = 0; i < 2; i++) {
3179 if (dis_sq < radius_sq) {
3211 return density ?
min_ff(maxsize / (
float(density) * 0.5f), maxsize) : maxsize;
3221 const float3 &kfv1_cageco,
3222 const float3 &kfv2_cageco,
3227 if (!
isect_ray_line_v3(cut_origin, cut_dir, kfv1_cageco, kfv2_cageco, &lambda)) {
3244 const float2 &curr_cage_ss,
3245 const float3 *curr_cage_constrain,
3263 const float maxdist_sq = maxdist * maxdist;
3264 float cur_dist_sq = maxdist_sq;
3265 bool has_hit =
false;
3269 (curr_cage_constrain ? *curr_cage_constrain : kcd->
curr.
cage) - kcd->
prev.
cage);
3275 float test_cagep[3];
3300 if (dis_sq >= cur_dist_sq) {
3311 cur_dist_sq = dis_sq;
3320 r_kpd->
mval = closest_ss;
3347 const float maxdist_sq = maxdist * maxdist;
3349 float cur_kfv_sco[2];
3350 float dis_sq, curdis_sq =
FLT_MAX;
3352 for (
int i = 0; i < 2; i++) {
3369 if (dis_sq < curdis_sq && dis_sq < maxdist_sq) {
3386 r_kpd->
mval = cur_kfv_sco;
3401 const float angle_delta = (
roundf(
angle / angle_snap) * angle_snap) -
angle;
3403 return angle + angle_delta;
3414 float3 curr_cage_projected;
3416 curr_cage_projected, ray_orig, ray_orig + ray_dir, kcd->
prev.
cage, axis))
3438 r_cage = kcd->
prev.
cage + dvec_snap;
3525 float3 prev_ray_orig, prev_ray_dir;
3536 kcd, prev_ray_orig, prev_ray_dir, 0.0f,
nullptr,
nullptr, &fprev_ob_index);
3539 if (!fprev || fprev != fcurr) {
3613 const short orientation_type = scene_orientation ? scene_orientation :
3636 float3 cage_dir = constrain_dir * lambda;
3641 r_cage = kcd->
prev.
cage + cage_dir;
3653 const float3 *curr_cage_constrain,
3665 curr_cage_constrain,
3671 kcd->
curr = kpos_tmp;
3718 float2 mval_constrain = mval;
3727 bool is_constrained =
false;
3745 is_constrained =
true;
3749 is_constrained =
true;
3754 float3 curr_cage_constrain;
3755 if (is_constrained) {
3769 curr_cage_constrain = kcd->
curr.
cage;
3777 is_constrained ? &curr_cage_constrain :
nullptr,
3778 is_constrained ? &fallback :
nullptr);
3798 for (
int i = 0; i <
undo->splits; i++) {
3804 for (
int i = 0; i <
undo->cuts; i++) {
3837 if (!
v2->is_invalid && !
v2->is_splitting) {
3838 v2->is_invalid =
true;
3843 v2->is_invalid =
false;
3871 bool use_tri_indices)
3875 const Mesh &mesh_orig = *id_cast<const Mesh *>(ob->
data);
3876 const Mesh &mesh_eval = *id_cast<const Mesh *>(obedit_eval->
data);
3883 obinfo->
em = &em_eval;
3896 if (use_tri_indices) {
3899 for (
int i = 0; i < looptris.
size(); i++) {
3900 const std::array<BMLoop *, 3> <ri = looptris[i];
3939 const bool only_select,
3940 const bool cut_through,
3942 const int visible_measurements,
3943 const int angle_snapping,
3944 const float angle_snapping_increment,
3945 const bool is_interactive)
3949 bool use_tri_indices = !is_interactive;
3959 kcd->
objects = std::move(objects);
3964 for (
int ob_index = 0; ob_index < kcd->
objects.size(); ob_index++) {
3986#ifdef USE_NET_ISLAND_CONNECT
3989 kcd->
edgenet.edge_visit = MEM_new<Set<BMEdge *>>(__func__);
4005 kcd->
origedgemap = MEM_new<Map<BMEdge *, KnifeEdge *>>(
"knife origedgemap");
4006 kcd->
origvertmap = MEM_new<Map<BMVert *, KnifeVert *>>(
"knife origvertmap");
4007 kcd->
kedgefacemap = MEM_new<Map<BMFace *, ListBaseT<LinkData> *>>(
"knife kedgefacemap");
4008 kcd->
facetrimap = MEM_new<Map<BMFace *, int>>(
"knife facetrimap");
4013 if (is_interactive) {
4061#ifdef USE_NET_ISLAND_CONNECT
4064 MEM_delete(kcd->
edgenet.edge_visit);
4144 for (
int ob_index : kcd->
objects.index_range()) {
4182 "CYCLE_ANGLE_SNAP_EDGE",
4184 "Cycle Angle Snapping Relative Edge",
4188 "SHOW_DISTANCE_ANGLE_TOGGLE",
4190 "Toggle Distance and Angle Measurements",
4200 {0,
nullptr, 0,
nullptr,
nullptr},
4236 bool do_refresh =
false;
4253 bool handled =
false;
4254 float snapping_increment_temp;
4283 switch (event->
val) {
4293 const bool changed = (kcd->
totkvert != 0);
4486 switch (event->
type) {
4597 const int visible_measurements =
RNA_enum_get(op->
ptr,
"visible_measurements");
4600 const float angle_snapping_increment =
RAD2DEGF(
4615 visible_measurements,
4617 angle_snapping_increment,
4621 bool faces_selected =
false;
4625 faces_selected =
true;
4629 if (!faces_selected) {
4642 if (wait_for_input ==
false) {
4665 ot->
name =
"Knife Topology Tool";
4666 ot->
idname =
"MESH_OT_knife_tool";
4685 {0,
nullptr, 0,
nullptr,
nullptr},
4695 "Angle snapping relative to the previous cut edge"},
4696 {0,
nullptr, 0,
nullptr,
nullptr},
4700 "use_occlude_geometry",
4703 "Only cut the front most geometry");
4704 RNA_def_boolean(ot->
srna,
"only_selected",
false,
"Only Selected",
"Only cut selected geometry");
4708 "visible_measurements",
4709 visible_measurements_items,
4712 "Visible distance and angle measurements");
4717 angle_snapping_items,
4720 "Angle snapping mode");
4724 "angle_snapping_increment",
4728 "Angle Snap Increment",
4729 "The angle snap increment used when in constrained angle mode",
4770 const bool only_select =
false;
4771 const bool is_interactive =
false;
4772 const bool xray =
false;
4777 kcd = MEM_new<KnifeTool_OpData>(__func__);
4785 visible_measurements,
4787 angle_snapping_increment,
4802 for (
const float2 &mval : poly.as_span().drop_front(1)) {
4815 for (
int ob_index : kcd->
objects.index_range()) {
4836#define F_ISECT_IS_UNKNOWN(f) BM_elem_flag_test(BM_FACE_FIRST_LOOP(f), BM_ELEM_TAG)
4837#define F_ISECT_SET_UNKNOWN(f) BM_elem_flag_enable(BM_FACE_FIRST_LOOP(f), BM_ELEM_TAG)
4838#define F_ISECT_SET_OUTSIDE(f) BM_elem_flag_disable(BM_FACE_FIRST_LOOP(f), BM_ELEM_TAG)
4857 float cent[3], cent_ss[2];
4859 mul_m4_v3(ob->object_to_world().ptr(), cent);
4870 keep_search =
false;
4879 BMLoop *l_iter = l_first;
4886 if (l_radial_iter != l_iter) {
4891 }
while ((l_radial_iter = l_radial_iter->
radial_next) != l_iter &&
4895 }
while ((l_iter = l_iter->
next) != l_first && (found ==
false));
4898 float cent[3], cent_ss[2];
4900 mul_m4_v3(ob->object_to_world().ptr(), cent);
4915 }
while (keep_search);
4917#undef F_ISECT_IS_UNKNOWN
4918#undef F_ISECT_SET_UNKNOWN
4919#undef F_ISECT_SET_OUTSIDE
#define SNPRINTF_UTF8(dst, format,...)
#define BLI_STR_UTF8_DEGREE_SIGN
#define BLT_I18NCONTEXT_ID_MESH
Object is a sort of wrapper for general info.
#define RV3D_CLIPPING_ENABLED(v3d, rv3d)
#define OPERATOR_RETVAL_CHECK(ret)
#define REGION_DRAW_POST_VIEW
#define GPU_batch_uniform_1f(batch, name, x)
#define GPU_batch_uniform_4fv(batch, name, val)
Read Blender memory allocation and freeing.
#define UNUSED_FUNCTION(x)
#define INIT_MINMAX(min, max)
#define BLI_assert_unreachable()
#define UNUSED_VARS_NDEBUG(...)
#define BM_FACE_FIRST_LOOP(p)
#define BM_elem_index_get(ele)
#define BM_elem_flag_disable(ele, hflag)
#define BM_elem_flag_test(ele, hflag)
#define BM_elem_flag_enable(ele, hflag)
#define BM_ITER_ELEM(ele, iter, data, itype)
#define BM_ITER_MESH(ele, iter, bm, itype)
#define MEM_SIZE_OPTIMAL(size)
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
bool closest(btVector3 &v)
bool add(const Key &key, const Value &value)
const Value & lookup(const Key &key) const
Value lookup_default(const Key &key, const Value &default_value) const
ItemIterator items() const &
bool contains(const Key &key) const
bool remove(const Key &key)
constexpr int64_t size() const
constexpr bool is_empty() const
void append(const T &value)
void item(std::string text, int icon1, int icon2=0)
void opmodal(std::string text, const wmOperatorType *ot, int propvalue, bool inverted=false)
#define KNIFE_FLT_EPS_PX_VERT
#define KNIFE_FLT_EPS_PX_EDGE
#define F_ISECT_SET_UNKNOWN(f)
#define F_ISECT_SET_OUTSIDE(f)
#define KNIFE_MAX_ANGLE_SNAPPING_INCREMENT
#define KNIFE_DEFAULT_ANGLE_SNAPPING_INCREMENT
#define KNIFE_FLT_EPS_PX_FACE
#define KNIFE_MIN_ANGLE_SNAPPING_INCREMENT
#define KNIFE_FLT_EPS_SQUARED
#define F_ISECT_IS_UNKNOWN(f)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
bool isect_point_poly(const float2 &pt, Span< float2 > verts)
void get_color_type_3ubv(int colorid, int spacetype, unsigned char col[3])
void get_color_3ubv(int colorid, unsigned char col[3])
MINLINE float min_ff(float a, float b)
void EDBM_flag_disable_all(BMesh *bm, char hflag)
MINLINE void madd_v3_v3v3fl(float r[3], const float a[3], const float b[3], float f)
static bool coinciding_edges(BMEdge *e1, BMEdge *e2)
MINLINE float dot_m4_v3_row_z(const float M[4][4], const float a[3]) ATTR_WARN_UNUSED_RESULT
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
MINLINE float len_squared_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
MINLINE void negate_v3_v3(float r[3], const float a[3])
static KnifeEdge * get_bm_knife_edge(KnifeTool_OpData *kcd, BMEdge *e, int ob_index)
float angle_normalized_v3v3(const float v1[3], const float v2[3]) ATTR_WARN_UNUSED_RESULT
void BM_mesh_elem_index_ensure(BMesh *bm, const char htype)
float line_point_factor_v3(const float p[3], const float l1[3], const float l2[3])
void BM_mesh_elem_hflag_enable_all(BMesh *bm, const char htype, const char hflag, const bool respecthide)
void wmOrtho2_region_pixelspace(const ARegion *region)
MINLINE bool is_zero_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
BLI_INLINE bool BM_edge_is_wire(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
MINLINE void copy_v2_v2_int(int r[2], const int a[2])
MINLINE void rgba_uchar_to_float(float r_col[4], const unsigned char col_ub[4])
static int get_lowest_face_tri(KnifeTool_OpData *kcd, BMFace *f)
int RNA_enum_get(PointerRNA *ptr, const char *name)
static KnifeVert * knife_split_edge(KnifeTool_OpData *kcd, KnifeEdge *kfe, const float co[3], const float cageco[3], KnifeEdge **r_kfe)
gpu::Batch * GPU_batch_create_ex(GPUPrimType primitive_type, gpu::VertBuf *vertex_buf, gpu::IndexBuf *index_buf, GPUBatchFlag owns_flag)
static void prepare_linehits_for_cut(KnifeTool_OpData *kcd)
bool BM_edge_in_face(const BMEdge *e, const BMFace *f)
void rotate_normalized_v3_v3v3fl(float out[3], const float p[3], const float axis[3], float angle)
static wmOperatorStatus knifetool_invoke(bContext *C, wmOperator *op, const wmEvent *event)
void BLF_position(int fontid, float x, float y, float z)
static void knife_constrain_axis(const KnifeTool_OpData *kcd, const float3 &ray_orig, const float3 &ray_dir, float3 &r_cage)
void EDBM_selectmode_flush(BMesh *bm, short selectmode)
MemArena * BLI_memarena_new(size_t bufsize, const char *name) ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL ATTR_NONNULL(2) ATTR_MALLOC
@ KNF_MODAL_IGNORE_SNAP_OFF
@ KNF_MODAL_ADD_CUT_CLOSED
@ KNF_MODAL_CUT_THROUGH_TOGGLE
@ KNF_MODAL_IGNORE_SNAP_ON
@ KNF_MODAL_SHOW_DISTANCE_ANGLE_TOGGLE
@ KNF_MODAL_DEPTH_TEST_TOGGLE
@ KNF_MODAL_CYCLE_ANGLE_SNAP_EDGE
@ KNF_MODAL_ANGLE_SNAP_TOGGLE
static void knife_start_cut(KnifeTool_OpData *kcd, const float2 &mval)
static bool knife_snap_angle_impl(const KnifeTool_OpData *kcd, const float3 &vec_x, const float3 &axis, const float3 &ray_orig, const float3 &ray_dir, float3 &r_cage, float &r_angle)
wmKeyMap * WM_modalkeymap_find(wmKeyConfig *keyconf, const char *idname)
BMesh * BKE_editmesh_bmesh_get_for_write(Mesh *mesh)
int * BLI_bvhtree_intersect_plane(const BVHTree *tree, float plane[4], uint *r_intersect_num)
BLI_INLINE bool BM_loop_is_adjacent(const BMLoop *l_a, const BMLoop *l_b) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
bool BLI_stack_is_empty(const BLI_Stack *stack) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
MINLINE void copy_v3_v3(float r[3], const float a[3])
static bool knife_find_closest_edge_of_face(KnifeTool_OpData *kcd, int ob_index, BMFace *f, const float2 &curr_cage_ss, const float3 *curr_cage_constrain, const float3 &ray_orig, const float3 &ray_dir, KnifePosData *r_kpd)
bool handleNumInput(bContext *C, NumInput *n, const wmEvent *event)
static void knife_finish_cut(KnifeTool_OpData *kcd)
static bool knife_linehit_face_test(KnifeTool_OpData *kcd, float s1[2], float s2[2], float sco[2], float ray_start[3], float ray_end[3], int ob_index, BMFace *f, float face_tol_sq, KnifeLineHit *r_hit)
void minmax_v3v3_v3(float min[3], float max[3], const float vec[3])
void BLI_stack_free(BLI_Stack *stack) ATTR_NONNULL()
ATTR_WARN_UNUSED_RESULT const BMLoop * l
bool isect_ray_tri_watertight_v3(const float ray_origin[3], const struct IsectRayPrecalc *isect_precalc, const float v0[3], const float v1[3], const float v2[3], float *r_lambda, float r_uv[2])
static bool knife_add_single_cut__is_linehit_outside_face(BMFace *f, const KnifeLineHit *lh, const float co[3])
bool isect_ray_plane_v3(const float ray_origin[3], const float ray_direction[3], const float plane[4], float *r_lambda, bool clip)
static void knifetool_draw_orientation_locking(const KnifeTool_OpData *kcd)
static BMElem * bm_elem_from_knife_edge(KnifeEdge *kfe)
static void knife_make_cuts(KnifeTool_OpData *kcd, int ob_index)
static ListBaseT< LinkData > * knife_get_face_kedges(KnifeTool_OpData *kcd, int ob_index, BMFace *f)
static void knifetool_disable_angle_snapping(KnifeTool_OpData *kcd)
static void knife_recalc_ortho(KnifeTool_OpData *kcd)
void GPU_matrix_identity_set()
void mul_v3_m4v3(float r[3], const float mat[4][4], const float vec[3])
MINLINE void copy_v2_v2(float r[2], const float a[2])
bool isect_ray_line_v3(const float ray_origin[3], const float ray_direction[3], const float v0[3], const float v1[3], float *r_lambda)
GPUVertFormat * immVertexFormat()
void BLI_bvhtree_free(BVHTree *tree)
float angle_v3v3v3(const float a[3], const float b[3], const float c[3]) ATTR_WARN_UNUSED_RESULT
MINLINE float mul_project_m4_v3_zfac(const float mat[4][4], const float co[3]) ATTR_WARN_UNUSED_RESULT
void EDBM_update(Mesh *mesh, const EDBMUpdate_Params *params)
void BLI_stack_pop(BLI_Stack *stack, void *dst) ATTR_NONNULL()
static void knifetool_init(ViewContext *vc, KnifeTool_OpData *kcd, Vector< Object * > objects, const bool only_select, const bool cut_through, const bool xray, const int visible_measurements, const int angle_snapping, const float angle_snapping_increment, const bool is_interactive)
static int knife_update_active(KnifeTool_OpData *kcd, const float2 &mval)
void WM_cursor_modal_set(wmWindow *win, int val)
static bool point_is_visible(KnifeTool_OpData *kcd, const float p[3], const float s[2], BMElem *ele_test)
@ OP_IS_MODAL_CURSOR_REGION
static void knifetool_finish(wmOperator *op)
void immBegin(GPUPrimType, uint vertex_len)
static void knife_find_line_hits(KnifeTool_OpData *kcd)
int isect_seg_seg_v2_point_ex(const float v0[2], const float v1[2], const float v2[2], const float v3[2], float endpoint_bias, float r_vi[2])
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, const int default_value, const char *ui_name, const char *ui_description)
void BLI_bvhtree_balance(BVHTree *tree)
static LinkData * find_ref(ListBaseT< LinkData > *lb, void *ref)
BMLoop * BM_face_edge_share_loop(BMFace *f, BMEdge *e)
Return the Loop Shared by Face and Edge.
void axis_angle_to_quat(float r[4], const float axis[3], float angle)
int BKE_scene_orientation_get_index(Scene *scene, int slot_index)
static bool knife_find_closest_face(KnifeTool_OpData *kcd, const float2 &mval, const float3 &ray_orig, const float3 &ray_dir, KnifePosData *r_kpd)
bool hasNumInput(const NumInput *n)
static void knifetool_finish_single_pre(KnifeTool_OpData *kcd, int ob_index)
void GPU_batch_discard(gpu::Batch *batch)
@ KNF_CONSTRAIN_AXIS_NONE
wmWindow * CTX_wm_window(const bContext *C)
void MESH_OT_knife_tool(wmOperatorType *ot)
static void knife_add_cut(KnifeTool_OpData *kcd)
@ KNF_CONSTRAIN_AXIS_MODE_GLOBAL
@ KNF_CONSTRAIN_AXIS_MODE_NONE
@ KNF_CONSTRAIN_AXIS_MODE_LOCAL
void project_plane_normalized_v3_v3v3(float out[3], const float p[3], const float v_plane[3])
ATTR_WARN_UNUSED_RESULT const BMVert * v
static bool knife_snap_angle_relative(KnifeTool_OpData *kcd, const float3 &ray_orig, const float3 &ray_dir, float3 &r_cage, float &r_angle)
void immUniformColor4fv(const float rgba[4])
BMVert * BM_vert_create(BMesh *bm, const float co[3], const BMVert *v_example, const eBMCreateFlag create_flag)
Main function for creating a new vertex.
gpu::Batch * immBeginBatchAtMost(GPUPrimType, uint vertex_len)
static void knifetool_undo(KnifeTool_OpData *kcd)
float normal_tri_v3(float n[3], const float v1[3], const float v2[3], const float v3[3])
static bool knife_bm_face_is_select(BMFace *f)
void BLI_stack_discard(BLI_Stack *stack) ATTR_NONNULL()
int BLI_bvhtree_ray_cast(const BVHTree *tree, const float co[3], const float dir[3], float radius, BVHTreeRayHit *hit, BVHTree_RayCastCallback callback, void *userdata)
void ED_region_tag_redraw(ARegion *region)
void * BLI_stack_push_r(BLI_Stack *stack) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void BLF_disable(int fontid, FontFlags flag)
void plane_from_point_normal_v3(float r_plane[4], const float plane_co[3], const float plane_no[3])
static void knifetool_draw(const bContext *, ARegion *, void *arg)
static void knife_init_colors(KnifeColors *colors)
float angle_signed_on_axis_v3v3_v3(const float v1[3], const float v2[3], const float axis[3]) ATTR_WARN_UNUSED_RESULT
static BMFace * knife_find_common_face(ListBaseT< LinkData > *faces1, ListBaseT< LinkData > *faces2)
void GPU_batch_draw_range(gpu::Batch *batch, int vertex_first, int vertex_count)
void immUniformColor3ubv(const unsigned char rgb[3])
void GPU_line_width(float width)
static void knife_snap_curr(KnifeTool_OpData *kcd, const float2 &mval, const float3 &ray_orig, const float3 &ray_dir, const float3 *curr_cage_constrain, const float3 *fallback)
static bool knife_bm_face_is_not_hidden(BMFace *f)
bool ED_view3d_unproject_v3(const ARegion *region, float regionx, float regiony, float regionz, float world[3])
static void knife_input_ray_segment(const KnifeTool_OpData *kcd, const float mval[2], float r_origin[3], float r_end[3])
static void calc_ortho_extent(KnifeTool_OpData *kcd)
static KnifeEdge * new_knife_edge(KnifeTool_OpData *kcd)
@ KNF_MEASUREMENT_DISTANCE
bool BM_face_point_inside_test(const BMFace *f, const float co[3])
float dist_squared_to_line_segment_v2(const float p[2], const float l1[2], const float l2[2])
static void knifetool_draw_visible_angles(const KnifeTool_OpData *kcd)
MINLINE void sub_v3_v3(float r[3], const float a[3])
VecBase< float, 4 > float4
void mul_qt_v3(const float q[4], float r[3])
void immBindBuiltinProgram(GPUBuiltinShader shader_id)
static ListBaseT< LinkData > * knife_empty_list(KnifeTool_OpData *kcd)
wmKeyMap * knifetool_modal_keymap(wmKeyConfig *keyconf)
void mul_m4_v3(const float M[4][4], float r[3])
MINLINE bool equals_v3v3(const float v1[3], const float v2[3]) ATTR_WARN_UNUSED_RESULT
static void knife_project_v2(const KnifeTool_OpData *kcd, const float co[3], float sco[2])
static void knife_append_list_no_dup(KnifeTool_OpData *kcd, ListBaseT< LinkData > *lst, void *elem)
static void knifetool_draw_dist_angle(const KnifeTool_OpData *kcd)
void BLI_mempool_destroy(BLI_mempool *pool) ATTR_NONNULL(1)
static void knifetool_draw_visible_distances(const KnifeTool_OpData *kcd)
static float knife_snap_size(KnifeTool_OpData *kcd, float maxsize)
void BLF_size(int fontid, float size)
void * ED_region_draw_cb_activate(ARegionType *art, void(*draw)(const bContext *, ARegion *, void *), void *customdata, int type)
void EDBM_mesh_knife(ViewContext *vc, const Span< Object * > objects, const Span< Array< float2 > > polys, bool use_tag, bool cut_through)
VecBase< float, 2 > float2
void immUniform1f(const char *name, float x)
void transform_point_by_seg_v3(float p_dst[3], const float p_src[3], const float l_dst_p1[3], const float l_dst_p2[3], const float l_src_p1[3], const float l_src_p2[3])
void interp_v3_v3v3v3_uv(float p[3], const float v1[3], const float v2[3], const float v3[3], const float uv[2])
void void void BLI_listbase_sort_r(ListBase *listbase, int(*cmp)(void *, const void *, const void *), void *thunk) ATTR_NONNULL(1
static void linehit_to_knifepos(KnifePosData *kpos, KnifeLineHit *lh)
static KnifeVert * get_bm_knife_vert(KnifeTool_OpData *kcd, BMVert *v, int ob_index)
MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3])
bool ED_region_draw_cb_exit(ARegionType *art, void *handle)
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
void BM_edge_kill(BMesh *bm, BMEdge *e)
static void knifetool_disable_orientation_locking(KnifeTool_OpData *kcd)
void BKE_report(ReportList *reports, eReportType type, const char *message)
BMesh const char void * data
void BLF_color3ubv(int fontid, const unsigned char rgb[3])
void GPU_vertbuf_attr_set(gpu::VertBuf *, uint a_idx, uint v_idx, const void *data)
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
static void knife_reset_snap_angle_input(KnifeTool_OpData *kcd)
@ GPU_SHADER_3D_UNIFORM_COLOR
@ GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA
void initNumInput(NumInput *n)
BLI_mempool * BLI_mempool_create(unsigned int esize, unsigned int elem_num, unsigned int pchunk, unsigned int flag) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL
void BLI_memarena_clear(MemArena *ma) ATTR_NONNULL(1)
static bool knife_closest_constrain_to_edge(const float3 &cut_origin, const float3 &cut_dir, const float3 &kfv1_cageco, const float3 &kfv2_cageco, float r_close[3])
void immUniformThemeColor3(int color_id)
eV3DProjStatus ED_view3d_project_float_global(const ARegion *region, const float co[3], float r_co[2], eV3DProjTest flag)
static void knife_bvh_init(KnifeTool_OpData *kcd)
BVHTree * BLI_bvhtree_new(int maxsize, float epsilon, char tree_type, char axis)
static bool edbm_mesh_knife_point_isect(const Span< Array< float2 > > polys, const float2 cent_ss)
static void clip_to_ortho_planes(float v1[3], float v2[3], const float center[3], const float d)
void RNA_def_property_subtype(PropertyRNA *prop, PropertySubType subtype)
void WM_cursor_modal_restore(wmWindow *win)
bool BM_vert_in_face(BMVert *v, BMFace *f)
static bool knife_ray_intersect_face(KnifeTool_OpData *kcd, const float s[2], const float v1[3], const float v2[3], int ob_index, BMFace *f, const float face_tol_sq, float hit_co[3], float hit_cageco[3])
static void knife_bm_tri_cagecos_get(const KnifeTool_OpData *kcd, int ob_index, int tri_index, float cos[3][3])
void GPU_batch_draw(gpu::Batch *batch)
static BMFace * knife_bvh_raycast_filter(KnifeTool_OpData *kcd, const float co[3], const float dir[3], const float radius, float *r_dist, float r_cagehit[3], int *r_ob_index, bool(*filter_cb)(BMFace *f, void *userdata), void *filter_userdata)
void BLI_mempool_iternew(BLI_mempool *pool, BLI_mempool_iter *iter) ATTR_NONNULL()
void GPU_program_point_size(bool enable)
BLI_INLINE bool BM_edge_is_boundary(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void interp_v3_v3v3(float r[3], const float a[3], const float b[3], float t)
void * BLI_mempool_iterstep(BLI_mempool_iter *iter) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Array< float3 > BM_mesh_vert_coords_alloc(const BMesh *bm)
static void knifetool_cancel(bContext *, wmOperator *op)
size_t BKE_unit_value_as_string(char *str, int str_maxncpy, double value, int prec, int type, const UnitSettings &settings, bool pad, bool do_unit_suffix)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
static void knife_add_single_cut(KnifeTool_OpData *kcd, KnifeLineHit *lh1, KnifeLineHit *lh2, BMFace *f)
void * BLI_stack_peek(BLI_Stack *stack) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
static void knifetool_draw_angle(const KnifeTool_OpData *kcd, const float start[3], const float mid[3], const float end[3], const float start_ss[2], const float mid_ss[2], const float end_ss[2], const float angle)
static void knife_pos_data_clear(KnifePosData *kpd)
bool BKE_editmesh_eval_orig_map_available(const Mesh &mesh_eval, const Mesh *mesh_orig)
void ED_view3d_init_mats_rv3d(const Object *ob, RegionView3D *rv3d)
bool isect_ray_tri_v3(const float ray_origin[3], const float ray_direction[3], const float v0[3], const float v1[3], const float v2[3], float *r_lambda, float r_uv[2])
size_t BKE_unit_value_as_string_scaled(char *str, int str_maxncpy, double value, int prec, int type, const UnitSettings &settings, bool pad, bool do_unit_suffix)
MINLINE void zero_v3(float r[3])
void BLF_draw(int fontid, const char *str, size_t str_len, ResultBLF *r_info=nullptr) ATTR_NONNULL(2)
uint GPU_vertformat_attr_add(GPUVertFormat *format, StringRef name, gpu::VertAttrType type)
int BLI_listbase_count_at_most(const ListBase *listbase, int count_max) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
bool isect_ray_ray_v3(const float ray_origin_a[3], const float ray_direction_a[3], const float ray_origin_b[3], const float ray_direction_b[3], float *r_lambda_a, float *r_lambda_b)
void GPU_batch_program_set_builtin(gpu::Batch *batch, GPUBuiltinShader shader_id)
void BM_face_calc_point_in_face(const BMFace *f, float r_co[3])
bool isect_line_plane_v3(float r_isect_co[3], const float l1[3], const float l2[3], const float plane_co[3], const float plane_no[3]) ATTR_WARN_UNUSED_RESULT
BMFace * EDBM_face_find_nearest(ViewContext *vc, float *dist_px_manhattan_p)
bool applyNumInput(NumInput *n, float *vec)
bool BKE_object_is_visible_in_viewport(const View3D *v3d, const Object *ob)
static void knife_make_face_cuts(KnifeTool_OpData *kcd, BMesh *bm, BMFace *f, ListBaseT< LinkData > *kfedges)
bool ED_view3d_clip_range_get(const Depsgraph *depsgraph, const View3D *v3d, const RegionView3D *rv3d, bool use_ortho_factor, float *r_clip_start, float *r_clip_end)
static bool knife_find_closest_vert_of_edge(KnifeTool_OpData *kcd, const KnifeEdge *kfe, const float2 &cage_ss, KnifePosData *r_kpd)
MINLINE float normalize_v3_v3(float r[3], const float a[3])
static void knifetool_finish_ex(KnifeTool_OpData *kcd)
static void knifetool_update_mval(KnifeTool_OpData *kcd, const float2 &mval)
void RNA_def_property_translation_context(PropertyRNA *prop, const char *context)
BMEditMesh * BKE_editmesh_from_object(Object *ob)
Return the BMEditMesh for a given object.
void * BLI_memarena_alloc(MemArena *ma, size_t size) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC ATTR_ALLOC_SIZE(2)
BMEdge * BM_edge_exists(BMVert *v_a, BMVert *v_b)
MINLINE float normalize_v3(float n[3])
static bool knife_snap_angle_screen(const KnifeTool_OpData *kcd, const float3 &ray_orig, const float3 &ray_dir, float3 &r_cage, float &r_angle)
MINLINE void add_v3_v3(float r[3], const float a[3])
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
void immVertex3fv(uint attr_id, const float data[3])
ViewContext em_setup_viewcontext(bContext *C)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
static void knife_edge_append_face(KnifeTool_OpData *kcd, KnifeEdge *kfe, BMFace *f)
void mid_v3_v3v3(float r[3], const float a[3], const float b[3])
static bool bm_ray_cast_cb_elem_not_in_face_check(BMFace *f, void *user_data)
MINLINE bool compare_v3v3(const float v1[3], const float v2[3], float limit) ATTR_WARN_UNUSED_RESULT
BMVert * BM_edge_split(BMesh *bm, BMEdge *e, BMVert *v, BMEdge **r_e, float fac)
Edge Split.
bool ED_view3d_clipping_test(const RegionView3D *rv3d, const float co[3], bool is_local)
float closest_ray_to_segment_v3(const float ray_origin[3], const float ray_direction[3], const float v0[3], const float v1[3], float r_close[3])
float dist_squared_to_plane_v3(const float p[3], const float plane[4])
static void knife_add_edge_faces_to_vert(KnifeTool_OpData *kcd, KnifeVert *kfv, BMEdge *e)
static void UNUSED_FUNCTION knifetool_recast_cageco(KnifeTool_OpData *kcd, float mval[3], float r_cage[3])
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
static int linehit_compare(const KnifeLineHit &lh1, const KnifeLineHit &lh2)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
void GPU_matrix_pop_projection()
static void knife_join_edge(KnifeEdge *newkfe, KnifeEdge *kfe)
float ED_view3d_pixel_size_no_ui_scale(const RegionView3D *rv3d, const float co[3])
bool ED_view3d_win_to_segment_clipped(const Depsgraph *depsgraph, const ARegion *region, const View3D *v3d, const float mval[2], float r_ray_start[3], float r_ray_end[3], bool do_clip_planes)
bool ED_view3d_win_to_ray_clipped(Depsgraph *depsgraph, const ARegion *region, const View3D *v3d, const float mval[2], float r_ray_start[3], float r_ray_normal[3], bool do_clip_planes)
static void knife_draw_line(const KnifeTool_OpData *kcd, const uchar color[3])
static void knife_bvh_raycast_cb(void *userdata, int index, const BVHTreeRay *ray, BVHTreeRayHit *hit)
MINLINE float len_v2v2(const float v1[2], const float v2[2]) ATTR_WARN_UNUSED_RESULT
static BMFace * knife_bvh_raycast(KnifeTool_OpData *kcd, const float co[3], const float dir[3], const float radius, float *r_dist, float r_cagehit[3], int *r_ob_index)
Array< float3 > BKE_editmesh_vert_coords_alloc(Depsgraph *depsgraph, const BMesh *bm, Scene *scene, Object *ob)
void GPU_vertbuf_data_alloc(gpu::VertBuf &verts, uint v_len)
static void add_hit_to_facehits(KnifeTool_OpData *kcd, Map< BMFace *, ListBaseT< LinkData > * > &facehits, BMFace *f, KnifeLineHit *hit)
static wmOperatorStatus knifetool_modal(bContext *C, wmOperator *op, const wmEvent *event)
void mid_v2_v2v2(float r[2], const float a[2], const float b[2])
void * BLI_mempool_calloc(BLI_mempool *pool) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL ATTR_NONNULL(1)
bool BM_face_split_edgenet_connect_islands(BMesh *bm, BMFace *f, BMEdge **edge_net_init, const uint edge_net_init_len, bool use_partial_connect, MemArena *mem_arena, BMEdge ***r_edge_net_new, uint *r_edge_net_new_len)
Vector< Object * > BKE_view_layer_array_from_objects_in_edit_mode_unique_data(const Main &bmain, const Scene *scene, ViewLayer *view_layer, const View3D *v3d)
void BLI_bvhtree_insert(BVHTree *tree, int index, const float co[3], int numpoints)
static int sort_verts_by_dist_cb(void *co_p, const void *cur_a_p, const void *cur_b_p)
bool BM_face_split_edgenet(BMesh *bm, BMFace *f, BMEdge **edge_net, const int edge_net_len, Vector< BMFace * > *r_face_arr)
static KnifeVert * new_knife_vert(KnifeTool_OpData *kcd, const float co[3], const float cageco[3])
const BMesh * BKE_editmesh_bmesh_get(const Object *ob)
void WM_modalkeymap_assign(wmKeyMap *km, const char *opname)
void BLI_stack_push(BLI_Stack *stack, const void *src) ATTR_NONNULL()
bool EDBM_uvselect_clear(BMesh *bm)
static void knife_linehit_set(KnifeTool_OpData *kcd, float s1[2], float s2[2], float sco[2], float cage[3], int ob_index, KnifeVert *v, KnifeEdge *kfe, KnifeLineHit *r_hit)
BMLoop * BM_face_vert_share_loop(BMFace *f, BMVert *v)
Return the Loop Shared by Face and Vertex.
static float knife_snap_v3_angle(float3 &r, const float3 &dvec, const float3 &vecx, const float3 &axis, float angle_snap)
bool ED_operator_editmesh_view3d(bContext *C)
bool isect_ray_tri_epsilon_v3(const float ray_origin[3], const float ray_direction[3], const float v0[3], const float v1[3], const float v2[3], float *r_lambda, float r_uv[2], float epsilon)
static int knife_sample_screen_density_from_closest_face(KnifeTool_OpData *kcd, const float radius, int ob_index, BMFace *f, const float cageco[3])
wmKeyMap * WM_modalkeymap_ensure(wmKeyConfig *keyconf, const char *idname, const EnumPropertyItem *items)
static void knife_cut_face(KnifeTool_OpData *kcd, BMFace *f, ListBaseT< LinkData > *hits)
void GPU_blend(GPUBlend blend)
void GPU_polygon_offset(float viewdist, float dist)
static int knife_calculate_snap_ref_edges(KnifeTool_OpData *kcd, const float3 &ray_orig, const float3 &ray_dir)
float BM_loop_point_side_of_edge_test(const BMLoop *l, const float co[3])
int BLI_mempool_len(const BLI_mempool *pool) ATTR_NONNULL(1)
VecBase< float, 3 > float3
static void knife_append_list(KnifeTool_OpData *kcd, ListBaseT< LinkData > *lst, void *elem)
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
MINLINE float len_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
std::optional< std::string > WM_modalkeymap_operator_items_to_string(wmOperatorType *ot, const int propvalue, const bool compact)
MINLINE float len_squared_v2v2(const float a[2], const float b[2]) ATTR_WARN_UNUSED_RESULT
bool clip_segment_v3_plane_n(const float p1[3], const float p2[3], const float plane_array[][4], int plane_num, float r_p1[3], float r_p2[3])
void BLF_width_and_height(int fontid, const char *str, size_t str_len, float *r_width, float *r_height) ATTR_NONNULL()
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])
void BLF_rotation(int fontid, float angle)
void GPU_matrix_push_projection()
BLI_Stack * BLI_stack_new(size_t elem_size, const char *description) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
static void knifetool_finish_single_post(KnifeTool_OpData *, Object *ob)
float closest_to_line_segment_v2(float r_close[2], const float p[2], const float l1[2], const float l2[2])
static void knifetool_exit_ex(KnifeTool_OpData *kcd)
void GPU_depth_test(GPUDepthTest test)
static void knifetool_init_obinfo(KnifeTool_OpData *kcd, Object *ob, int ob_index, bool use_tri_indices)
PropertyRNA * RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, const float default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
void immRectf(uint pos, float x1, float y1, float x2, float y2)
MINLINE void zero_v2(float r[2])
void ED_workspace_status_text(bContext *C, const char *str)
static void knife_update_header(bContext *C, wmOperator *op, KnifeTool_OpData *kcd)
static void knife_add_to_vert_edges(KnifeTool_OpData *kcd, KnifeEdge *kfe)
BMEdge * BM_edge_create(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *e_example, const eBMCreateFlag create_flag)
Main function for creating a new edge.
float RNA_float_get(PointerRNA *ptr, const char *name)
static void knife_bm_tri_cagecos_get_worldspace(const KnifeTool_OpData *kcd, int ob_index, int tri_index, float cos[3][3])
static void knifetool_draw_angle_snapping(const KnifeTool_OpData *kcd)
void BLF_enable(int fontid, FontFlags flag)
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
static void knife_bvh_free(KnifeTool_OpData *kcd)
static BMElem * bm_elem_from_knife_vert(KnifeVert *kfv, KnifeEdge **r_kfe)
void BLI_memarena_free(MemArena *ma) ATTR_NONNULL(1)
static bool knife_verts_edge_in_face(KnifeVert *v1, KnifeVert *v2, BMFace *f)
static const int * knife_bm_tri_index_get(const KnifeTool_OpData *kcd, int ob_index, int tri_index, int tri_index_buf[3])
static void knife_snap_update_from_mval(KnifeTool_OpData *kcd, const float2 &mval)
static void knifetool_exit(wmOperator *op)
@ KNF_CONSTRAIN_ANGLE_MODE_NONE
@ KNF_CONSTRAIN_ANGLE_MODE_RELATIVE
@ KNF_CONSTRAIN_ANGLE_MODE_SCREEN
void mul_transposed_mat3_m4_v3(const float M[4][4], float r[3])
float BM_loop_point_side_of_loop_test(const BMLoop *l, const float co[3])
static void set_lowest_face_tri(KnifeTool_OpData *kcd, BMEditMesh *em, BMFace *f, int index)
void BM_edge_select_set(BMesh *bm, BMEdge *e, const bool select)
Select Edge.
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
bke::ARegionRuntime * runtime
Array< std::array< BMLoop *, 3 > > looptris
struct BMLoop * radial_next
struct IsectRayPrecalc * isect_precalc
bool(*) filter_cb(BMFace *f, void *userdata)
Span< std::array< BMLoop *, 3 > > looptris
ListBaseT< LinkData > faces
Array< float3 > positions_cage
Array< int3 > tri_indices
ListBaseT< LinkData > edges
ListBaseT< LinkData > faces
bke::MeshRuntime * runtime
eRegionView3D_Persp persp
struct ToolSettings * toolsettings
struct ARegionType * type
std::shared_ptr< BMEditMesh > edit_mesh
void(*) cancel(bContext *C, wmOperator *op)
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
struct ReportList * reports
struct wmOperatorType * type