blender-archive/source/blender/editors/mesh/editmesh_knife.c

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2007 Blender Foundation.
 * All rights reserved.
 */

/** \file
 * \ingroup edmesh
 *
 * Interactive editmesh knife tool.
 */

#ifdef _MSC_VER
#  define _USE_MATH_DEFINES
#endif

#include "MEM_guardedalloc.h"

#include "BLI_listbase.h"
#include "BLI_string.h"
#include "BLI_array.h"
#include "BLI_alloca.h"
#include "BLI_linklist.h"
#include "BLI_math.h"
#include "BLI_smallhash.h"
#include "BLI_memarena.h"

#include "BLT_translation.h"

#include "BKE_bvhutils.h"
#include "BKE_context.h"
#include "BKE_editmesh.h"
#include "BKE_editmesh_bvh.h"
#include "BKE_report.h"

#include "GPU_immediate.h"
#include "GPU_matrix.h"
#include "GPU_state.h"

#include "ED_screen.h"
#include "ED_space_api.h"
#include "ED_view3d.h"
#include "ED_mesh.h"

#include "WM_api.h"
#include "WM_types.h"

#include "DNA_object_types.h"

#include "UI_interface.h"
#include "UI_resources.h"

#include "RNA_access.h"
#include "RNA_define.h"

#include "DEG_depsgraph.h"
#include "DEG_depsgraph_query.h"

#include "mesh_intern.h" /* own include */

/* detect isolated holes and fill them */
#define USE_NET_ISLAND_CONNECT

#define KMAXDIST 10 /* max mouse distance from edge before not detecting it */

/* WARNING: knife float precision is fragile:
 * be careful before making changes here see: (T43229, T42864, T42459, T41164).
 */
#define KNIFE_FLT_EPS 0.00001f
#define KNIFE_FLT_EPS_SQUARED (KNIFE_FLT_EPS * KNIFE_FLT_EPS)
#define KNIFE_FLT_EPSBIG 0.0005f

#define KNIFE_FLT_EPS_PX_VERT 0.5f
#define KNIFE_FLT_EPS_PX_EDGE 0.05f
#define KNIFE_FLT_EPS_PX_FACE 0.05f

typedef struct KnifeColors {
  uchar line[3];
  uchar edge[3];
  uchar curpoint[3];
  uchar curpoint_a[4];
  uchar point[3];
  uchar point_a[4];
} KnifeColors;

/* knifetool operator */
typedef struct KnifeVert {
  BMVert *v; /* non-NULL if this is an original vert */
  ListBase edges;
  ListBase faces;

  float co[3], cageco[3], sco[2]; /* sco is screen coordinates for cageco */
  bool is_face, in_space;
  bool is_cut; /* along a cut created by user input (will draw too) */
} KnifeVert;

typedef struct Ref {
  struct Ref *next, *prev;
  void *ref;
} Ref;

typedef struct KnifeEdge {
  KnifeVert *v1, *v2;
  BMFace *basef; /* face to restrict face fill to */
  ListBase faces;

  BMEdge *e /* , *e_old */; /* non-NULL if this is an original edge */
  bool is_cut;              /* along a cut created by user input (will draw too) */
} KnifeEdge;

typedef struct KnifeLineHit {
  float hit[3], cagehit[3];
  float schit[2]; /* screen coordinates for cagehit */
  float l;        /* lambda along cut line */
  float perc;     /* lambda along hit line */
  float m;        /* depth front-to-back */

  /* Exactly one of kfe, v, or f should be non-NULL,
   * saying whether cut line crosses and edge,
   * is snapped to a vert, or is in the middle of some face. */
  KnifeEdge *kfe;
  KnifeVert *v;
  BMFace *f;
} KnifeLineHit;

typedef struct KnifePosData {
  float co[3];
  float cage[3];

  /* At most one of vert, edge, or bmface should be non-NULL,
   * saying whether the point is snapped to a vertex, edge, or in a face.
   * If none are set, this point is in space and is_space should be true. */
  KnifeVert *vert;
  KnifeEdge *edge;
  BMFace *bmface;
  bool is_space;

  float mval[2]; /* mouse screen position (may be non-integral if snapped to something) */
} KnifePosData;

/* struct for properties used while drawing */
typedef struct KnifeTool_OpData {
  ARegion *ar;       /* region that knifetool was activated in */
  void *draw_handle; /* for drawing preview loop */
  ViewContext vc;    /* note: _don't_ use 'mval', instead use the one we define below */
  float mval[2];     /* mouse value with snapping applied */
  //bContext *C;

  Scene *scene;
  Object *ob;
  BMEditMesh *em;

  MemArena *arena;

  /* reused for edge-net filling */
  struct {
    /* cleared each use */
    GSet *edge_visit;
#ifdef USE_NET_ISLAND_CONNECT
    MemArena *arena;
#endif
  } edgenet;

  GHash *origvertmap;
  GHash *origedgemap;
  GHash *kedgefacemap;
  GHash *facetrimap;

  BMBVHTree *bmbvh;

  BLI_mempool *kverts;
  BLI_mempool *kedges;

  float vthresh;
  float ethresh;

  /* used for drag-cutting */
  KnifeLineHit *linehits;
  int totlinehit;

  /* Data for mouse-position-derived data */
  KnifePosData curr; /* current point under the cursor */
  KnifePosData prev; /* last added cut (a line draws from the cursor to this) */
  KnifePosData init; /* the first point in the cut-list, used for closing the loop */

  int totkedge, totkvert;

  BLI_mempool *refs;

  float projmat[4][4];
  float projmat_inv[4][4];
  /* vector along view z axis (object space, normalized) */
  float proj_zaxis[3];

  KnifeColors colors;

  /* run by the UI or not */
  bool is_interactive;

  /* operatpr options */
  bool cut_through;   /* preference, can be modified at runtime (that feature may go) */
  bool only_select;   /* set on initialization */
  bool select_result; /* set on initialization */

  bool is_ortho;
  float ortho_extent;
  float ortho_extent_center[3];

  float clipsta, clipend;

  enum { MODE_IDLE, MODE_DRAGGING, MODE_CONNECT, MODE_PANNING } mode;
  bool is_drag_hold;

  int prevmode;
  bool snap_midpoints;
  bool ignore_edge_snapping;
  bool ignore_vert_snapping;

  /* use to check if we're currently dragging an angle snapped line */
  bool is_angle_snapping;
  bool angle_snapping;
  float angle;

  const float (*cagecos)[3];
} KnifeTool_OpData;

enum {
  KNF_MODAL_CANCEL = 1,
  KNF_MODAL_CONFIRM,
  KNF_MODAL_MIDPOINT_ON,
  KNF_MODAL_MIDPOINT_OFF,
  KNF_MODAL_NEW_CUT,
  KNF_MODEL_IGNORE_SNAP_ON,
  KNF_MODEL_IGNORE_SNAP_OFF,
  KNF_MODAL_ADD_CUT,
  KNF_MODAL_ANGLE_SNAP_TOGGLE,
  KNF_MODAL_CUT_THROUGH_TOGGLE,
  KNF_MODAL_PANNING,
  KNF_MODAL_ADD_CUT_CLOSED,
};

static ListBase *knife_get_face_kedges(KnifeTool_OpData *kcd, BMFace *f);

static void knife_input_ray_segment(KnifeTool_OpData *kcd,
                                    const float mval[2],
                                    const float ofs,
                                    float r_origin[3],
                                    float r_dest[3]);

static bool knife_verts_edge_in_face(KnifeVert *v1, KnifeVert *v2, BMFace *f);

static void knifetool_free_bmbvh(KnifeTool_OpData *kcd);

static int knifetool_modal(bContext *C, wmOperator *op, const wmEvent *event);

static void knife_update_header(bContext *C, wmOperator *op, KnifeTool_OpData *kcd)
{
  char header[UI_MAX_DRAW_STR];
  char buf[UI_MAX_DRAW_STR];

  char *p = buf;
  int available_len = sizeof(buf);

#define WM_MODALKEY(_id) \
  WM_modalkeymap_operator_items_to_string_buf( \
      op->type, (_id), true, UI_MAX_SHORTCUT_STR, &available_len, &p)

  BLI_snprintf(header,
               sizeof(header),
               IFACE_("%s: confirm, %s: cancel, "
                      "%s: start/define cut, %s: close cut, %s: new cut, "
                      "%s: midpoint snap (%s), %s: ignore snap (%s), "
                      "%s: angle constraint (%s), %s: cut through (%s), "
                      "%s: panning"),
               WM_MODALKEY(KNF_MODAL_CONFIRM),
               WM_MODALKEY(KNF_MODAL_CANCEL),
               WM_MODALKEY(KNF_MODAL_ADD_CUT),
               WM_MODALKEY(KNF_MODAL_ADD_CUT_CLOSED),
               WM_MODALKEY(KNF_MODAL_NEW_CUT),
               WM_MODALKEY(KNF_MODAL_MIDPOINT_ON),
               WM_bool_as_string(kcd->snap_midpoints),
               WM_MODALKEY(KNF_MODEL_IGNORE_SNAP_ON),
               WM_bool_as_string(kcd->ignore_edge_snapping),
               WM_MODALKEY(KNF_MODAL_ANGLE_SNAP_TOGGLE),
               WM_bool_as_string(kcd->angle_snapping),
               WM_MODALKEY(KNF_MODAL_CUT_THROUGH_TOGGLE),
               WM_bool_as_string(kcd->cut_through),
               WM_MODALKEY(KNF_MODAL_PANNING));

#undef WM_MODALKEY

  ED_workspace_status_text(C, header);
}

static void knife_project_v2(const KnifeTool_OpData *kcd, const float co[3], float sco[2])
{
  ED_view3d_project_float_v2_m4(kcd->ar, co, sco, (float(*)[4])kcd->projmat);
}

/* use when lambda is in screen-space */
static void knife_interp_v3_v3v3(const KnifeTool_OpData *kcd,
                                 float r_co[3],
                                 const float v1[3],
                                 const float v2[3],
                                 float lambda_ss)
{
  if (kcd->is_ortho) {
    interp_v3_v3v3(r_co, v1, v2, lambda_ss);
  }
  else {
    /* transform into screen-space, interp, then transform back */
    float v1_ss[3], v2_ss[3];

    mul_v3_project_m4_v3(v1_ss, (float(*)[4])kcd->projmat, v1);
    mul_v3_project_m4_v3(v2_ss, (float(*)[4])kcd->projmat, v2);

    interp_v3_v3v3(r_co, v1_ss, v2_ss, lambda_ss);

    mul_project_m4_v3((float(*)[4])kcd->projmat_inv, r_co);
  }
}

static void knife_pos_data_clear(KnifePosData *kpd)
{
  zero_v3(kpd->co);
  zero_v3(kpd->cage);
  kpd->vert = NULL;
  kpd->edge = NULL;
  kpd->bmface = NULL;
  zero_v2(kpd->mval);
}

static ListBase *knife_empty_list(KnifeTool_OpData *kcd)
{
  ListBase *lst;

  lst = BLI_memarena_alloc(kcd->arena, sizeof(ListBase));
  BLI_listbase_clear(lst);
  return lst;
}

static void knife_append_list(KnifeTool_OpData *kcd, ListBase *lst, void *elem)
{
  Ref *ref;

  ref = BLI_mempool_calloc(kcd->refs);
  ref->ref = elem;
  BLI_addtail(lst, ref);
}

static Ref *find_ref(ListBase *lb, void *ref)
{
  Ref *ref1;

  for (ref1 = lb->first; ref1; ref1 = ref1->next) {
    if (ref1->ref == ref) {
      return ref1;
    }
  }

  return NULL;
}

static void knife_append_list_no_dup(KnifeTool_OpData *kcd, ListBase *lst, void *elem)
{
  if (!find_ref(lst, elem)) {
    knife_append_list(kcd, lst, elem);
  }
}

static KnifeEdge *new_knife_edge(KnifeTool_OpData *kcd)
{
  kcd->totkedge++;
  return BLI_mempool_calloc(kcd->kedges);
}

static void knife_add_to_vert_edges(KnifeTool_OpData *kcd, KnifeEdge *kfe)
{
  knife_append_list(kcd, &kfe->v1->edges, kfe);
  knife_append_list(kcd, &kfe->v2->edges, kfe);
}

/* Add faces of an edge to a KnifeVert's faces list.  No checks for dups. */
static void knife_add_edge_faces_to_vert(KnifeTool_OpData *kcd, KnifeVert *kfv, BMEdge *e)
{
  BMIter bmiter;
  BMFace *f;

  BM_ITER_ELEM (f, &bmiter, e, BM_FACES_OF_EDGE) {
    knife_append_list(kcd, &kfv->faces, f);
  }
}

/* Find a face in common in the two faces lists.
 * If more than one, return the first; if none, return NULL */
static BMFace *knife_find_common_face(ListBase *faces1, ListBase *faces2)
{
  Ref *ref1, *ref2;

  for (ref1 = faces1->first; ref1; ref1 = ref1->next) {
    for (ref2 = faces2->first; ref2; ref2 = ref2->next) {
      if (ref1->ref == ref2->ref) {
        return (BMFace *)(ref1->ref);
      }
    }
  }
  return NULL;
}

static KnifeVert *new_knife_vert(KnifeTool_OpData *kcd, const float co[3], const float cageco[3])
{
  KnifeVert *kfv = BLI_mempool_calloc(kcd->kverts);

  kcd->totkvert++;

  copy_v3_v3(kfv->co, co);
  copy_v3_v3(kfv->cageco, cageco);

  knife_project_v2(kcd, kfv->cageco, kfv->sco);

  return kfv;
}

/* get a KnifeVert wrapper for an existing BMVert */
static KnifeVert *get_bm_knife_vert(KnifeTool_OpData *kcd, BMVert *v)
{
  KnifeVert *kfv = BLI_ghash_lookup(kcd->origvertmap, v);
  const float *cageco;

  if (!kfv) {
    BMIter bmiter;
    BMFace *f;

    if (BM_elem_index_get(v) >= 0) {
      cageco = kcd->cagecos[BM_elem_index_get(v)];
    }
    else {
      cageco = v->co;
    }
    kfv = new_knife_vert(kcd, v->co, cageco);
    kfv->v = v;
    BLI_ghash_insert(kcd->origvertmap, v, kfv);
    BM_ITER_ELEM (f, &bmiter, v, BM_FACES_OF_VERT) {
      knife_append_list(kcd, &kfv->faces, f);
    }
  }

  return kfv;
}

/* get a KnifeEdge wrapper for an existing BMEdge */
static KnifeEdge *get_bm_knife_edge(KnifeTool_OpData *kcd, BMEdge *e)
{
  KnifeEdge *kfe = BLI_ghash_lookup(kcd->origedgemap, e);
  if (!kfe) {
    BMIter bmiter;
    BMFace *f;

    kfe = new_knife_edge(kcd);
    kfe->e = e;
    kfe->v1 = get_bm_knife_vert(kcd, e->v1);
    kfe->v2 = get_bm_knife_vert(kcd, e->v2);

    knife_add_to_vert_edges(kcd, kfe);

    BLI_ghash_insert(kcd->origedgemap, e, kfe);

    BM_ITER_ELEM (f, &bmiter, e, BM_FACES_OF_EDGE) {
      knife_append_list(kcd, &kfe->faces, f);
    }
  }

  return kfe;
}

/* Record the index in kcd->em->looptris of first looptri triple for a given face,
 * given an index for some triple in that array.
 * This assumes that all of the triangles for a given face are contiguous
 * in that array (as they are by the current tessellation routines).
 * Actually store index + 1 in the hash, because 0 looks like "no entry"
 * to hash lookup routine; will reverse this in the get routine.
 * Doing this lazily rather than all at once for all faces.
 */
static void set_lowest_face_tri(KnifeTool_OpData *kcd, BMFace *f, int index)
{
  int i;

  if (BLI_ghash_lookup(kcd->facetrimap, f)) {
    return;
  }

  BLI_assert(index >= 0 && index < kcd->em->tottri);
  BLI_assert(kcd->em->looptris[index][0]->f == f);
  for (i = index - 1; i >= 0; i--) {
    if (kcd->em->looptris[i][0]->f != f) {
      i++;
      break;
    }
  }
  if (i == -1) {
    i++;
  }

  BLI_ghash_insert(kcd->facetrimap, f, POINTER_FROM_INT(i + 1));
}

/* This should only be called for faces that have had a lowest face tri set by previous function */
static int get_lowest_face_tri(KnifeTool_OpData *kcd, BMFace *f)
{
  int ans;

  ans = POINTER_AS_INT(BLI_ghash_lookup(kcd->facetrimap, f));
  BLI_assert(ans != 0);
  return ans - 1;
}

/* User has just clicked for first time or first time after a restart (E key).
 * Copy the current position data into prev. */
static void knife_start_cut(KnifeTool_OpData *kcd)
{
  kcd->prev = kcd->curr;
  kcd->curr.is_space = 0; /*TODO: why do we do this? */

  if (kcd->prev.vert == NULL && kcd->prev.edge == NULL) {
    float origin[3], origin_ofs[3];
    float ofs_local[3];

    negate_v3_v3(ofs_local, kcd->vc.rv3d->ofs);
    invert_m4_m4(kcd->ob->imat, kcd->ob->obmat);
    mul_m4_v3(kcd->ob->imat, ofs_local);

    knife_input_ray_segment(kcd, kcd->curr.mval, 1.0f, origin, origin_ofs);

    if (!isect_line_plane_v3(kcd->prev.cage, origin, origin_ofs, ofs_local, kcd->proj_zaxis)) {
      zero_v3(kcd->prev.cage);
    }

    copy_v3_v3(kcd->prev.co, kcd->prev.cage); /*TODO: do we need this? */
    copy_v3_v3(kcd->curr.cage, kcd->prev.cage);
    copy_v3_v3(kcd->curr.co, kcd->prev.co);
  }
}

static ListBase *knife_get_face_kedges(KnifeTool_OpData *kcd, BMFace *f)
{
  ListBase *lst = BLI_ghash_lookup(kcd->kedgefacemap, f);

  if (!lst) {
    BMIter bmiter;
    BMEdge *e;

    lst = knife_empty_list(kcd);

    BM_ITER_ELEM (e, &bmiter, f, BM_EDGES_OF_FACE) {
      knife_append_list(kcd, lst, get_bm_knife_edge(kcd, e));
    }

    BLI_ghash_insert(kcd->kedgefacemap, f, lst);
  }

  return lst;
}

static void knife_edge_append_face(KnifeTool_OpData *kcd, KnifeEdge *kfe, BMFace *f)
{
  knife_append_list(kcd, knife_get_face_kedges(kcd, f), kfe);
  knife_append_list(kcd, &kfe->faces, f);
}

static KnifeVert *knife_split_edge(KnifeTool_OpData *kcd,
                                   KnifeEdge *kfe,
                                   const float co[3],
                                   const float cageco[3],
                                   KnifeEdge **r_kfe)
{
  KnifeEdge *newkfe = new_knife_edge(kcd);
  Ref *ref;
  BMFace *f;

  newkfe->v1 = kfe->v1;
  newkfe->v2 = new_knife_vert(kcd, co, cageco);
  newkfe->v2->is_cut = true;
  if (kfe->e) {
    knife_add_edge_faces_to_vert(kcd, newkfe->v2, kfe->e);
  }
  else {
    /* kfe cuts across an existing face.
     * If v1 and v2 are in multiple faces together (e.g., if they
     * are in doubled polys) then this arbitrarily chooses one of them */
    f = knife_find_common_face(&kfe->v1->faces, &kfe->v2->faces);
    if (f) {
      knife_append_list(kcd, &newkfe->v2->faces, f);
    }
  }
  newkfe->basef = kfe->basef;

  ref = find_ref(&kfe->v1->edges, kfe);
  BLI_remlink(&kfe->v1->edges, ref);

  kfe->v1 = newkfe->v2;
  BLI_addtail(&kfe->v1->edges, ref);

  for (ref = kfe->faces.first; ref; ref = ref->next) {
    knife_edge_append_face(kcd, newkfe, ref->ref);
  }

  knife_add_to_vert_edges(kcd, newkfe);

  newkfe->is_cut = kfe->is_cut;
  newkfe->e = kfe->e;

  *r_kfe = newkfe;

  return newkfe->v2;
}

static void linehit_to_knifepos(KnifePosData *kpos, KnifeLineHit *lh)
{
  kpos->bmface = lh->f;
  kpos->vert = lh->v;
  kpos->edge = lh->kfe;
  copy_v3_v3(kpos->cage, lh->cagehit);
  copy_v3_v3(kpos->co, lh->hit);
  copy_v2_v2(kpos->mval, lh->schit);
}

/* primary key: lambda along cut
 * secondary key: lambda along depth
 * tertiary key: pointer comparisons of verts if both snapped to verts
 */
static int linehit_compare(const void *vlh1, const void *vlh2)
{
  const KnifeLineHit *lh1 = vlh1;
  const KnifeLineHit *lh2 = vlh2;

  if (lh1->l < lh2->l) {
    return -1;
  }
  else if (lh1->l > lh2->l) {
    return 1;
  }
  else {
    if (lh1->m < lh2->m) {
      return -1;
    }
    else if (lh1->m > lh2->m) {
      return 1;
    }
    else {
      if (lh1->v < lh2->v) {
        return -1;
      }
      else if (lh1->v > lh2->v) {
        return 1;
      }
      else {
        return 0;
      }
    }
  }
}

/*
 * Sort linehits by distance along cut line, and secondarily from
 * front to back (from eye), and tertiarily by snap vertex,
 * and remove any duplicates.
 */
static void prepare_linehits_for_cut(KnifeTool_OpData *kcd)
{
  KnifeLineHit *linehits, *lhi, *lhj;
  int i, j, n;
  bool is_double = false;

  n = kcd->totlinehit;
  linehits = kcd->linehits;
  if (n == 0) {
    return;
  }

  qsort(linehits, n, sizeof(KnifeLineHit), linehit_compare);

  /* Remove any edge hits that are preceded or followed
   * by a vertex hit that is very near. Mark such edge hits using
   * l == -1 and then do another pass to actually remove.
   * Also remove all but one of a series of vertex hits for the same vertex. */
  for (i = 0; i < n; i++) {
    lhi = &linehits[i];
    if (lhi->v) {
      for (j = i - 1; j >= 0; j--) {
        lhj = &linehits[j];
        if (!lhj->kfe || fabsf(lhi->l - lhj->l) > KNIFE_FLT_EPSBIG ||
            fabsf(lhi->m - lhj->m) > KNIFE_FLT_EPSBIG) {
          break;
        }

        if (lhi->kfe == lhj->kfe) {
          lhj->l = -1.0f;
          is_double = true;
        }
      }
      for (j = i + 1; j < n; j++) {
        lhj = &linehits[j];
        if (fabsf(lhi->l - lhj->l) > KNIFE_FLT_EPSBIG ||
            fabsf(lhi->m - lhj->m) > KNIFE_FLT_EPSBIG) {
          break;
        }
        if ((lhj->kfe && (lhi->kfe == lhj->kfe)) || (lhi->v == lhj->v)) {
          lhj->l = -1.0f;
          is_double = true;
        }
      }
    }
  }

  if (is_double) {
    /* delete-in-place loop: copying from pos j to pos i+1 */
    i = 0;
    j = 1;
    while (j < n) {
      lhi = &linehits[i];
      lhj = &linehits[j];
      if (lhj->l == -1.0f) {
        j++; /* skip copying this one */
      }
      else {
        /* copy unless a no-op */
        if (lhi->l == -1.0f) {
          /* could happen if linehits[0] is being deleted */
          memcpy(&linehits[i], &linehits[j], sizeof(KnifeLineHit));
        }
        else {
          if (i + 1 != j) {
            memcpy(&linehits[i + 1], &linehits[j], sizeof(KnifeLineHit));
          }
          i++;
        }
        j++;
      }
    }
    kcd->totlinehit = i + 1;
  }
}

/* Add hit to list of hits in facehits[f], where facehits is a map, if not already there */
static void add_hit_to_facehits(KnifeTool_OpData *kcd,
                                GHash *facehits,
                                BMFace *f,
                                KnifeLineHit *hit)
{
  ListBase *lst = BLI_ghash_lookup(facehits, f);

  if (!lst) {
    lst = knife_empty_list(kcd);
    BLI_ghash_insert(facehits, f, lst);
  }
  knife_append_list_no_dup(kcd, lst, hit);
}

/**
 * special purpose function, if the linehit is connected to a real edge/vert
 * return true if \a co is outside the face.
 */
static bool knife_add_single_cut__is_linehit_outside_face(BMFace *f,
                                                          const KnifeLineHit *lh,
                                                          const float co[3])
{

  if (lh->v && lh->v->v) {
    BMLoop *l; /* side-of-loop */
    if ((l = BM_face_vert_share_loop(f, lh->v->v)) &&
        (BM_loop_point_side_of_loop_test(l, co) < 0.0f)) {
      return true;
    }
  }
  else if ((lh->kfe && lh->kfe->e)) {
    BMLoop *l; /* side-of-edge */
    if ((l = BM_face_edge_share_loop(f, lh->kfe->e)) &&
        (BM_loop_point_side_of_edge_test(l, co) < 0.0f)) {
      return true;
    }
  }

  return false;
}

static void knife_add_single_cut(KnifeTool_OpData *kcd,
                                 KnifeLineHit *lh1,
                                 KnifeLineHit *lh2,
                                 BMFace *f)
{
  KnifeEdge *kfe, *kfe2;
  BMEdge *e_base;

  if ((lh1->v && lh1->v == lh2->v) || (lh1->kfe && lh1->kfe == lh2->kfe)) {
    return;
  }

  /* if the cut is on an edge, just tag that its a cut and return */
  if ((lh1->v && lh2->v) && (lh1->v->v && lh2->v && lh2->v->v) &&
      (e_base = BM_edge_exists(lh1->v->v, lh2->v->v))) {
    kfe = get_bm_knife_edge(kcd, e_base);
    kfe->is_cut = true;
    kfe->e = e_base;
    return;
  }
  else {
    if (knife_add_single_cut__is_linehit_outside_face(f, lh1, lh2->hit) ||
        knife_add_single_cut__is_linehit_outside_face(f, lh2, lh1->hit)) {
      return;
    }
  }

  /* Check if edge actually lies within face (might not, if this face is concave) */
  if ((lh1->v && !lh1->kfe) && (lh2->v && !lh2->kfe)) {
    if (!knife_verts_edge_in_face(lh1->v, lh2->v, f)) {
      return;
    }
  }

  kfe = new_knife_edge(kcd);
  kfe->is_cut = true;
  kfe->basef = f;

  if (lh1->v) {
    kfe->v1 = lh1->v;
  }
  else if (lh1->kfe) {
    kfe->v1 = knife_split_edge(kcd, lh1->kfe, lh1->hit, lh1->cagehit, &kfe2);
    lh1->v = kfe->v1; /* record the KnifeVert for this hit  */
  }
  else {
    BLI_assert(lh1->f);
    kfe->v1 = new_knife_vert(kcd, lh1->hit, lh1->cagehit);
    kfe->v1->is_cut = true;
    kfe->v1->is_face = true;
    knife_append_list(kcd, &kfe->v1->faces, lh1->f);
    lh1->v = kfe->v1; /* record the KnifeVert for this hit */
  }

  if (lh2->v) {
    kfe->v2 = lh2->v;
  }
  else if (lh2->kfe) {
    kfe->v2 = knife_split_edge(kcd, lh2->kfe, lh2->hit, lh2->cagehit, &kfe2);
    lh2->v = kfe->v2; /* future uses of lh2 won't split again */
  }
  else {
    BLI_assert(lh2->f);
    kfe->v2 = new_knife_vert(kcd, lh2->hit, lh2->cagehit);
    kfe->v2->is_cut = true;
    kfe->v2->is_face = true;
    knife_append_list(kcd, &kfe->v2->faces, lh2->f);
    lh2->v = kfe->v2; /* record the KnifeVert for this hit */
  }

  knife_add_to_vert_edges(kcd, kfe);

  /* TODO: check if this is ever needed */
  if (kfe->basef && !find_ref(&kfe->faces, kfe->basef)) {
    knife_edge_append_face(kcd, kfe, kfe->basef);
  }
}

/* Given a list of KnifeLineHits for one face, sorted by l
 * and then by m, make the required KnifeVerts and
 * KnifeEdges.
 */
static void knife_cut_face(KnifeTool_OpData *kcd, BMFace *f, ListBase *hits)
{
  Ref *r;

  if (BLI_listbase_count_at_most(hits, 2) != 2) {
    return;
  }

  for (r = hits->first; r->next; r = r->next) {
    knife_add_single_cut(kcd, r->ref, r->next->ref, f);
  }
}

/* User has just left-clicked after the first time.
 * Add all knife cuts implied by line from prev to curr.
 * If that line crossed edges then kcd->linehits will be non-NULL.
 * Make all of the KnifeVerts and KnifeEdges implied by this cut.
 */
static void knife_add_cut(KnifeTool_OpData *kcd)
{
  int i;
  GHash *facehits;
  BMFace *f;
  Ref *r;
  GHashIterator giter;
  ListBase *lst;

  prepare_linehits_for_cut(kcd);
  if (kcd->totlinehit == 0) {
    if (kcd->is_drag_hold == false) {
      kcd->prev = kcd->curr;
    }
    return;
  }

  /* make facehits: map face -> list of linehits touching it */
  facehits = BLI_ghash_ptr_new("knife facehits");
  for (i = 0; i < kcd->totlinehit; i++) {
    KnifeLineHit *lh = &kcd->linehits[i];
    if (lh->f) {
      add_hit_to_facehits(kcd, facehits, lh->f, lh);
    }
    if (lh->v) {
      for (r = lh->v->faces.first; r; r = r->next) {
        add_hit_to_facehits(kcd, facehits, r->ref, lh);
      }
    }
    if (lh->kfe) {
      for (r = lh->kfe->faces.first; r; r = r->next) {
        add_hit_to_facehits(kcd, facehits, r->ref, lh);
      }
    }
  }

  /* Note: as following loop progresses, the 'v' fields of
   * the linehits will be filled in (as edges are split or
   * in-face verts are made), so it may be true that both
   * the v and the kfe or f fields will be non-NULL. */
  GHASH_ITER (giter, facehits) {
    f = (BMFace *)BLI_ghashIterator_getKey(&giter);
    lst = (ListBase *)BLI_ghashIterator_getValue(&giter);
    knife_cut_face(kcd, f, lst);
  }

  /* set up for next cut */
  kcd->prev = kcd->curr;

  if (kcd->prev.bmface) {
    /* was "in face" but now we have a KnifeVert it is snapped to */
    KnifeLineHit *lh = &kcd->linehits[kcd->totlinehit - 1];
    kcd->prev.vert = lh->v;
    kcd->prev.bmface = NULL;
  }

  if (kcd->is_drag_hold) {
    KnifeLineHit *lh = &kcd->linehits[kcd->totlinehit - 1];
    linehit_to_knifepos(&kcd->prev, lh);
  }

  BLI_ghash_free(facehits, NULL, NULL);
  MEM_freeN(kcd->linehits);
  kcd->linehits = NULL;
  kcd->totlinehit = 0;
}

static void knife_finish_cut(KnifeTool_OpData *kcd)
{
  if (kcd->linehits) {
    MEM_freeN(kcd->linehits);
    kcd->linehits = NULL;
    kcd->totlinehit = 0;
  }
}

static void knifetool_draw_angle_snapping(const KnifeTool_OpData *kcd)
{
  float v1[3], v2[3];
  float planes[4][4];

  planes_from_projmat(
      (float(*)[4])kcd->projmat, planes[2], planes[0], planes[3], planes[1], NULL, NULL);

  /* ray-cast all planes */
  {
    float ray_dir[3];
    float ray_hit_best[2][3] = {{UNPACK3(kcd->prev.cage)}, {UNPACK3(kcd->curr.cage)}};
    float lambda_best[2] = {-FLT_MAX, FLT_MAX};
    int i;

    /* we (sometimes) need the lines to be at the same depth before projecting */
#if 0
    sub_v3_v3v3(ray_dir, kcd->curr.cage, kcd->prev.cage);
#else
    {
      float curr_cage_adjust[3];
      float co_depth[3];

      copy_v3_v3(co_depth, kcd->prev.cage);
      mul_m4_v3(kcd->ob->obmat, co_depth);
      ED_view3d_win_to_3d(kcd->vc.v3d, kcd->ar, co_depth, kcd->curr.mval, curr_cage_adjust);
      mul_m4_v3(kcd->ob->imat, curr_cage_adjust);

      sub_v3_v3v3(ray_dir, curr_cage_adjust, kcd->prev.cage);
    }
#endif

    for (i = 0; i < 4; i++) {
      float ray_hit[3];
      float lambda_test;
      if (isect_ray_plane_v3(kcd->prev.cage, ray_dir, planes[i], &lambda_test, false)) {
        madd_v3_v3v3fl(ray_hit, kcd->prev.cage, ray_dir, lambda_test);
        if (lambda_test < 0.0f) {
          if (lambda_test > lambda_best[0]) {
            copy_v3_v3(ray_hit_best[0], ray_hit);
            lambda_best[0] = lambda_test;
          }
        }
        else {
          if (lambda_test < lambda_best[1]) {
            copy_v3_v3(ray_hit_best[1], ray_hit);
            lambda_best[1] = lambda_test;
          }
        }
      }
    }

    copy_v3_v3(v1, ray_hit_best[0]);
    copy_v3_v3(v2, ray_hit_best[1]);
  }

  uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);

  immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
  immUniformThemeColor(TH_TRANSFORM);
  GPU_line_width(2.0);

  immBegin(GPU_PRIM_LINES, 2);
  immVertex3fv(pos, v1);
  immVertex3fv(pos, v2);
  immEnd();

  immUnbindProgram();
}

static void knife_init_colors(KnifeColors *colors)
{
  /* possible BMESH_TODO: add explicit themes or calculate these by
   * figuring out contrasting colors with grid / edges / verts
   * a la UI_make_axis_color */
  UI_GetThemeColorType3ubv(TH_NURB_VLINE, SPACE_VIEW3D, colors->line);
  UI_GetThemeColorType3ubv(TH_NURB_ULINE, SPACE_VIEW3D, colors->edge);
  UI_GetThemeColorType3ubv(TH_HANDLE_SEL_VECT, SPACE_VIEW3D, colors->curpoint);
  UI_GetThemeColorType3ubv(TH_HANDLE_SEL_VECT, SPACE_VIEW3D, colors->curpoint_a);
  colors->curpoint_a[3] = 102;
  UI_GetThemeColorType3ubv(TH_ACTIVE_SPLINE, SPACE_VIEW3D, colors->point);
  UI_GetThemeColorType3ubv(TH_ACTIVE_SPLINE, SPACE_VIEW3D, colors->point_a);
  colors->point_a[3] = 102;
}

/* modal loop selection drawing callback */
static void knifetool_draw(const bContext *UNUSED(C), ARegion *UNUSED(ar), void *arg)
{
  const KnifeTool_OpData *kcd = arg;
  GPU_depth_test(false);

  glPolygonOffset(1.0f, 1.0f);

  GPU_matrix_push();
  GPU_matrix_mul(kcd->ob->obmat);

  if (kcd->mode == MODE_DRAGGING && kcd->is_angle_snapping) {
    knifetool_draw_angle_snapping(kcd);
  }

  GPUVertFormat *format = immVertexFormat();
  uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);

  immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);

  if (kcd->mode == MODE_DRAGGING) {
    immUniformColor3ubv(kcd->colors.line);
    GPU_line_width(2.0);

    immBegin(GPU_PRIM_LINES, 2);
    immVertex3fv(pos, kcd->prev.cage);
    immVertex3fv(pos, kcd->curr.cage);
    immEnd();
  }

  if (kcd->prev.vert) {
    immUniformColor3ubv(kcd->colors.point);
    GPU_point_size(11);

    immBegin(GPU_PRIM_POINTS, 1);
    immVertex3fv(pos, kcd->prev.cage);
    immEnd();
  }

  if (kcd->prev.bmface) {
    immUniformColor3ubv(kcd->colors.curpoint);
    GPU_point_size(9);

    immBegin(GPU_PRIM_POINTS, 1);
    immVertex3fv(pos, kcd->prev.cage);
    immEnd();
  }

  if (kcd->curr.edge) {
    immUniformColor3ubv(kcd->colors.edge);
    GPU_line_width(2.0);

    immBegin(GPU_PRIM_LINES, 2);
    immVertex3fv(pos, kcd->curr.edge->v1->cageco);
    immVertex3fv(pos, kcd->curr.edge->v2->cageco);
    immEnd();
  }
  else if (kcd->curr.vert) {
    immUniformColor3ubv(kcd->colors.point);
    GPU_point_size(11);

    immBegin(GPU_PRIM_POINTS, 1);
    immVertex3fv(pos, kcd->curr.cage);
    immEnd();
  }

  if (kcd->curr.bmface) {
    immUniformColor3ubv(kcd->colors.curpoint);
    GPU_point_size(9);

    immBegin(GPU_PRIM_POINTS, 1);
    immVertex3fv(pos, kcd->curr.cage);
    immEnd();
  }

  if (kcd->totlinehit > 0) {
    KnifeLineHit *lh;
    int i, v, vs;
    float fcol[4];

    GPU_blend(true);
    GPU_blend_set_func_separate(
        GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);

    GPUVertBuf *vert = GPU_vertbuf_create_with_format(format);
    GPU_vertbuf_data_alloc(vert, kcd->totlinehit);

    lh = kcd->linehits;
    for (i = 0, v = 0, vs = kcd->totlinehit - 1; i < kcd->totlinehit; i++, lh++) {
      if (lh->v) {
        GPU_vertbuf_attr_set(vert, pos, v++, lh->cagehit);
      }
      else {
        GPU_vertbuf_attr_set(vert, pos, vs--, lh->cagehit);
      }
    }

    GPUBatch *batch = GPU_batch_create_ex(GPU_PRIM_POINTS, vert, NULL, GPU_BATCH_OWNS_VBO);
    GPU_batch_program_set_builtin(batch, GPU_SHADER_3D_UNIFORM_COLOR);

    /* draw any snapped verts first */
    rgba_uchar_to_float(fcol, kcd->colors.point_a);
    GPU_batch_uniform_4fv(batch, "color", fcol);
    GPU_matrix_bind(batch->interface);
    GPU_point_size(11);
    GPU_batch_draw_range_ex(batch, 0, v - 1, false);

    /* now draw the rest */
    rgba_uchar_to_float(fcol, kcd->colors.curpoint_a);
    GPU_batch_uniform_4fv(batch, "color", fcol);
    GPU_point_size(7);
    GPU_batch_draw_range_ex(batch, vs + 1, kcd->totlinehit - (vs + 1), false);

    GPU_batch_program_use_end(batch);
    GPU_batch_discard(batch);

    GPU_blend(false);
  }

  if (kcd->totkedge > 0) {
    BLI_mempool_iter iter;
    KnifeEdge *kfe;

    immUniformColor3ubv(kcd->colors.line);
    GPU_line_width(1.0);

    GPUBatch *batch = immBeginBatchAtMost(GPU_PRIM_LINES, BLI_mempool_len(kcd->kedges) * 2);

    BLI_mempool_iternew(kcd->kedges, &iter);
    for (kfe = BLI_mempool_iterstep(&iter); kfe; kfe = BLI_mempool_iterstep(&iter)) {
      if (!kfe->is_cut) {
        continue;
      }

      immVertex3fv(pos, kfe->v1->cageco);
      immVertex3fv(pos, kfe->v2->cageco);
    }

    immEnd();

    GPU_batch_draw(batch);
    GPU_batch_discard(batch);
  }

  if (kcd->totkvert > 0) {
    BLI_mempool_iter iter;
    KnifeVert *kfv;

    immUniformColor3ubv(kcd->colors.point);
    GPU_point_size(5.0);

    GPUBatch *batch = immBeginBatchAtMost(GPU_PRIM_POINTS, BLI_mempool_len(kcd->kverts));

    BLI_mempool_iternew(kcd->kverts, &iter);
    for (kfv = BLI_mempool_iterstep(&iter); kfv; kfv = BLI_mempool_iterstep(&iter)) {
      if (!kfv->is_cut) {
        continue;
      }

      immVertex3fv(pos, kfv->cageco);
    }

    immEnd();

    GPU_batch_draw(batch);
    GPU_batch_discard(batch);
  }

  immUnbindProgram();

  GPU_matrix_pop();

  /* Reset default */
  GPU_depth_test(true);
}

/**
 * Find intersection of v1-v2 with face f.
 * Only take intersections that are at least \a face_tol_sq (in screen space) away
 * from other intersection elements.
 * If v1-v2 is coplanar with f, call that "no intersection though
 * it really means "infinite number of intersections".
 * In such a case we should have gotten hits on edges or verts of the face.
 */
static bool knife_ray_intersect_face(KnifeTool_OpData *kcd,
                                     const float s[2],
                                     const float v1[3],
                                     const float v2[3],
                                     BMFace *f,
                                     const float face_tol_sq,
                                     float hit_co[3],
                                     float hit_cageco[3])
{
  int tottri, tri_i;
  float raydir[3];
  float tri_norm[3], tri_plane[4];
  float se1[2], se2[2];
  float d, lambda;
  BMLoop **tri;
  ListBase *lst;
  Ref *ref;
  KnifeEdge *kfe;

  sub_v3_v3v3(raydir, v2, v1);
  normalize_v3(raydir);
  tri_i = get_lowest_face_tri(kcd, f);
  tottri = kcd->em->tottri;
  BLI_assert(tri_i >= 0 && tri_i < tottri);

  for (; tri_i < tottri; tri_i++) {
    const float *lv1, *lv2, *lv3;
    float ray_tri_uv[2];

    tri = kcd->em->looptris[tri_i];
    if (tri[0]->f != f) {
      break;
    }
    lv1 = kcd->cagecos[BM_elem_index_get(tri[0]->v)];
    lv2 = kcd->cagecos[BM_elem_index_get(tri[1]->v)];
    lv3 = kcd->cagecos[BM_elem_index_get(tri[2]->v)];
    /* using epsilon test in case ray is directly through an internal
     * tessellation edge and might not hit either tessellation tri with
     * an exact test;
     * we will exclude hits near real edges by a later test */
    if (isect_ray_tri_epsilon_v3(v1, raydir, lv1, lv2, lv3, &lambda, ray_tri_uv, KNIFE_FLT_EPS)) {
      /* check if line coplanar with tri */
      normal_tri_v3(tri_norm, lv1, lv2, lv3);
      plane_from_point_normal_v3(tri_plane, lv1, tri_norm);
      if ((dist_squared_to_plane_v3(v1, tri_plane) < KNIFE_FLT_EPS) &&
          (dist_squared_to_plane_v3(v2, tri_plane) < KNIFE_FLT_EPS)) {
        return false;
      }
      interp_v3_v3v3v3_uv(hit_cageco, lv1, lv2, lv3, ray_tri_uv);
      /* Now check that far enough away from verts and edges */
      lst = knife_get_face_kedges(kcd, f);
      for (ref = lst->first; ref; ref = ref->next) {
        kfe = ref->ref;
        knife_project_v2(kcd, kfe->v1->cageco, se1);
        knife_project_v2(kcd, kfe->v2->cageco, se2);
        d = dist_squared_to_line_segment_v2(s, se1, se2);
        if (d < face_tol_sq) {
          return false;
        }
      }
      interp_v3_v3v3v3_uv(hit_co, tri[0]->v->co, tri[1]->v->co, tri[2]->v->co, ray_tri_uv);
      return true;
    }
  }
  return false;
}

/**
 * Calculate the center and maximum excursion of mesh.
 */
static void calc_ortho_extent(KnifeTool_OpData *kcd)
{
  BMIter iter;
  BMVert *v;
  BMesh *bm = kcd->em->bm;
  float min[3], max[3];

  INIT_MINMAX(min, max);

  if (kcd->cagecos) {
    minmax_v3v3_v3_array(min, max, kcd->cagecos, bm->totvert);
  }
  else {
    BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
      minmax_v3v3_v3(min, max, v->co);
    }
  }

  kcd->ortho_extent = len_v3v3(min, max) / 2;
  mid_v3_v3v3(kcd->ortho_extent_center, min, max);
}

static BMElem *bm_elem_from_knife_vert(KnifeVert *kfv, KnifeEdge **r_kfe)
{
  BMElem *ele_test;
  KnifeEdge *kfe = NULL;

  /* vert? */
  ele_test = (BMElem *)kfv->v;

  if (r_kfe || ele_test == NULL) {
    if (kfv->v == NULL) {
      Ref *ref;
      for (ref = kfv->edges.first; ref; ref = ref->next) {
        kfe = ref->ref;
        if (kfe->e) {
          if (r_kfe) {
            *r_kfe = kfe;
          }
          break;
        }
      }
    }
  }

  /* edge? */
  if (ele_test == NULL) {
    if (kfe) {
      ele_test = (BMElem *)kfe->e;
    }
  }

  /* face? */
  if (ele_test == NULL) {
    if (BLI_listbase_is_single(&kfe->faces)) {
      ele_test = ((Ref *)kfe->faces.first)->ref;
    }
  }

  return ele_test;
}

static BMElem *bm_elem_from_knife_edge(KnifeEdge *kfe)
{
  BMElem *ele_test;

  ele_test = (BMElem *)kfe->e;

  if (ele_test == NULL) {
    ele_test = (BMElem *)kfe->basef;
  }

  return ele_test;
}

/* Do edges e1 and e2 go between exactly the same coordinates? */
static bool coinciding_edges(BMEdge *e1, BMEdge *e2)
{
  const float *co11, *co12, *co21, *co22;

  co11 = e1->v1->co;
  co12 = e1->v2->co;
  co21 = e2->v1->co;
  co22 = e2->v2->co;
  if ((equals_v3v3(co11, co21) && equals_v3v3(co12, co22)) ||
      (equals_v3v3(co11, co22) && equals_v3v3(co12, co21))) {
    return true;
  }
  else {
    return false;
  }
}

/* Callback used in point_is_visible to exclude hits on the faces that are the same
 * as or contain the hitting element (which is in user_data).
 * Also (see T44492) want to exclude hits on faces that butt up to the hitting element
 * (e.g., when you double an edge by an edge split).
 */
static bool bm_ray_cast_cb_elem_not_in_face_check(BMFace *f, void *user_data)
{
  bool ans;
  BMEdge *e, *e2;
  BMIter iter;

  switch (((BMElem *)user_data)->head.htype) {
    case BM_FACE:
      ans = (BMFace *)user_data != f;
      break;
    case BM_EDGE:
      e = (BMEdge *)user_data;
      ans = !BM_edge_in_face(e, f);
      if (ans) {
        /* Is it a boundary edge, coincident with a split edge? */
        if (BM_edge_is_boundary(e)) {
          BM_ITER_ELEM (e2, &iter, f, BM_EDGES_OF_FACE) {
            if (coinciding_edges(e, e2)) {
              ans = false;
              break;
            }
          }
        }
      }
      break;
    case BM_VERT:
      ans = !BM_vert_in_face((BMVert *)user_data, f);
      break;
    default:
      ans = true;
      break;
  }
  return ans;
}

/**
 * Check if \a p is visible (not clipped, not occluded by another face).
 * s in screen projection of p.
 *
 * \param ele_test: Optional vert/edge/face to use when \a p is on the surface of the geometry,
 * intersecting faces matching this face (or connected when an vert/edge) will be ignored.
 */
static bool point_is_visible(KnifeTool_OpData *kcd,
                             const float p[3],
                             const float s[2],
                             BMElem *ele_test)
{
  BMFace *f_hit;

  /* If box clipping on, make sure p is not clipped */
  if (kcd->vc.rv3d->rflag & RV3D_CLIPPING && ED_view3d_clipping_test(kcd->vc.rv3d, p, true)) {
    return false;
  }

  /* If not cutting through, make sure no face is in front of p */
  if (!kcd->cut_through) {
    float dist;
    float view[3], p_ofs[3];

    /* TODO: I think there's a simpler way to get the required raycast ray */
    ED_view3d_unproject(kcd->vc.ar, s[0], s[1], 0.0f, view);

    mul_m4_v3(kcd->ob->imat, view);

    /* make p_ofs a little towards view, so ray doesn't hit p's face. */
    sub_v3_v3(view, p);
    dist = normalize_v3(view);
    copy_v3_v3(p_ofs, p);

    /* avoid projecting behind the viewpoint */
    if (kcd->is_ortho && (kcd->vc.rv3d->persp != RV3D_CAMOB)) {
      dist = kcd->vc.v3d->clip_end * 2.0f;
    }

    if (kcd->vc.rv3d->rflag & RV3D_CLIPPING) {
      float view_clip[2][3];
      /* note: view_clip[0] should never get clipped */
      copy_v3_v3(view_clip[0], p_ofs);
      madd_v3_v3v3fl(view_clip[1], p_ofs, view, dist);

      if (clip_segment_v3_plane_n(view_clip[0],
                                  view_clip[1],
                                  kcd->vc.rv3d->clip_local,
                                  6,
                                  view_clip[0],
                                  view_clip[1])) {
        dist = len_v3v3(p_ofs, view_clip[1]);
      }
    }

    /* see if there's a face hit between p1 and the view */
    if (ele_test) {
      f_hit = BKE_bmbvh_ray_cast_filter(kcd->bmbvh,
                                        p_ofs,
                                        view,
                                        KNIFE_FLT_EPS,
                                        &dist,
                                        NULL,
                                        NULL,
                                        bm_ray_cast_cb_elem_not_in_face_check,
                                        ele_test);
    }
    else {
      f_hit = BKE_bmbvh_ray_cast(kcd->bmbvh, p_ofs, view, KNIFE_FLT_EPS, &dist, NULL, NULL);
    }

    if (f_hit) {
      return false;
    }
  }

  return true;
}

/* Clip the line (v1, v2) to planes perpendicular to it and distances d from
 * the closest point on the line to the origin */
static void clip_to_ortho_planes(float v1[3], float v2[3], const float center[3], const float d)
{
  float closest[3], dir[3];

  sub_v3_v3v3(dir, v1, v2);
  normalize_v3(dir);

  /* could be v1 or v2 */
  sub_v3_v3(v1, center);
  project_plane_normalized_v3_v3v3(closest, v1, dir);
  add_v3_v3(closest, center);

  madd_v3_v3v3fl(v1, closest, dir, d);
  madd_v3_v3v3fl(v2, closest, dir, -d);
}

static void set_linehit_depth(KnifeTool_OpData *kcd, KnifeLineHit *lh)
{
  lh->m = dot_m4_v3_row_z(kcd->vc.rv3d->persmatob, lh->cagehit);
}

/* Finds visible (or all, if cutting through) edges that intersects the current screen drag line */
static void knife_find_line_hits(KnifeTool_OpData *kcd)
{
  SmallHash faces, kfes, kfvs;
  float v1[3], v2[3], v3[3], v4[3], s1[2], s2[2];
  BVHTree *planetree, *tree;
  BVHTreeOverlap *results, *result;
  BMLoop **ls;
  BMFace *f;
  KnifeEdge *kfe;
  KnifeVert *v;
  ListBase *lst;
  Ref *ref;
  KnifeLineHit *linehits = NULL;
  BLI_array_declare(linehits);
  SmallHashIter hiter;
  KnifeLineHit hit;
  void *val;
  void **val_p;
  float plane_cos[12];
  float s[2], se1[2], se2[2], sint[2];
  float r1[3], r2[3];
  float d, d1, d2, lambda;
  float vert_tol, vert_tol_sq;
  float line_tol, line_tol_sq;
  float face_tol, face_tol_sq;
  int isect_kind;
  unsigned int tot;
  int i;
  const bool use_hit_prev = true;
  const bool use_hit_curr = (kcd->is_drag_hold == false);

  if (kcd->linehits) {
    MEM_freeN(kcd->linehits);
    kcd->linehits = NULL;
    kcd->totlinehit = 0;
  }

  copy_v3_v3(v1, kcd->prev.cage);
  copy_v3_v3(v2, kcd->curr.cage);

  /* project screen line's 3d coordinates back into 2d */
  knife_project_v2(kcd, v1, s1);
  knife_project_v2(kcd, v2, s2);

  if (kcd->is_interactive) {
    if (len_squared_v2v2(s1, s2) < 1.0f) {
      return;
    }
  }
  else {
    if (len_squared_v2v2(s1, s2) < KNIFE_FLT_EPS_SQUARED) {
      return;
    }
  }

  /* unproject screen line */
  ED_view3d_win_to_segment_clipped(kcd->vc.depsgraph, kcd->ar, kcd->vc.v3d, s1, v1, v3, true);
  ED_view3d_win_to_segment_clipped(kcd->vc.depsgraph, kcd->ar, kcd->vc.v3d, s2, v2, v4, true);

  mul_m4_v3(kcd->ob->imat, v1);
  mul_m4_v3(kcd->ob->imat, v2);
  mul_m4_v3(kcd->ob->imat, v3);
  mul_m4_v3(kcd->ob->imat, v4);

  /* numeric error, 'v1' -> 'v2', 'v2' -> 'v4' can end up being ~2000 units apart in otho mode
   * (from ED_view3d_win_to_segment_clipped() above)
   * this gives precision error; rather then solving properly
   * (which may involve using doubles everywhere!),
   * limit the distance between these points */
  if (kcd->is_ortho && (kcd->vc.rv3d->persp != RV3D_CAMOB)) {
    if (kcd->ortho_extent == 0.0f) {
      calc_ortho_extent(kcd);
    }
    clip_to_ortho_planes(v1, v3, kcd->ortho_extent_center, kcd->ortho_extent + 10.0f);
    clip_to_ortho_planes(v2, v4, kcd->ortho_extent_center, kcd->ortho_extent + 10.0f);
  }

  /* First use bvh tree to find faces, knife edges, and knife verts that might
   * intersect the cut plane with rays v1-v3 and v2-v4.
   * This deduplicates the candidates before doing more expensive intersection tests. */

  tree = BKE_bmbvh_tree_get(kcd->bmbvh);
  planetree = BLI_bvhtree_new(4, FLT_EPSILON * 4, 8, 8);
  copy_v3_v3(plane_cos + 0, v1);
  copy_v3_v3(plane_cos + 3, v2);
  copy_v3_v3(plane_cos + 6, v3);
  copy_v3_v3(plane_cos + 9, v4);
  BLI_bvhtree_insert(planetree, 0, plane_cos, 4);
  BLI_bvhtree_balance(planetree);

  results = BLI_bvhtree_overlap(tree, planetree, &tot, NULL, NULL);
  if (!results) {
    BLI_bvhtree_free(planetree);
    return;
  }

  BLI_smallhash_init(&faces);
  BLI_smallhash_init(&kfes);
  BLI_smallhash_init(&kfvs);

  for (i = 0, result = results; i < tot; i++, result++) {
    ls = (BMLoop **)kcd->em->looptris[result->indexA];
    f = ls[0]->f;
    set_lowest_face_tri(kcd, f, result->indexA);

    /* occlude but never cut unselected faces (when only_select is used) */
    if (kcd->only_select && !BM_elem_flag_test(f, BM_ELEM_SELECT)) {
      continue;
    }
    /* for faces, store index of lowest hit looptri in hash */
    if (BLI_smallhash_haskey(&faces, (uintptr_t)f)) {
      continue;
    }
    /* don't care what the value is except that it is non-NULL, for iterator */
    BLI_smallhash_insert(&faces, (uintptr_t)f, f);

    lst = knife_get_face_kedges(kcd, f);
    for (ref = lst->first; ref; ref = ref->next) {
      kfe = ref->ref;
      if (BLI_smallhash_haskey(&kfes, (uintptr_t)kfe)) {
        continue;
      }
      BLI_smallhash_insert(&kfes, (uintptr_t)kfe, kfe);
      v = kfe->v1;
      BLI_smallhash_reinsert(&kfvs, (uintptr_t)v, v);
      v = kfe->v2;
      BLI_smallhash_reinsert(&kfvs, (uintptr_t)v, v);
    }
  }

  /* Now go through the candidates and find intersections */
  /* These tolerances, in screen space, are for intermediate hits,
   * as ends are already snapped to screen. */

  if (kcd->is_interactive) {
    vert_tol = KNIFE_FLT_EPS_PX_VERT;
    line_tol = KNIFE_FLT_EPS_PX_EDGE;
    face_tol = KNIFE_FLT_EPS_PX_FACE;
  }
  else {
    /* Use 1/100th of a pixel, see T43896 (too big), T47910 (too small).
     *
     * Update, leave this as is until we investigate not using pixel coords
     * for geometry calculations: T48023. */
    vert_tol = line_tol = face_tol = 0.5f;
  }

  vert_tol_sq = vert_tol * vert_tol;
  line_tol_sq = line_tol * line_tol;
  face_tol_sq = face_tol * face_tol;

  /* Assume these tolerances swamp floating point rounding errors in calculations below */

  /* first look for vertex hits */
  for (val_p = BLI_smallhash_iternew_p(&kfvs, &hiter, (uintptr_t *)&v); val_p;
       val_p = BLI_smallhash_iternext_p(&hiter, (uintptr_t *)&v)) {
    KnifeEdge *kfe_hit = NULL;

    knife_project_v2(kcd, v->cageco, s);
    d = dist_squared_to_line_segment_v2(s, s1, s2);
    if ((d <= vert_tol_sq) &&
        (point_is_visible(kcd, v->cageco, s, bm_elem_from_knife_vert(v, &kfe_hit)))) {
      memset(&hit, 0, sizeof(hit));
      hit.v = v;

      /* If this isn't from an existing BMVert, it may have been added to a BMEdge originally.
       * knowing if the hit comes from an edge is important for edge-in-face checks later on
       * see: #knife_add_single_cut -> #knife_verts_edge_in_face, T42611 */
      if (kfe_hit) {
        hit.kfe = kfe_hit;
      }

      copy_v3_v3(hit.hit, v->co);
      copy_v3_v3(hit.cagehit, v->cageco);
      copy_v2_v2(hit.schit, s);
      set_linehit_depth(kcd, &hit);
      BLI_array_append(linehits, hit);
    }
    else {
      /* note that these vertes aren't used */
      *val_p = NULL;
    }
  }

  /* now edge hits; don't add if a vertex at end of edge should have hit */
  for (val = BLI_smallhash_iternew(&kfes, &hiter, (uintptr_t *)&kfe); val;
       val = BLI_smallhash_iternext(&hiter, (uintptr_t *)&kfe)) {
    int kfe_verts_in_cut;
    /* if we intersect both verts, don't attempt to intersect the edge */

    kfe_verts_in_cut = (BLI_smallhash_lookup(&kfvs, (intptr_t)kfe->v1) != NULL) +
                       (BLI_smallhash_lookup(&kfvs, (intptr_t)kfe->v2) != NULL);

    if (kfe_verts_in_cut == 2) {
      continue;
    }

    knife_project_v2(kcd, kfe->v1->cageco, se1);
    knife_project_v2(kcd, kfe->v2->cageco, se2);
    isect_kind = (kfe_verts_in_cut) ? -1 : isect_seg_seg_v2_point(s1, s2, se1, se2, sint);
    if (isect_kind == -1) {
      /* isect_seg_seg_v2_simple doesn't do tolerance test around ends of s1-s2 */
      closest_to_line_segment_v2(sint, s1, se1, se2);
      if (len_squared_v2v2(sint, s1) <= line_tol_sq) {
        isect_kind = 1;
      }
      else {
        closest_to_line_segment_v2(sint, s2, se1, se2);
        if (len_squared_v2v2(sint, s2) <= line_tol_sq) {
          isect_kind = 1;
        }
      }
    }
    if (isect_kind == 1) {
      d1 = len_v2v2(sint, se1);
      d2 = len_v2v2(se2, se1);
      if (!(d1 <= line_tol || d2 <= line_tol || fabsf(d1 - d2) <= line_tol)) {
        float p_cage[3], p_cage_tmp[3];
        lambda = d1 / d2;
        /* Can't just interpolate between ends of kfe because
         * that doesn't work with perspective transformation.
         * Need to find 3d intersection of ray through sint */
        knife_input_ray_segment(kcd, sint, 1.0f, r1, r2);
        isect_kind = isect_line_line_v3(
            kfe->v1->cageco, kfe->v2->cageco, r1, r2, p_cage, p_cage_tmp);
        if (isect_kind >= 1 && point_is_visible(kcd, p_cage, sint, bm_elem_from_knife_edge(kfe))) {
          memset(&hit, 0, sizeof(hit));
          if (kcd->snap_midpoints) {
            /* choose intermediate point snap too */
            mid_v3_v3v3(p_cage, kfe->v1->cageco, kfe->v2->cageco);
            mid_v2_v2v2(sint, se1, se2);
            lambda = 0.5f;
          }
          hit.kfe = kfe;
          transform_point_by_seg_v3(
              hit.hit, p_cage, kfe->v1->co, kfe->v2->co, kfe->v1->cageco, kfe->v2->cageco);
          copy_v3_v3(hit.cagehit, p_cage);
          copy_v2_v2(hit.schit, sint);
          hit.perc = lambda;
          set_linehit_depth(kcd, &hit);
          BLI_array_append(linehits, hit);
        }
      }
    }
  }
  /* now face hits; don't add if a vertex or edge in face should have hit */
  for (val = BLI_smallhash_iternew(&faces, &hiter, (uintptr_t *)&f); val;
       val = BLI_smallhash_iternext(&hiter, (uintptr_t *)&f)) {
    float p[3], p_cage[3];

    if (use_hit_prev && knife_ray_intersect_face(kcd, s1, v1, v3, f, face_tol_sq, p, p_cage)) {
      if (point_is_visible(kcd, p_cage, s1, (BMElem *)f)) {
        memset(&hit, 0, sizeof(hit));
        hit.f = f;
        copy_v3_v3(hit.hit, p);
        copy_v3_v3(hit.cagehit, p_cage);
        copy_v2_v2(hit.schit, s1);
        set_linehit_depth(kcd, &hit);
        BLI_array_append(linehits, hit);
      }
    }

    if (use_hit_curr && knife_ray_intersect_face(kcd, s2, v2, v4, f, face_tol_sq, p, p_cage)) {
      if (point_is_visible(kcd, p_cage, s2, (BMElem *)f)) {
        memset(&hit, 0, sizeof(hit));
        hit.f = f;
        copy_v3_v3(hit.hit, p);
        copy_v3_v3(hit.cagehit, p_cage);
        copy_v2_v2(hit.schit, s2);
        set_linehit_depth(kcd, &hit);
        BLI_array_append(linehits, hit);
      }
    }
  }

  kcd->linehits = linehits;
  kcd->totlinehit = BLI_array_len(linehits);

  /* find position along screen line, used for sorting */
  for (i = 0; i < kcd->totlinehit; i++) {
    KnifeLineHit *lh = kcd->linehits + i;

    lh->l = len_v2v2(lh->schit, s1) / len_v2v2(s2, s1);
  }

  BLI_smallhash_release(&faces);
  BLI_smallhash_release(&kfes);
  BLI_smallhash_release(&kfvs);
  BLI_bvhtree_free(planetree);
  if (results) {
    MEM_freeN(results);
  }
}

static void knife_input_ray_segment(KnifeTool_OpData *kcd,
                                    const float mval[2],
                                    const float ofs,
                                    float r_origin[3],
                                    float r_origin_ofs[3])
{
  /* unproject to find view ray */
  ED_view3d_unproject(kcd->vc.ar, mval[0], mval[1], 0.0f, r_origin);
  ED_view3d_unproject(kcd->vc.ar, mval[0], mval[1], ofs, r_origin_ofs);

  /* transform into object space */
  invert_m4_m4(kcd->ob->imat, kcd->ob->obmat);

  mul_m4_v3(kcd->ob->imat, r_origin);
  mul_m4_v3(kcd->ob->imat, r_origin_ofs);
}

static BMFace *knife_find_closest_face(KnifeTool_OpData *kcd,
                                       float co[3],
                                       float cageco[3],
                                       bool *is_space)
{
  BMFace *f;
  float dist = KMAXDIST;
  float origin[3];
  float origin_ofs[3];
  float ray[3], ray_normal[3];

  /* unproject to find view ray */
  knife_input_ray_segment(kcd, kcd->curr.mval, 1.0f, origin, origin_ofs);
  sub_v3_v3v3(ray, origin_ofs, origin);
  normalize_v3_v3(ray_normal, ray);

  f = BKE_bmbvh_ray_cast(kcd->bmbvh, origin, ray_normal, 0.0f, NULL, co, cageco);

  if (f && kcd->only_select && BM_elem_flag_test(f, BM_ELEM_SELECT) == 0) {
    f = NULL;
  }

  if (is_space) {
    *is_space = !f;
  }

  if (!f) {
    if (kcd->is_interactive) {
      /* try to use backbuffer selection method if ray casting failed */
      f = EDBM_face_find_nearest(&kcd->vc, &dist);

      /* cheat for now; just put in the origin instead
       * of a true coordinate on the face.
       * This just puts a point 1.0f infront of the view. */
      add_v3_v3v3(co, origin, ray);
    }
  }

  return f;
}

/* find the 2d screen space density of vertices within a radius.  used to scale snapping
 * distance for picking edges/verts.*/
static int knife_sample_screen_density(KnifeTool_OpData *kcd, const float radius)
{
  BMFace *f;
  bool is_space;
  float co[3], cageco[3], sco[2];

  BLI_assert(kcd->is_interactive == true);

  f = knife_find_closest_face(kcd, co, cageco, &is_space);

  if (f && !is_space) {
    const float radius_sq = radius * radius;
    ListBase *lst;
    Ref *ref;
    float dis_sq;
    int c = 0;

    knife_project_v2(kcd, cageco, sco);

    lst = knife_get_face_kedges(kcd, f);
    for (ref = lst->first; ref; ref = ref->next) {
      KnifeEdge *kfe = ref->ref;
      int i;

      for (i = 0; i < 2; i++) {
        KnifeVert *kfv = i ? kfe->v2 : kfe->v1;

        knife_project_v2(kcd, kfv->cageco, kfv->sco);

        dis_sq = len_squared_v2v2(kfv->sco, sco);
        if (dis_sq < radius_sq) {
          if (kcd->vc.rv3d->rflag & RV3D_CLIPPING) {
            if (ED_view3d_clipping_test(kcd->vc.rv3d, kfv->cageco, true) == 0) {
              c++;
            }
          }
          else {
            c++;
          }
        }
      }
    }

    return c;
  }

  return 0;
}

/* returns snapping distance for edges/verts, scaled by the density of the
 * surrounding mesh (in screen space)*/
static float knife_snap_size(KnifeTool_OpData *kcd, float maxsize)
{
  float density = (float)knife_sample_screen_density(kcd, maxsize * 2.0f);

  return min_ff(maxsize / (density * 0.5f), maxsize);
}

/* p is closest point on edge to the mouse cursor */
static KnifeEdge *knife_find_closest_edge(
    KnifeTool_OpData *kcd, float p[3], float cagep[3], BMFace **fptr, bool *is_space)
{
  BMFace *f;
  float co[3], cageco[3], sco[2];
  float maxdist;

  if (kcd->is_interactive) {
    maxdist = knife_snap_size(kcd, kcd->ethresh);

    if (kcd->ignore_vert_snapping) {
      maxdist *= 0.5f;
    }
  }
  else {
    maxdist = KNIFE_FLT_EPS;
  }

  f = knife_find_closest_face(kcd, co, cageco, NULL);
  *is_space = !f;

  kcd->curr.bmface = f;

  if (f) {
    const float maxdist_sq = maxdist * maxdist;
    KnifeEdge *cure = NULL;
    float cur_cagep[3];
    ListBase *lst;
    Ref *ref;
    float dis_sq, curdis_sq = FLT_MAX;

    /* set p to co, in case we don't find anything, means a face cut */
    copy_v3_v3(p, co);
    copy_v3_v3(cagep, cageco);

    knife_project_v2(kcd, cageco, sco);

    /* look through all edges associated with this face */
    lst = knife_get_face_kedges(kcd, f);
    for (ref = lst->first; ref; ref = ref->next) {
      KnifeEdge *kfe = ref->ref;
      float test_cagep[3];
      float lambda;

      /* project edge vertices into screen space */
      knife_project_v2(kcd, kfe->v1->cageco, kfe->v1->sco);
      knife_project_v2(kcd, kfe->v2->cageco, kfe->v2->sco);

      /* check if we're close enough and calculate 'lambda' */
      if (kcd->is_angle_snapping) {
        /* if snapping, check we're in bounds */
        float sco_snap[2];
        isect_line_line_v2_point(
            kfe->v1->sco, kfe->v2->sco, kcd->prev.mval, kcd->curr.mval, sco_snap);
        lambda = line_point_factor_v2(sco_snap, kfe->v1->sco, kfe->v2->sco);

        /* be strict about angle-snapping within edge */
        if ((lambda < 0.0f - KNIFE_FLT_EPSBIG) || (lambda > 1.0f + KNIFE_FLT_EPSBIG)) {
          continue;
        }

        dis_sq = len_squared_v2v2(sco, sco_snap);
        if (dis_sq < curdis_sq && dis_sq < maxdist_sq) {
          /* we already have 'lambda' */
        }
        else {
          continue;
        }
      }
      else {
        dis_sq = dist_squared_to_line_segment_v2(sco, kfe->v1->sco, kfe->v2->sco);
        if (dis_sq < curdis_sq && dis_sq < maxdist_sq) {
          lambda = line_point_factor_v2(sco, kfe->v1->sco, kfe->v2->sco);
        }
        else {
          continue;
        }
      }

      /* now we have 'lambda' calculated (in screen-space) */
      knife_interp_v3_v3v3(kcd, test_cagep, kfe->v1->cageco, kfe->v2->cageco, lambda);

      if (kcd->vc.rv3d->rflag & RV3D_CLIPPING) {
        /* check we're in the view */
        if (ED_view3d_clipping_test(kcd->vc.rv3d, test_cagep, true)) {
          continue;
        }
      }

      cure = kfe;
      curdis_sq = dis_sq;
      copy_v3_v3(cur_cagep, test_cagep);
    }

    if (fptr) {
      *fptr = f;
    }

    if (cure) {
      if (!kcd->ignore_edge_snapping || !(cure->e)) {
        KnifeVert *edgesnap = NULL;

        if (kcd->snap_midpoints) {
          mid_v3_v3v3(p, cure->v1->co, cure->v2->co);
          mid_v3_v3v3(cagep, cure->v1->cageco, cure->v2->cageco);
        }
        else {
          float lambda = line_point_factor_v3(cur_cagep, cure->v1->cageco, cure->v2->cageco);
          copy_v3_v3(cagep, cur_cagep);
          interp_v3_v3v3(p, cure->v1->co, cure->v2->co, lambda);
        }

        /* update mouse coordinates to the snapped-to edge's screen coordinates
         * this is important for angle snap, which uses the previous mouse position */
        edgesnap = new_knife_vert(kcd, p, cagep);
        kcd->curr.mval[0] = edgesnap->sco[0];
        kcd->curr.mval[1] = edgesnap->sco[1];
      }
      else {
        return NULL;
      }
    }

    return cure;
  }

  if (fptr) {
    *fptr = NULL;
  }

  return NULL;
}

/* find a vertex near the mouse cursor, if it exists */
static KnifeVert *knife_find_closest_vert(
    KnifeTool_OpData *kcd, float p[3], float cagep[3], BMFace **fptr, bool *is_space)
{
  BMFace *f;
  float co[3], cageco[3], sco[2];
  float maxdist;

  if (kcd->is_interactive) {
    maxdist = knife_snap_size(kcd, kcd->vthresh);
    if (kcd->ignore_vert_snapping) {
      maxdist *= 0.5f;
    }
  }
  else {
    maxdist = KNIFE_FLT_EPS;
  }

  f = knife_find_closest_face(kcd, co, cageco, is_space);

  kcd->curr.bmface = f;

  if (f) {
    const float maxdist_sq = maxdist * maxdist;
    ListBase *lst;
    Ref *ref;
    KnifeVert *curv = NULL;
    float dis_sq, curdis_sq = FLT_MAX;

    /* set p to co, in case we don't find anything, means a face cut */
    copy_v3_v3(p, co);
    copy_v3_v3(cagep, cageco);

    knife_project_v2(kcd, cageco, sco);

    lst = knife_get_face_kedges(kcd, f);
    for (ref = lst->first; ref; ref = ref->next) {
      KnifeEdge *kfe = ref->ref;
      int i;

      for (i = 0; i < 2; i++) {
        KnifeVert *kfv = i ? kfe->v2 : kfe->v1;

        knife_project_v2(kcd, kfv->cageco, kfv->sco);

        /* be strict about angle snapping, the vertex needs to be very close to the angle,
         * or we ignore */
        if (kcd->is_angle_snapping) {
          if (dist_squared_to_line_segment_v2(kfv->sco, kcd->prev.mval, kcd->curr.mval) >
              KNIFE_FLT_EPSBIG) {
            continue;
          }
        }

        dis_sq = len_squared_v2v2(kfv->sco, sco);
        if (dis_sq < curdis_sq && dis_sq < maxdist_sq) {
          if (kcd->vc.rv3d->rflag & RV3D_CLIPPING) {
            if (ED_view3d_clipping_test(kcd->vc.rv3d, kfv->cageco, true) == 0) {
              curv = kfv;
              curdis_sq = dis_sq;
            }
          }
          else {
            curv = kfv;
            curdis_sq = dis_sq;
          }
        }
      }
    }

    if (!kcd->ignore_vert_snapping || !(curv && curv->v)) {
      if (fptr) {
        *fptr = f;
      }

      if (curv) {
        copy_v3_v3(p, curv->co);
        copy_v3_v3(cagep, curv->cageco);

        /* update mouse coordinates to the snapped-to vertex's screen coordinates
         * this is important for angle snap, which uses the previous mouse position */
        kcd->curr.mval[0] = curv->sco[0];
        kcd->curr.mval[1] = curv->sco[1];
      }

      return curv;
    }
    else {
      if (fptr) {
        *fptr = f;
      }

      return NULL;
    }
  }

  if (fptr) {
    *fptr = NULL;
  }

  return NULL;
}

/**
 * Snaps a 2d vector to an angle, relative to \a v_ref.
 */
static float snap_v2_angle(float r[2], const float v[2], const float v_ref[2], float angle_snap)
{
  float m2[2][2];
  float v_unit[2];
  float angle, angle_delta;

  BLI_ASSERT_UNIT_V2(v_ref);

  normalize_v2_v2(v_unit, v);
  angle = angle_signed_v2v2(v_unit, v_ref);
  angle_delta = (roundf(angle / angle_snap) * angle_snap) - angle;
  angle_to_mat2(m2, angle_delta);

  mul_v2_m2v2(r, m2, v);
  return angle + angle_delta;
}

/* update both kcd->curr.mval and kcd->mval to snap to required angle */
static bool knife_snap_angle(KnifeTool_OpData *kcd)
{
  const float dvec_ref[2] = {0.0f, 1.0f};
  float dvec[2], dvec_snap[2];
  float snap_step = DEG2RADF(45);

  sub_v2_v2v2(dvec, kcd->curr.mval, kcd->prev.mval);
  if (is_zero_v2(dvec)) {
    return false;
  }

  kcd->angle = snap_v2_angle(dvec_snap, dvec, dvec_ref, snap_step);

  add_v2_v2v2(kcd->curr.mval, kcd->prev.mval, dvec_snap);

  copy_v2_v2(kcd->mval, kcd->curr.mval);

  return true;
}

/* update active knife edge/vert pointers */
static int knife_update_active(KnifeTool_OpData *kcd)
{
  knife_pos_data_clear(&kcd->curr);
  copy_v2_v2(kcd->curr.mval, kcd->mval);

  /* view matrix may have changed, reproject */
  knife_project_v2(kcd, kcd->prev.cage, kcd->prev.mval);

  if (kcd->angle_snapping && (kcd->mode == MODE_DRAGGING)) {
    kcd->is_angle_snapping = knife_snap_angle(kcd);
  }
  else {
    kcd->is_angle_snapping = false;
  }

  kcd->curr.vert = knife_find_closest_vert(
      kcd, kcd->curr.co, kcd->curr.cage, &kcd->curr.bmface, &kcd->curr.is_space);

  if (!kcd->curr.vert &&
      /* no edge snapping while dragging (edges are too sticky when cuts are immediate) */
      !kcd->is_drag_hold) {
    kcd->curr.edge = knife_find_closest_edge(
        kcd, kcd->curr.co, kcd->curr.cage, &kcd->curr.bmface, &kcd->curr.is_space);
  }

  /* if no hits are found this would normally default to (0, 0, 0) so instead
   * get a point at the mouse ray closest to the previous point.
   * Note that drawing lines in `free-space` isn't properly supported
   * but there's no guarantee (0, 0, 0) has any geometry either - campbell */
  if (kcd->curr.vert == NULL && kcd->curr.edge == NULL && kcd->curr.bmface == NULL) {
    float origin[3];
    float origin_ofs[3];

    knife_input_ray_segment(kcd, kcd->curr.mval, 1.0f, origin, origin_ofs);

    if (!isect_line_plane_v3(
            kcd->curr.cage, origin, origin_ofs, kcd->prev.cage, kcd->proj_zaxis)) {
      copy_v3_v3(kcd->curr.cage, kcd->prev.cage);

      /* should never fail! */
      BLI_assert(0);
    }
  }

  if (kcd->mode == MODE_DRAGGING) {
    knife_find_line_hits(kcd);
  }
  return 1;
}

static int sort_verts_by_dist_cb(void *co_p, const void *cur_a_p, const void *cur_b_p)
{
  const KnifeVert *cur_a = ((const Ref *)cur_a_p)->ref;
  const KnifeVert *cur_b = ((const Ref *)cur_b_p)->ref;
  const float *co = co_p;
  const float a_sq = len_squared_v3v3(co, cur_a->co);
  const float b_sq = len_squared_v3v3(co, cur_b->co);

  if (a_sq < b_sq) {
    return -1;
  }
  else if (a_sq > b_sq) {
    return 1;
  }
  else {
    return 0;
  }
}

static bool knife_verts_edge_in_face(KnifeVert *v1, KnifeVert *v2, BMFace *f)
{
  bool v1_inside, v2_inside;
  bool v1_inface, v2_inface;
  BMLoop *l1, *l2;

  if (!f || !v1 || !v2) {
    return false;
  }

  l1 = v1->v ? BM_face_vert_share_loop(f, v1->v) : NULL;
  l2 = v2->v ? BM_face_vert_share_loop(f, v2->v) : NULL;

  if ((l1 && l2) && BM_loop_is_adjacent(l1, l2)) {
    /* boundary-case, always false to avoid edge-in-face checks below */
    return false;
  }

  /* find out if v1 and v2, if set, are part of the face */
  v1_inface = (l1 != NULL);
  v2_inface = (l2 != NULL);

  /* BM_face_point_inside_test uses best-axis projection so this isn't most accurate test... */
  v1_inside = v1_inface ? false : BM_face_point_inside_test(f, v1->co);
  v2_inside = v2_inface ? false : BM_face_point_inside_test(f, v2->co);
  if ((v1_inface && v2_inside) || (v2_inface && v1_inside) || (v1_inside && v2_inside)) {
    return true;
  }

  if (v1_inface && v2_inface) {
    float mid[3];
    /* Can have case where v1 and v2 are on shared chain between two faces.
     * BM_face_splits_check_legal does visibility and self-intersection tests,
     * but it is expensive and maybe a bit buggy, so use a simple
     * "is the midpoint in the face" test */
    mid_v3_v3v3(mid, v1->co, v2->co);
    return BM_face_point_inside_test(f, mid);
  }
  return false;
}

static void knife_make_face_cuts(KnifeTool_OpData *kcd, BMFace *f, ListBase *kfedges)
{
  BMesh *bm = kcd->em->bm;
  KnifeEdge *kfe;
  Ref *ref;
  int edge_array_len = BLI_listbase_count(kfedges);
  int i;

  BMEdge **edge_array = BLI_array_alloca(edge_array, edge_array_len);

  /* point to knife edges we've created edges in, edge_array aligned */
  KnifeEdge **kfe_array = BLI_array_alloca(kfe_array, edge_array_len);

  BLI_assert(BLI_gset_len(kcd->edgenet.edge_visit) == 0);

  i = 0;
  for (ref = kfedges->first; ref; ref = ref->next) {
    bool is_new_edge = false;
    kfe = ref->ref;

    if (kfe->e == NULL) {
      if (kfe->v1->v && kfe->v2->v) {
        kfe->e = BM_edge_exists(kfe->v1->v, kfe->v2->v);
      }
    }

    if (kfe->e) {
      if (BM_edge_in_face(kfe->e, f)) {
        /* shouldn't happen, but in this case - just ignore */
        continue;
      }
    }
    else {
      if (kfe->v1->v == NULL) {
        kfe->v1->v = BM_vert_create(bm, kfe->v1->co, NULL, 0);
      }
      if (kfe->v2->v == NULL) {
        kfe->v2->v = BM_vert_create(bm, kfe->v2->co, NULL, 0);
      }
      BLI_assert(kfe->e == NULL);
      kfe->e = BM_edge_create(bm, kfe->v1->v, kfe->v2->v, NULL, 0);
      if (kfe->e) {
        if (kcd->select_result || BM_elem_flag_test(f, BM_ELEM_SELECT)) {
          BM_edge_select_set(bm, kfe->e, true);
        }
        is_new_edge = true;
      }
    }

    BLI_assert(kfe->e);

    if (BLI_gset_add(kcd->edgenet.edge_visit, kfe->e)) {
      kfe_array[i] = is_new_edge ? kfe : 0;
      edge_array[i] = kfe->e;
      i += 1;
    }
  }

  if (i) {
    const int edge_array_len_orig = i;
    edge_array_len = i;

#ifdef USE_NET_ISLAND_CONNECT
    unsigned int edge_array_holes_len;
    BMEdge **edge_array_holes;
    if (BM_face_split_edgenet_connect_islands(bm,
                                              f,
                                              edge_array,
                                              edge_array_len,
                                              true,
                                              kcd->edgenet.arena,
                                              &edge_array_holes,
                                              &edge_array_holes_len)) {
      if (BM_elem_flag_test(f, BM_ELEM_SELECT)) {
        for (i = edge_array_len; i < edge_array_holes_len; i++) {
          BM_edge_select_set(bm, edge_array_holes[i], true);
        }
      }

      edge_array_len = edge_array_holes_len;
      edge_array = edge_array_holes; /* owned by the arena */
    }
#endif

    {
      BMFace **face_arr = NULL;
      int face_arr_len;

      BM_face_split_edgenet(bm, f, edge_array, edge_array_len, &face_arr, &face_arr_len);

      if (face_arr) {
        MEM_freeN(face_arr);
      }
    }

    /* remove dangling edges, not essential - but nice for users */
    for (i = 0; i < edge_array_len_orig; i++) {
      if (kfe_array[i]) {
        if (BM_edge_is_wire(kfe_array[i]->e)) {
          BM_edge_kill(bm, kfe_array[i]->e);
          kfe_array[i]->e = NULL;
        }
      }
    }

#ifdef USE_NET_ISLAND_CONNECT
    BLI_memarena_clear(kcd->edgenet.arena);
#endif
  }

  BLI_gset_clear(kcd->edgenet.edge_visit, NULL);
}

/* Use the network of KnifeEdges and KnifeVerts accumulated to make real BMVerts and BMEdedges */
static void knife_make_cuts(KnifeTool_OpData *kcd)
{
  BMesh *bm = kcd->em->bm;
  KnifeEdge *kfe;
  KnifeVert *kfv;
  BMFace *f;
  BMEdge *e, *enew;
  ListBase *lst;
  Ref *ref;
  float pct;
  SmallHashIter hiter;
  BLI_mempool_iter iter;
  SmallHash fhash_, *fhash = &fhash_;
  SmallHash ehash_, *ehash = &ehash_;

  BLI_smallhash_init(fhash);
  BLI_smallhash_init(ehash);

  /* put list of cutting edges for a face into fhash, keyed by face */
  BLI_mempool_iternew(kcd->kedges, &iter);
  for (kfe = BLI_mempool_iterstep(&iter); kfe; kfe = BLI_mempool_iterstep(&iter)) {

    /* select edges that lie directly on the cut */
    if (kcd->select_result) {
      if (kfe->e && kfe->is_cut) {
        BM_edge_select_set(bm, kfe->e, true);
      }
    }

    f = kfe->basef;
    if (!f || kfe->e) {
      continue;
    }
    lst = BLI_smallhash_lookup(fhash, (uintptr_t)f);
    if (!lst) {
      lst = knife_empty_list(kcd);
      BLI_smallhash_insert(fhash, (uintptr_t)f, lst);
    }
    knife_append_list(kcd, lst, kfe);
  }

  /* put list of splitting vertices for an edge into ehash, keyed by edge */
  BLI_mempool_iternew(kcd->kverts, &iter);
  for (kfv = BLI_mempool_iterstep(&iter); kfv; kfv = BLI_mempool_iterstep(&iter)) {
    if (kfv->v) {
      continue; /* already have a BMVert */
    }
    for (ref = kfv->edges.first; ref; ref = ref->next) {
      kfe = ref->ref;
      e = kfe->e;
      if (!e) {
        continue;
      }
      lst = BLI_smallhash_lookup(ehash, (uintptr_t)e);
      if (!lst) {
        lst = knife_empty_list(kcd);
        BLI_smallhash_insert(ehash, (uintptr_t)e, lst);
      }
      /* there can be more than one kfe in kfv's list with same e */
      if (!find_ref(lst, kfv)) {
        knife_append_list(kcd, lst, kfv);
      }
    }
  }

  /* split bmesh edges where needed */
  for (lst = BLI_smallhash_iternew(ehash, &hiter, (uintptr_t *)&e); lst;
       lst = BLI_smallhash_iternext(&hiter, (uintptr_t *)&e)) {
    BLI_listbase_sort_r(lst, sort_verts_by_dist_cb, e->v1->co);

    for (ref = lst->first; ref; ref = ref->next) {
      kfv = ref->ref;
      pct = line_point_factor_v3(kfv->co, e->v1->co, e->v2->co);
      kfv->v = BM_edge_split(bm, e, e->v1, &enew, pct);
    }
  }

  if (kcd->only_select) {
    EDBM_flag_disable_all(kcd->em, BM_ELEM_SELECT);
  }

  /* do cuts for each face */
  for (lst = BLI_smallhash_iternew(fhash, &hiter, (uintptr_t *)&f); lst;
       lst = BLI_smallhash_iternext(&hiter, (uintptr_t *)&f)) {
    knife_make_face_cuts(kcd, f, lst);
  }

  BLI_smallhash_release(fhash);
  BLI_smallhash_release(ehash);
}

/* called on tool confirmation */
static void knifetool_finish_ex(KnifeTool_OpData *kcd)
{
  knife_make_cuts(kcd);

  EDBM_selectmode_flush(kcd->em);
  EDBM_mesh_normals_update(kcd->em);
  EDBM_update_generic(kcd->em, true, true);

  /* re-tessellating makes this invalid, dont use again by accident */
  knifetool_free_bmbvh(kcd);
}
static void knifetool_finish(wmOperator *op)
{
  KnifeTool_OpData *kcd = op->customdata;
  knifetool_finish_ex(kcd);
}

static void knife_recalc_projmat(KnifeTool_OpData *kcd)
{
  invert_m4_m4(kcd->ob->imat, kcd->ob->obmat);
  ED_view3d_ob_project_mat_get(kcd->ar->regiondata, kcd->ob, kcd->projmat);
  invert_m4_m4(kcd->projmat_inv, kcd->projmat);

  mul_v3_mat3_m4v3(kcd->proj_zaxis, kcd->ob->imat, kcd->vc.rv3d->viewinv[2]);
  normalize_v3(kcd->proj_zaxis);

  kcd->is_ortho = ED_view3d_clip_range_get(
      kcd->vc.depsgraph, kcd->vc.v3d, kcd->vc.rv3d, &kcd->clipsta, &kcd->clipend, true);
}

/* called when modal loop selection is done... */
static void knifetool_exit_ex(bContext *C, KnifeTool_OpData *kcd)
{
  if (!kcd) {
    return;
  }

  if (kcd->is_interactive) {
    WM_cursor_modal_restore(CTX_wm_window(C));

    /* deactivate the extra drawing stuff in 3D-View */
    ED_region_draw_cb_exit(kcd->ar->type, kcd->draw_handle);
  }

  /* free the custom data */
  BLI_mempool_destroy(kcd->refs);
  BLI_mempool_destroy(kcd->kverts);
  BLI_mempool_destroy(kcd->kedges);

  BLI_ghash_free(kcd->origedgemap, NULL, NULL);
  BLI_ghash_free(kcd->origvertmap, NULL, NULL);
  BLI_ghash_free(kcd->kedgefacemap, NULL, NULL);
  BLI_ghash_free(kcd->facetrimap, NULL, NULL);

  BLI_memarena_free(kcd->arena);
#ifdef USE_NET_ISLAND_CONNECT
  BLI_memarena_free(kcd->edgenet.arena);
#endif
  BLI_gset_free(kcd->edgenet.edge_visit, NULL);

  /* tag for redraw */
  ED_region_tag_redraw(kcd->ar);

  knifetool_free_bmbvh(kcd);

  if (kcd->linehits) {
    MEM_freeN(kcd->linehits);
  }

  /* destroy kcd itself */
  MEM_freeN(kcd);
}
static void knifetool_exit(bContext *C, wmOperator *op)
{
  KnifeTool_OpData *kcd = op->customdata;
  knifetool_exit_ex(C, kcd);
  op->customdata = NULL;
}

static void knifetool_update_mval(KnifeTool_OpData *kcd, const float mval[2])
{
  knife_recalc_projmat(kcd);
  copy_v2_v2(kcd->mval, mval);

  if (knife_update_active(kcd)) {
    ED_region_tag_redraw(kcd->ar);
  }
}

static void knifetool_update_mval_i(KnifeTool_OpData *kcd, const int mval_i[2])
{
  float mval[2] = {UNPACK2(mval_i)};
  knifetool_update_mval(kcd, mval);
}

static void knifetool_init_bmbvh(KnifeTool_OpData *kcd)
{
  BM_mesh_elem_index_ensure(kcd->em->bm, BM_VERT);

  Scene *scene_eval = (Scene *)DEG_get_evaluated_id(kcd->vc.depsgraph, &kcd->scene->id);
  Object *obedit_eval = (Object *)DEG_get_evaluated_id(kcd->vc.depsgraph, &kcd->em->ob->id);
  BMEditMesh *em_eval = BKE_editmesh_from_object(obedit_eval);

  kcd->cagecos = (const float(*)[3])BKE_editmesh_vertexCos_get(
      kcd->vc.depsgraph, em_eval, scene_eval, NULL);

  kcd->bmbvh = BKE_bmbvh_new_from_editmesh(
      kcd->em,
      BMBVH_RETURN_ORIG |
          ((kcd->only_select && kcd->cut_through) ? BMBVH_RESPECT_SELECT : BMBVH_RESPECT_HIDDEN),
      kcd->cagecos,
      false);
}

static void knifetool_free_bmbvh(KnifeTool_OpData *kcd)
{
  if (kcd->bmbvh) {
    BKE_bmbvh_free(kcd->bmbvh);
    kcd->bmbvh = NULL;
  }

  if (kcd->cagecos) {
    MEM_freeN((void *)kcd->cagecos);
    kcd->cagecos = NULL;
  }
}

/* called when modal loop selection gets set up... */
static void knifetool_init(bContext *C,
                           KnifeTool_OpData *kcd,
                           const bool only_select,
                           const bool cut_through,
                           const bool is_interactive)
{
  Scene *scene = CTX_data_scene(C);
  Object *obedit = CTX_data_edit_object(C);

  /* assign the drawing handle for drawing preview line... */
  kcd->scene = scene;
  kcd->ob = obedit;
  kcd->ar = CTX_wm_region(C);

  em_setup_viewcontext(C, &kcd->vc);

  kcd->em = BKE_editmesh_from_object(kcd->ob);

  /* cut all the way through the mesh if use_occlude_geometry button not pushed */
  kcd->is_interactive = is_interactive;
  kcd->cut_through = cut_through;
  kcd->only_select = only_select;

  knifetool_init_bmbvh(kcd);

  kcd->arena = BLI_memarena_new(MEM_SIZE_OPTIMAL(1 << 15), "knife");
#ifdef USE_NET_ISLAND_CONNECT
  kcd->edgenet.arena = BLI_memarena_new(MEM_SIZE_OPTIMAL(1 << 15), __func__);
#endif
  kcd->edgenet.edge_visit = BLI_gset_ptr_new(__func__);

  kcd->vthresh = KMAXDIST - 1;
  kcd->ethresh = KMAXDIST;

  knife_recalc_projmat(kcd);

  ED_region_tag_redraw(kcd->ar);

  kcd->refs = BLI_mempool_create(sizeof(Ref), 0, 2048, 0);
  kcd->kverts = BLI_mempool_create(sizeof(KnifeVert), 0, 512, BLI_MEMPOOL_ALLOW_ITER);
  kcd->kedges = BLI_mempool_create(sizeof(KnifeEdge), 0, 512, BLI_MEMPOOL_ALLOW_ITER);

  kcd->origedgemap = BLI_ghash_ptr_new("knife origedgemap");
  kcd->origvertmap = BLI_ghash_ptr_new("knife origvertmap");
  kcd->kedgefacemap = BLI_ghash_ptr_new("knife kedgefacemap");
  kcd->facetrimap = BLI_ghash_ptr_new("knife facetrimap");

  /* can't usefully select resulting edges in face mode */
  kcd->select_result = (kcd->em->selectmode != SCE_SELECT_FACE);

  knife_pos_data_clear(&kcd->curr);
  knife_pos_data_clear(&kcd->prev);

  if (is_interactive) {
    kcd->draw_handle = ED_region_draw_cb_activate(
        kcd->ar->type, knifetool_draw, kcd, REGION_DRAW_POST_VIEW);

    knife_init_colors(&kcd->colors);
  }
}

static void knifetool_cancel(bContext *C, wmOperator *op)
{
  /* this is just a wrapper around exit() */
  knifetool_exit(C, op);
}

static int knifetool_invoke(bContext *C, wmOperator *op, const wmEvent *event)
{
  const bool only_select = RNA_boolean_get(op->ptr, "only_selected");
  const bool cut_through = !RNA_boolean_get(op->ptr, "use_occlude_geometry");
  const bool wait_for_input = RNA_boolean_get(op->ptr, "wait_for_input");

  KnifeTool_OpData *kcd;

  if (only_select) {
    Object *obedit = CTX_data_edit_object(C);
    BMEditMesh *em = BKE_editmesh_from_object(obedit);
    if (em->bm->totfacesel == 0) {
      BKE_report(op->reports, RPT_ERROR, "Selected faces required");
      return OPERATOR_CANCELLED;
    }
  }

  view3d_operator_needs_opengl(C);

  /* alloc new customdata */
  kcd = op->customdata = MEM_callocN(sizeof(KnifeTool_OpData), __func__);

  knifetool_init(C, kcd, only_select, cut_through, true);

  op->flag |= OP_IS_MODAL_CURSOR_REGION;

  /* add a modal handler for this operator - handles loop selection */
  WM_cursor_modal_set(CTX_wm_window(C), BC_KNIFECURSOR);
  WM_event_add_modal_handler(C, op);

  knifetool_update_mval_i(kcd, event->mval);

  if (wait_for_input == false) {
    /* Avoid copy-paste logic. */
    wmEvent event_modal = {
        .prevval = KM_NOTHING,
        .type = EVT_MODAL_MAP,
        .val = KNF_MODAL_ADD_CUT,
    };
    int ret = knifetool_modal(C, op, &event_modal);
    BLI_assert(ret == OPERATOR_RUNNING_MODAL);
    UNUSED_VARS_NDEBUG(ret);
  }

  knife_update_header(C, op, kcd);

  return OPERATOR_RUNNING_MODAL;
}

wmKeyMap *knifetool_modal_keymap(wmKeyConfig *keyconf)
{
  static const EnumPropertyItem modal_items[] = {
      {KNF_MODAL_CANCEL, "CANCEL", 0, "Cancel", ""},
      {KNF_MODAL_CONFIRM, "CONFIRM", 0, "Confirm", ""},
      {KNF_MODAL_MIDPOINT_ON, "SNAP_MIDPOINTS_ON", 0, "Snap To Midpoints On", ""},
      {KNF_MODAL_MIDPOINT_OFF, "SNAP_MIDPOINTS_OFF", 0, "Snap To Midpoints Off", ""},
      {KNF_MODEL_IGNORE_SNAP_ON, "IGNORE_SNAP_ON", 0, "Ignore Snapping On", ""},
      {KNF_MODEL_IGNORE_SNAP_OFF, "IGNORE_SNAP_OFF", 0, "Ignore Snapping Off", ""},
      {KNF_MODAL_ANGLE_SNAP_TOGGLE, "ANGLE_SNAP_TOGGLE", 0, "Toggle Angle Snapping", ""},
      {KNF_MODAL_CUT_THROUGH_TOGGLE, "CUT_THROUGH_TOGGLE", 0, "Toggle Cut Through", ""},
      {KNF_MODAL_NEW_CUT, "NEW_CUT", 0, "End Current Cut", ""},
      {KNF_MODAL_ADD_CUT, "ADD_CUT", 0, "Add Cut", ""},
      {KNF_MODAL_PANNING, "PANNING", 0, "Panning", ""},
      {0, NULL, 0, NULL, NULL},
  };

  wmKeyMap *keymap = WM_modalkeymap_get(keyconf, "Knife Tool Modal Map");

  /* this function is called for each spacetype, only needs to add map once */
  if (keymap && keymap->modal_items) {
    return NULL;
  }

  keymap = WM_modalkeymap_add(keyconf, "Knife Tool Modal Map", modal_items);

  WM_modalkeymap_assign(keymap, "MESH_OT_knife_tool");

  return keymap;
}

static int knifetool_modal(bContext *C, wmOperator *op, const wmEvent *event)
{
  Object *obedit = CTX_data_edit_object(C);
  KnifeTool_OpData *kcd = op->customdata;
  bool do_refresh = false;

  if (!obedit || obedit->type != OB_MESH || BKE_editmesh_from_object(obedit) != kcd->em) {
    knifetool_exit(C, op);
    ED_workspace_status_text(C, NULL);
    return OPERATOR_FINISHED;
  }

  em_setup_viewcontext(C, &kcd->vc);
  kcd->ar = kcd->vc.ar;

  view3d_operator_needs_opengl(C);
  ED_view3d_init_mats_rv3d(obedit, kcd->vc.rv3d); /* needed to initialize clipping */

  if (kcd->mode == MODE_PANNING) {
    kcd->mode = kcd->prevmode;
  }

  /* handle modal keymap */
  if (event->type == EVT_MODAL_MAP) {
    switch (event->val) {
      case KNF_MODAL_CANCEL:
        /* finish */
        ED_region_tag_redraw(kcd->ar);

        knifetool_exit(C, op);
        ED_workspace_status_text(C, NULL);

        return OPERATOR_CANCELLED;
      case KNF_MODAL_CONFIRM:
        /* finish */
        ED_region_tag_redraw(kcd->ar);

        knifetool_finish(op);
        knifetool_exit(C, op);
        ED_workspace_status_text(C, NULL);

        return OPERATOR_FINISHED;
      case KNF_MODAL_MIDPOINT_ON:
        kcd->snap_midpoints = true;

        knife_recalc_projmat(kcd);
        knife_update_active(kcd);
        knife_update_header(C, op, kcd);
        ED_region_tag_redraw(kcd->ar);
        do_refresh = true;
        break;
      case KNF_MODAL_MIDPOINT_OFF:
        kcd->snap_midpoints = false;

        knife_recalc_projmat(kcd);
        knife_update_active(kcd);
        knife_update_header(C, op, kcd);
        ED_region_tag_redraw(kcd->ar);
        do_refresh = true;
        break;
      case KNF_MODEL_IGNORE_SNAP_ON:
        ED_region_tag_redraw(kcd->ar);
        kcd->ignore_vert_snapping = kcd->ignore_edge_snapping = true;
        knife_update_header(C, op, kcd);
        do_refresh = true;
        break;
      case KNF_MODEL_IGNORE_SNAP_OFF:
        ED_region_tag_redraw(kcd->ar);
        kcd->ignore_vert_snapping = kcd->ignore_edge_snapping = false;
        knife_update_header(C, op, kcd);
        do_refresh = true;
        break;
      case KNF_MODAL_ANGLE_SNAP_TOGGLE:
        kcd->angle_snapping = !kcd->angle_snapping;
        knife_update_header(C, op, kcd);
        do_refresh = true;
        break;
      case KNF_MODAL_CUT_THROUGH_TOGGLE:
        kcd->cut_through = !kcd->cut_through;
        knife_update_header(C, op, kcd);
        do_refresh = true;
        break;
      case KNF_MODAL_NEW_CUT:
        ED_region_tag_redraw(kcd->ar);
        knife_finish_cut(kcd);
        kcd->mode = MODE_IDLE;
        break;
      case KNF_MODAL_ADD_CUT:
        knife_recalc_projmat(kcd);

        /* get the value of the event which triggered this one */
        if (event->prevval != KM_RELEASE) {
          if (kcd->mode == MODE_DRAGGING) {
            knife_add_cut(kcd);
          }
          else if (kcd->mode != MODE_PANNING) {
            knife_start_cut(kcd);
            kcd->mode = MODE_DRAGGING;
            kcd->init = kcd->curr;
          }

          /* freehand drawing is incompatible with cut-through */
          if (kcd->cut_through == false) {
            kcd->is_drag_hold = true;
          }
        }
        else {
          kcd->is_drag_hold = false;

          /* needed because the last face 'hit' is ignored when dragging */
          knifetool_update_mval(kcd, kcd->curr.mval);
        }

        ED_region_tag_redraw(kcd->ar);
        break;
      case KNF_MODAL_ADD_CUT_CLOSED:
        if (kcd->mode == MODE_DRAGGING) {

          /* shouldn't be possible with default key-layout, just incase... */
          if (kcd->is_drag_hold) {
            kcd->is_drag_hold = false;
            knifetool_update_mval(kcd, kcd->curr.mval);
          }

          kcd->prev = kcd->curr;
          kcd->curr = kcd->init;

          knife_project_v2(kcd, kcd->curr.cage, kcd->curr.mval);
          knifetool_update_mval(kcd, kcd->curr.mval);

          knife_add_cut(kcd);

          /* KNF_MODAL_NEW_CUT */
          knife_finish_cut(kcd);
          kcd->mode = MODE_IDLE;
        }
        break;
      case KNF_MODAL_PANNING:
        if (event->val != KM_RELEASE) {
          if (kcd->mode != MODE_PANNING) {
            kcd->prevmode = kcd->mode;
            kcd->mode = MODE_PANNING;
          }
        }
        else {
          kcd->mode = kcd->prevmode;
        }

        ED_region_tag_redraw(kcd->ar);
        return OPERATOR_PASS_THROUGH;
    }
  }
  else { /* non-modal-mapped events */
    switch (event->type) {
      case MOUSEPAN:
      case MOUSEZOOM:
      case MOUSEROTATE:
      case WHEELUPMOUSE:
      case WHEELDOWNMOUSE:
        return OPERATOR_PASS_THROUGH;
      case MOUSEMOVE: /* mouse moved somewhere to select another loop */
        if (kcd->mode != MODE_PANNING) {
          knifetool_update_mval_i(kcd, event->mval);

          if (kcd->is_drag_hold) {
            if (kcd->totlinehit >= 2) {
              knife_add_cut(kcd);
            }
          }
        }

        break;
    }
  }

  if (kcd->mode == MODE_DRAGGING) {
    op->flag &= ~OP_IS_MODAL_CURSOR_REGION;
  }
  else {
    op->flag |= OP_IS_MODAL_CURSOR_REGION;
  }

  if (do_refresh) {
    /* we don't really need to update mval,
     * but this happens to be the best way to refresh at the moment */
    knifetool_update_mval_i(kcd, event->mval);
  }

  /* keep going until the user confirms */
  return OPERATOR_RUNNING_MODAL;
}

void MESH_OT_knife_tool(wmOperatorType *ot)
{
  /* description */
  ot->name = "Knife Topology Tool";
  ot->idname = "MESH_OT_knife_tool";
  ot->description = "Cut new topology";

  /* callbacks */
  ot->invoke = knifetool_invoke;
  ot->modal = knifetool_modal;
  ot->cancel = knifetool_cancel;
  ot->poll = ED_operator_editmesh_view3d;

  /* flags */
  ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_BLOCKING;

  /* properties */
  PropertyRNA *prop;
  RNA_def_boolean(ot->srna,
                  "use_occlude_geometry",
                  true,
                  "Occlude Geometry",
                  "Only cut the front most geometry");
  RNA_def_boolean(ot->srna, "only_selected", false, "Only Selected", "Only cut selected geometry");

  prop = RNA_def_boolean(ot->srna, "wait_for_input", true, "Wait for Input", "");
  RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
}

/* -------------------------------------------------------------------- */
/* Knife tool as a utility function
 * that can be used for internal slicing operations */

static bool edbm_mesh_knife_point_isect(LinkNode *polys, const float cent_ss[2])
{
  LinkNode *p = polys;
  int isect = 0;

  while (p) {
    const float(*mval_fl)[2] = p->link;
    const int mval_tot = MEM_allocN_len(mval_fl) / sizeof(*mval_fl);
    isect += (int)isect_point_poly_v2(cent_ss, mval_fl, mval_tot - 1, false);
    p = p->next;
  }

  if (isect % 2) {
    return true;
  }
  return false;
}

/**
 * \param use_tag: When set, tag all faces inside the polylines.
 */
void EDBM_mesh_knife(bContext *C, LinkNode *polys, bool use_tag, bool cut_through)
{
  KnifeTool_OpData *kcd;

  view3d_operator_needs_opengl(C);

  /* init */
  {
    const bool only_select = false;
    const bool is_interactive = false; /* can enable for testing */

    kcd = MEM_callocN(sizeof(KnifeTool_OpData), __func__);

    knifetool_init(C, kcd, only_select, cut_through, is_interactive);

    kcd->ignore_edge_snapping = true;
    kcd->ignore_vert_snapping = true;

    if (use_tag) {
      BM_mesh_elem_hflag_enable_all(kcd->em->bm, BM_EDGE, BM_ELEM_TAG, false);
    }
  }

  /* execute */
  {
    LinkNode *p = polys;

    knife_recalc_projmat(kcd);

    while (p) {
      const float(*mval_fl)[2] = p->link;
      const int mval_tot = MEM_allocN_len(mval_fl) / sizeof(*mval_fl);
      int i;

      for (i = 0; i < mval_tot; i++) {
        knifetool_update_mval(kcd, mval_fl[i]);
        if (i == 0) {
          knife_start_cut(kcd);
          kcd->mode = MODE_DRAGGING;
        }
        else {
          knife_add_cut(kcd);
        }
      }
      knife_finish_cut(kcd);
      kcd->mode = MODE_IDLE;
      p = p->next;
    }
  }

  /* finish */
  {
    knifetool_finish_ex(kcd);

    /* tag faces inside! */
    if (use_tag) {
      BMesh *bm = kcd->em->bm;
      float projmat[4][4];

      BMEdge *e;
      BMIter iter;

      bool keep_search;

      /* freed on knifetool_finish_ex, but we need again to check if points are visible */
      if (kcd->cut_through == false) {
        knifetool_init_bmbvh(kcd);
      }

      ED_view3d_ob_project_mat_get(kcd->ar->regiondata, kcd->ob, projmat);

      /* use face-loop tag to store if we have intersected */
#define F_ISECT_IS_UNKNOWN(f) BM_elem_flag_test(BM_FACE_FIRST_LOOP(f), BM_ELEM_TAG)
#define F_ISECT_SET_UNKNOWN(f) BM_elem_flag_enable(BM_FACE_FIRST_LOOP(f), BM_ELEM_TAG)
#define F_ISECT_SET_OUTSIDE(f) BM_elem_flag_disable(BM_FACE_FIRST_LOOP(f), BM_ELEM_TAG)
      {
        BMFace *f;
        BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
          F_ISECT_SET_UNKNOWN(f);
          BM_elem_flag_disable(f, BM_ELEM_TAG);
        }
      }

      /* tag all faces linked to cut edges */
      BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
        /* check are we tagged?, then we are an original face */
        if (BM_elem_flag_test(e, BM_ELEM_TAG) == false) {
          BMFace *f;
          BMIter fiter;
          BM_ITER_ELEM (f, &fiter, e, BM_FACES_OF_EDGE) {
            float cent[3], cent_ss[2];
            BM_face_calc_point_in_face(f, cent);
            knife_project_v2(kcd, cent, cent_ss);
            if (edbm_mesh_knife_point_isect(polys, cent_ss)) {
              BM_elem_flag_enable(f, BM_ELEM_TAG);
            }
          }
        }
      }

      /* expand tags for faces which are not cut, but are inside the polys */
      do {
        BMFace *f;
        keep_search = false;
        BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
          if (BM_elem_flag_test(f, BM_ELEM_TAG) == false && (F_ISECT_IS_UNKNOWN(f))) {
            /* am I connected to a tagged face via an un-tagged edge
             * (ie, not across a cut) */
            BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
            BMLoop *l_iter = l_first;
            bool found = false;

            do {
              if (BM_elem_flag_test(l_iter->e, BM_ELEM_TAG) != false) {
                /* now check if the adjacent faces is tagged */
                BMLoop *l_radial_iter = l_iter->radial_next;
                if (l_radial_iter != l_iter) {
                  do {
                    if (BM_elem_flag_test(l_radial_iter->f, BM_ELEM_TAG)) {
                      found = true;
                    }
                  } while ((l_radial_iter = l_radial_iter->radial_next) != l_iter &&
                           (found == false));
                }
              }
            } while ((l_iter = l_iter->next) != l_first && (found == false));

            if (found) {
              float cent[3], cent_ss[2];
              BM_face_calc_point_in_face(f, cent);
              knife_project_v2(kcd, cent, cent_ss);
              if ((kcd->cut_through || point_is_visible(kcd, cent, cent_ss, (BMElem *)f)) &&
                  edbm_mesh_knife_point_isect(polys, cent_ss)) {
                BM_elem_flag_enable(f, BM_ELEM_TAG);
                keep_search = true;
              }
              else {
                /* don't loose time on this face again, set it as outside */
                F_ISECT_SET_OUTSIDE(f);
              }
            }
          }
        }
      } while (keep_search);

#undef F_ISECT_IS_UNKNOWN
#undef F_ISECT_SET_UNKNOWN
#undef F_ISECT_SET_OUTSIDE
    }

    knifetool_exit_ex(C, kcd);
    kcd = NULL;
  }
}