Cleanup, LineArt: Rename LineartLine -> LineartEdge

Also cleanup various other "line" variable names

7 files changed, 483 insertions, 483 deletions

diff --git a/source/blender/gpencil_modifiers/intern/MOD_gpencillineart.c b/source/blender/gpencil_modifiers/intern/MOD_gpencillineart.c
index 2170e486416..fd880dbbe41 100644
--- a/source/blender/gpencil_modifiers/intern/MOD_gpencillineart.c
+++ b/source/blender/gpencil_modifiers/intern/MOD_gpencillineart.c
@@ -102,7 +102,7 @@ static void generate_strokes_actual(
       lmd->level_start,
       lmd->use_multiple_levels ? lmd->level_end : lmd->level_start,
       lmd->target_material ? BKE_gpencil_object_material_index_get(ob, lmd->target_material) : 0,
-      lmd->line_types,
+      lmd->edge_types,
       lmd->transparency_flags,
       lmd->transparency_mask,
       lmd->thickness,
diff --git a/source/blender/gpencil_modifiers/intern/lineart/MOD_lineart.h b/source/blender/gpencil_modifiers/intern/lineart/MOD_lineart.h
index 0c170deacbb..c523809a4ad 100644
--- a/source/blender/gpencil_modifiers/intern/lineart/MOD_lineart.h
+++ b/source/blender/gpencil_modifiers/intern/lineart/MOD_lineart.h
@@ -46,7 +46,7 @@ typedef struct LineartStaticMemPool {
 } LineartStaticMemPool;
 
 typedef struct LineartTriangleAdjacent {
-  struct LineartLine *rl[3];
+  struct LineartEdge *e[3];
 } LineartTriangleAdjacent;
 
 typedef struct LineartTriangle {
@@ -71,9 +71,9 @@ typedef struct LineartTriangleThread {
    * also re-used to store triangle-triangle pair for intersection testing stage.
    * Do not directly use LineartTriangleThread.
    * The size of LineartTriangle is dynamically allocated to contain set thread number of
-   * "testing" field. Worker threads will test lines against the "base" triangle.
-   * At least one thread is present, thus we always have at least testing[0]. */
-  struct LineartLine *testing[1];
+   * "testing_e" field. Worker threads will test lines against the "base" triangle.
+   * At least one thread is present, thus we always have at least testing_e[0]. */
+  struct LineartEdge *testing_e[1];
 } LineartTriangleThread;
 
 typedef enum eLineArtElementNodeFlag {
@@ -135,14 +135,14 @@ typedef enum eLineArtVertFlags {
   LRT_VERT_EDGE_USED = (1 << 1),
 } eLineArtVertFlags;
 
-typedef struct LineartLine {
+typedef struct LineartEdge {
   /* We only need link node kind of list here. */
-  struct LineartLine *next;
-  struct LineartVert *l, *r;
+  struct LineartEdge *next;
+  struct LineartVert *v1, *v2;
   /* Local vertex index for two ends, not puting in RenderVert because all verts are loaded, so as
    * long as fewer than half of the mesh edges are becoming a feature line, we save more memory. */
-  int l_obindex, r_obindex;
-  struct LineartTriangle *tl, *tr;
+  int v1_obindex, v2_obindex;
+  struct LineartTriangle *t1, *t2;
   ListBase segments;
   char min_occ;
 
@@ -154,7 +154,7 @@ typedef struct LineartLine {
    * another bit in flags to be able to show the difference.
    */
   struct Object *object_ref;
-} LineartLine;
+} LineartEdge;
 
 typedef struct LineartLineChain {
   struct LineartLineChain *next, *prev;
@@ -232,29 +232,29 @@ typedef struct LineartRenderBuffer {
 
   unsigned int contour_count;
   unsigned int contour_processed;
-  LineartLine *contour_managed;
+  LineartEdge *contour_managed;
   /* Now changed to linknodes. */
-  LineartLine *contours;
+  LineartEdge *contours;
 
   unsigned int intersection_count;
   unsigned int intersection_processed;
-  LineartLine *intersection_managed;
-  LineartLine *intersection_lines;
+  LineartEdge *intersection_managed;
+  LineartEdge *intersection_lines;
 
   unsigned int crease_count;
   unsigned int crease_processed;
-  LineartLine *crease_managed;
-  LineartLine *crease_lines;
+  LineartEdge *crease_managed;
+  LineartEdge *crease_lines;
 
   unsigned int material_line_count;
   unsigned int material_processed;
-  LineartLine *material_managed;
-  LineartLine *material_lines;
+  LineartEdge *material_managed;
+  LineartEdge *material_lines;
 
   unsigned int edge_mark_count;
   unsigned int edge_mark_processed;
-  LineartLine *edge_mark_managed;
-  LineartLine *edge_marks;
+  LineartEdge *edge_mark_managed;
+  LineartEdge *edge_marks;
 
   ListBase chains;
 
@@ -307,30 +307,30 @@ typedef enum eLineartTriangleFlags {
   LRT_TRIANGLE_NO_INTERSECTION = (1 << 4),
 } eLineartTriangleFlags;
 
-/** Controls how many lines a worker thread is processing at one request.
+/** Controls how many edges a worker thread is processing at one request.
  * There's no significant performance impact on choosing different values.
  * Don't make it too small so that the worker thread won't request too many times. */
-#define LRT_THREAD_LINE_COUNT 1000
+#define LRT_THREAD_EDGE_COUNT 1000
 
 typedef struct LineartRenderTaskInfo {
   struct LineartRenderBuffer *rb;
 
   int thread_id;
 
-  LineartLine *contour;
-  LineartLine *contour_end;
+  LineartEdge *contour;
+  LineartEdge *contour_end;
 
-  LineartLine *intersection;
-  LineartLine *intersection_end;
+  LineartEdge *intersection;
+  LineartEdge *intersection_end;
 
-  LineartLine *crease;
-  LineartLine *crease_end;
+  LineartEdge *crease;
+  LineartEdge *crease_end;
 
-  LineartLine *material;
-  LineartLine *material_end;
+  LineartEdge *material;
+  LineartEdge *material_end;
 
-  LineartLine *edge_mark;
-  LineartLine *edge_mark_end;
+  LineartEdge *edge_mark;
+  LineartEdge *edge_mark_end;
 
 } LineartRenderTaskInfo;
 
@@ -535,7 +535,7 @@ void MOD_lineart_gpencil_generate(LineartRenderBuffer *rb,
                                   int level_start,
                                   int level_end,
                                   int mat_nr,
-                                  short line_types,
+                                  short edge_types,
                                   unsigned char transparency_flags,
                                   unsigned char transparency_mask,
                                   short thickness,
diff --git a/source/blender/gpencil_modifiers/intern/lineart/lineart_chain.c b/source/blender/gpencil_modifiers/intern/lineart/lineart_chain.c
index 10a028d94cc..fae5bcd7c2e 100644
--- a/source/blender/gpencil_modifiers/intern/lineart/lineart_chain.c
+++ b/source/blender/gpencil_modifiers/intern/lineart/lineart_chain.c
@@ -44,39 +44,39 @@
 
 #include <math.h>
 
-#define LRT_OTHER_RV(rl, rv) ((rv) == (rl)->l ? (rl)->r : ((rv) == (rl)->r ? (rl)->l : NULL))
+#define LRT_OTHER_RV(e, rv) ((rv) == (e)->v1 ? (e)->v2 : ((rv) == (e)->v2 ? (e)->v1 : NULL))
 
 /* Get a connected line, only for lines who has the exact given vert, or (in the case of
  * intersection lines) who has a vert that has the exact same position. */
-static LineartLine *lineart_line_get_connected(LineartBoundingArea *ba,
+static LineartEdge *lineart_line_get_connected(LineartBoundingArea *ba,
                                                LineartVert *rv,
                                                LineartVert **new_rv,
                                                int match_flag)
 {
   LISTBASE_FOREACH (LinkData *, lip, &ba->linked_lines) {
-    LineartLine *nrl = lip->data;
+    LineartEdge *n_e = lip->data;
 
-    if ((!(nrl->flags & LRT_EDGE_FLAG_ALL_TYPE)) || (nrl->flags & LRT_EDGE_FLAG_CHAIN_PICKED)) {
+    if ((!(n_e->flags & LRT_EDGE_FLAG_ALL_TYPE)) || (n_e->flags & LRT_EDGE_FLAG_CHAIN_PICKED)) {
       continue;
     }
 
-    if (match_flag && ((nrl->flags & LRT_EDGE_FLAG_ALL_TYPE) & match_flag) == 0) {
+    if (match_flag && ((n_e->flags & LRT_EDGE_FLAG_ALL_TYPE) & match_flag) == 0) {
       continue;
     }
 
-    *new_rv = LRT_OTHER_RV(nrl, rv);
+    *new_rv = LRT_OTHER_RV(n_e, rv);
     if (*new_rv) {
-      return nrl;
+      return n_e;
     }
 
-    if (nrl->flags & LRT_EDGE_FLAG_INTERSECTION) {
-      if (rv->fbcoord[0] == nrl->l->fbcoord[0] && rv->fbcoord[1] == nrl->l->fbcoord[1]) {
-        *new_rv = LRT_OTHER_RV(nrl, nrl->l);
-        return nrl;
+    if (n_e->flags & LRT_EDGE_FLAG_INTERSECTION) {
+      if (rv->fbcoord[0] == n_e->v1->fbcoord[0] && rv->fbcoord[1] == n_e->v1->fbcoord[1]) {
+        *new_rv = LRT_OTHER_RV(n_e, n_e->v1);
+        return n_e;
       }
-      if (rv->fbcoord[0] == nrl->r->fbcoord[0] && rv->fbcoord[1] == nrl->r->fbcoord[1]) {
-        *new_rv = LRT_OTHER_RV(nrl, nrl->r);
-        return nrl;
+      if (rv->fbcoord[0] == n_e->v2->fbcoord[0] && rv->fbcoord[1] == n_e->v2->fbcoord[1]) {
+        *new_rv = LRT_OTHER_RV(n_e, n_e->v2);
+        return n_e;
       }
     }
   }
@@ -198,216 +198,216 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
 
   LRT_ITER_ALL_LINES_BEGIN
   {
-    if ((!(rl->flags & LRT_EDGE_FLAG_ALL_TYPE)) || (rl->flags & LRT_EDGE_FLAG_CHAIN_PICKED)) {
+    if ((!(e->flags & LRT_EDGE_FLAG_ALL_TYPE)) || (e->flags & LRT_EDGE_FLAG_CHAIN_PICKED)) {
       LRT_ITER_ALL_LINES_NEXT
       continue;
     }
 
-    rl->flags |= LRT_EDGE_FLAG_CHAIN_PICKED;
+    e->flags |= LRT_EDGE_FLAG_CHAIN_PICKED;
 
     rlc = lineart_chain_create(rb);
 
     /* One chain can only have one object_ref,
      * so we assign it based on the first segment we found. */
-    rlc->object_ref = rl->object_ref;
+    rlc->object_ref = e->object_ref;
 
-    LineartLine *new_rl = rl;
+    LineartEdge *new_e = e;
     LineartVert *new_rv;
     float N[3] = {0};
 
-    if (rl->tl) {
-      N[0] += rl->tl->gn[0];
-      N[1] += rl->tl->gn[1];
-      N[2] += rl->tl->gn[2];
+    if (e->t1) {
+      N[0] += e->t1->gn[0];
+      N[1] += e->t1->gn[1];
+      N[2] += e->t1->gn[2];
     }
-    if (rl->tr) {
-      N[0] += rl->tr->gn[0];
-      N[1] += rl->tr->gn[1];
-      N[2] += rl->tr->gn[2];
+    if (e->t2) {
+      N[0] += e->t2->gn[0];
+      N[1] += e->t2->gn[1];
+      N[2] += e->t2->gn[2];
     }
-    if (rl->tl || rl->tr) {
+    if (e->t1 || e->t2) {
       normalize_v3(N);
     }
 
     /*  Step 1: grow left. */
-    ba = MOD_lineart_get_bounding_area(rb, rl->l->fbcoord[0], rl->l->fbcoord[1]);
-    new_rv = rl->l;
-    rls = rl->segments.first;
+    ba = MOD_lineart_get_bounding_area(rb, e->v1->fbcoord[0], e->v1->fbcoord[1]);
+    new_rv = e->v1;
+    rls = e->segments.first;
     VERT_COORD_TO_FLOAT(new_rv);
     lineart_chain_prepend_point(rb,
                                 rlc,
                                 use_fbcoord,
                                 use_gpos,
                                 N,
-                                rl->flags,
+                                e->flags,
                                 rls->occlusion,
                                 rls->transparency_mask,
-                                rl->l_obindex);
-    while (ba && (new_rl = lineart_line_get_connected(ba, new_rv, &new_rv, rl->flags))) {
-      new_rl->flags |= LRT_EDGE_FLAG_CHAIN_PICKED;
+                                e->v1_obindex);
+    while (ba && (new_e = lineart_line_get_connected(ba, new_rv, &new_rv, e->flags))) {
+      new_e->flags |= LRT_EDGE_FLAG_CHAIN_PICKED;
 
-      if (new_rl->tl || new_rl->tr) {
+      if (new_e->t1 || new_e->t2) {
         zero_v3(N);
-        if (new_rl->tl) {
-          N[0] += new_rl->tl->gn[0];
-          N[1] += new_rl->tl->gn[1];
-          N[2] += new_rl->tl->gn[2];
+        if (new_e->t1) {
+          N[0] += new_e->t1->gn[0];
+          N[1] += new_e->t1->gn[1];
+          N[2] += new_e->t1->gn[2];
         }
-        if (new_rl->tr) {
-          N[0] += new_rl->tr->gn[0];
-          N[1] += new_rl->tr->gn[1];
-          N[2] += new_rl->tr->gn[2];
+        if (new_e->t2) {
+          N[0] += new_e->t2->gn[0];
+          N[1] += new_e->t2->gn[1];
+          N[2] += new_e->t2->gn[2];
         }
         normalize_v3(N);
       }
 
-      if (new_rv == new_rl->l) {
-        for (rls = new_rl->segments.last; rls; rls = rls->prev) {
+      if (new_rv == new_e->v1) {
+        for (rls = new_e->segments.last; rls; rls = rls->prev) {
           double gpos[3], lpos[3];
-          double *lfb = new_rl->l->fbcoord, *rfb = new_rl->r->fbcoord;
+          double *lfb = new_e->v1->fbcoord, *rfb = new_e->v2->fbcoord;
           double global_at = lfb[3] * rls->at / (rls->at * lfb[3] + (1 - rls->at) * rfb[3]);
-          interp_v3_v3v3_db(lpos, new_rl->l->fbcoord, new_rl->r->fbcoord, rls->at);
-          interp_v3_v3v3_db(gpos, new_rl->l->gloc, new_rl->r->gloc, global_at);
+          interp_v3_v3v3_db(lpos, new_e->v1->fbcoord, new_e->v2->fbcoord, rls->at);
+          interp_v3_v3v3_db(gpos, new_e->v1->gloc, new_e->v2->gloc, global_at);
           POS_TO_FLOAT(lpos, gpos)
           lineart_chain_prepend_point(rb,
                                       rlc,
                                       use_fbcoord,
                                       use_gpos,
                                       N,
-                                      new_rl->flags,
+                                      new_e->flags,
                                       rls->occlusion,
                                       rls->transparency_mask,
-                                      new_rl->l_obindex);
+                                      new_e->v1_obindex);
           last_occlusion = rls->occlusion;
           last_transparency = rls->transparency_mask;
         }
       }
-      else if (new_rv == new_rl->r) {
-        rls = new_rl->segments.first;
+      else if (new_rv == new_e->v2) {
+        rls = new_e->segments.first;
         last_occlusion = rls->occlusion;
         last_transparency = rls->transparency_mask;
         rls = rls->next;
         for (; rls; rls = rls->next) {
           double gpos[3], lpos[3];
-          double *lfb = new_rl->l->fbcoord, *rfb = new_rl->r->fbcoord;
+          double *lfb = new_e->v1->fbcoord, *rfb = new_e->v2->fbcoord;
           double global_at = lfb[3] * rls->at / (rls->at * lfb[3] + (1 - rls->at) * rfb[3]);
-          interp_v3_v3v3_db(lpos, new_rl->l->fbcoord, new_rl->r->fbcoord, rls->at);
-          interp_v3_v3v3_db(gpos, new_rl->l->gloc, new_rl->r->gloc, global_at);
+          interp_v3_v3v3_db(lpos, new_e->v1->fbcoord, new_e->v2->fbcoord, rls->at);
+          interp_v3_v3v3_db(gpos, new_e->v1->gloc, new_e->v2->gloc, global_at);
           POS_TO_FLOAT(lpos, gpos)
           lineart_chain_prepend_point(rb,
                                       rlc,
                                       use_fbcoord,
                                       use_gpos,
                                       N,
-                                      new_rl->flags,
+                                      new_e->flags,
                                       last_occlusion,
                                       last_transparency,
-                                      new_rl->r_obindex);
+                                      new_e->v2_obindex);
           last_occlusion = rls->occlusion;
           last_transparency = rls->transparency_mask;
         }
-        VERT_COORD_TO_FLOAT(new_rl->r);
+        VERT_COORD_TO_FLOAT(new_e->v2);
         lineart_chain_prepend_point(rb,
                                     rlc,
                                     use_fbcoord,
                                     use_gpos,
                                     N,
-                                    new_rl->flags,
+                                    new_e->flags,
                                     last_occlusion,
                                     last_transparency,
-                                    new_rl->r_obindex);
+                                    new_e->v2_obindex);
       }
       ba = MOD_lineart_get_bounding_area(rb, new_rv->fbcoord[0], new_rv->fbcoord[1]);
     }
 
     /* Restore normal value. */
-    if (rl->tl || rl->tr) {
+    if (e->t1 || e->t2) {
       zero_v3(N);
-      if (rl->tl) {
-        N[0] += rl->tl->gn[0];
-        N[1] += rl->tl->gn[1];
-        N[2] += rl->tl->gn[2];
+      if (e->t1) {
+        N[0] += e->t1->gn[0];
+        N[1] += e->t1->gn[1];
+        N[2] += e->t1->gn[2];
       }
-      if (rl->tr) {
-        N[0] += rl->tr->gn[0];
-        N[1] += rl->tr->gn[1];
-        N[2] += rl->tr->gn[2];
+      if (e->t2) {
+        N[0] += e->t2->gn[0];
+        N[1] += e->t2->gn[1];
+        N[2] += e->t2->gn[2];
       }
       normalize_v3(N);
     }
     /*  Step 2: Adding all cuts from the given line, so we can continue connecting the right side
      * of the line. */
-    rls = rl->segments.first;
+    rls = e->segments.first;
     last_occlusion = ((LineartLineSegment *)rls)->occlusion;
     last_transparency = ((LineartLineSegment *)rls)->transparency_mask;
     for (rls = rls->next; rls; rls = rls->next) {
       double gpos[3], lpos[3];
-      double *lfb = rl->l->fbcoord, *rfb = rl->r->fbcoord;
+      double *lfb = e->v1->fbcoord, *rfb = e->v2->fbcoord;
       double global_at = lfb[3] * rls->at / (rls->at * lfb[3] + (1 - rls->at) * rfb[3]);
-      interp_v3_v3v3_db(lpos, rl->l->fbcoord, rl->r->fbcoord, rls->at);
-      interp_v3_v3v3_db(gpos, rl->l->gloc, rl->r->gloc, global_at);
+      interp_v3_v3v3_db(lpos, e->v1->fbcoord, e->v2->fbcoord, rls->at);
+      interp_v3_v3v3_db(gpos, e->v1->gloc, e->v2->gloc, global_at);
       POS_TO_FLOAT(lpos, gpos)
       lineart_chain_append_point(rb,
                                  rlc,
                                  use_fbcoord,
                                  use_gpos,
                                  N,
-                                 rl->flags,
+                                 e->flags,
                                  rls->occlusion,
                                  rls->transparency_mask,
-                                 rl->l_obindex);
+                                 e->v1_obindex);
       last_occlusion = rls->occlusion;
       last_transparency = rls->transparency_mask;
     }
-    VERT_COORD_TO_FLOAT(rl->r)
+    VERT_COORD_TO_FLOAT(e->v2)
     lineart_chain_append_point(rb,
                                rlc,
                                use_fbcoord,
                                use_gpos,
                                N,
-                               rl->flags,
+                               e->flags,
                                last_occlusion,
                                last_transparency,
-                               rl->r_obindex);
+                               e->v2_obindex);
 
     /*  Step 3: grow right. */
-    ba = MOD_lineart_get_bounding_area(rb, rl->r->fbcoord[0], rl->r->fbcoord[1]);
-    new_rv = rl->r;
-    while (ba && (new_rl = lineart_line_get_connected(ba, new_rv, &new_rv, rl->flags))) {
-      new_rl->flags |= LRT_EDGE_FLAG_CHAIN_PICKED;
+    ba = MOD_lineart_get_bounding_area(rb, e->v2->fbcoord[0], e->v2->fbcoord[1]);
+    new_rv = e->v2;
+    while (ba && (new_e = lineart_line_get_connected(ba, new_rv, &new_rv, e->flags))) {
+      new_e->flags |= LRT_EDGE_FLAG_CHAIN_PICKED;
 
-      if (new_rl->tl || new_rl->tr) {
+      if (new_e->t1 || new_e->t2) {
         zero_v3(N);
-        if (new_rl->tl) {
-          N[0] += new_rl->tl->gn[0];
-          N[1] += new_rl->tl->gn[1];
-          N[2] += new_rl->tl->gn[2];
+        if (new_e->t1) {
+          N[0] += new_e->t1->gn[0];
+          N[1] += new_e->t1->gn[1];
+          N[2] += new_e->t1->gn[2];
         }
-        if (new_rl->tr) {
-          N[0] += new_rl->tr->gn[0];
-          N[1] += new_rl->tr->gn[1];
-          N[2] += new_rl->tr->gn[2];
+        if (new_e->t2) {
+          N[0] += new_e->t2->gn[0];
+          N[1] += new_e->t2->gn[1];
+          N[2] += new_e->t2->gn[2];
         }
         normalize_v3(N);
       }
 
       /* Fix leading vertex type. */
       rlci = rlc->chain.last;
-      rlci->line_type = new_rl->flags & LRT_EDGE_FLAG_ALL_TYPE;
+      rlci->line_type = new_e->flags & LRT_EDGE_FLAG_ALL_TYPE;
 
-      if (new_rv == new_rl->l) {
-        rls = new_rl->segments.last;
+      if (new_rv == new_e->v1) {
+        rls = new_e->segments.last;
         last_occlusion = rls->occlusion;
         last_transparency = rls->transparency_mask;
         /* Fix leading vertex occlusion. */
         rlci->occlusion = last_occlusion;
         rlci->transparency_mask = last_transparency;
-        for (rls = new_rl->segments.last; rls; rls = rls->prev) {
+        for (rls = new_e->segments.last; rls; rls = rls->prev) {
           double gpos[3], lpos[3];
-          double *lfb = new_rl->l->fbcoord, *rfb = new_rl->r->fbcoord;
+          double *lfb = new_e->v1->fbcoord, *rfb = new_e->v2->fbcoord;
           double global_at = lfb[3] * rls->at / (rls->at * lfb[3] + (1 - rls->at) * rfb[3]);
-          interp_v3_v3v3_db(lpos, new_rl->l->fbcoord, new_rl->r->fbcoord, rls->at);
-          interp_v3_v3v3_db(gpos, new_rl->l->gloc, new_rl->r->gloc, global_at);
+          interp_v3_v3v3_db(lpos, new_e->v1->fbcoord, new_e->v2->fbcoord, rls->at);
+          interp_v3_v3v3_db(gpos, new_e->v1->gloc, new_e->v2->gloc, global_at);
           last_occlusion = rls->prev ? rls->prev->occlusion : last_occlusion;
           last_transparency = rls->prev ? rls->prev->transparency_mask : last_transparency;
           POS_TO_FLOAT(lpos, gpos)
@@ -416,14 +416,14 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
                                      use_fbcoord,
                                      use_gpos,
                                      N,
-                                     new_rl->flags,
+                                     new_e->flags,
                                      last_occlusion,
                                      last_transparency,
-                                     new_rl->l_obindex);
+                                     new_e->v1_obindex);
         }
       }
-      else if (new_rv == new_rl->r) {
-        rls = new_rl->segments.first;
+      else if (new_rv == new_e->v2) {
+        rls = new_e->segments.first;
         last_occlusion = rls->occlusion;
         last_transparency = rls->transparency_mask;
         rlci->occlusion = last_occlusion;
@@ -431,33 +431,33 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
         rls = rls->next;
         for (; rls; rls = rls->next) {
           double gpos[3], lpos[3];
-          double *lfb = new_rl->l->fbcoord, *rfb = new_rl->r->fbcoord;
+          double *lfb = new_e->v1->fbcoord, *rfb = new_e->v2->fbcoord;
           double global_at = lfb[3] * rls->at / (rls->at * lfb[3] + (1 - rls->at) * rfb[3]);
-          interp_v3_v3v3_db(lpos, new_rl->l->fbcoord, new_rl->r->fbcoord, rls->at);
-          interp_v3_v3v3_db(gpos, new_rl->l->gloc, new_rl->r->gloc, global_at);
+          interp_v3_v3v3_db(lpos, new_e->v1->fbcoord, new_e->v2->fbcoord, rls->at);
+          interp_v3_v3v3_db(gpos, new_e->v1->gloc, new_e->v2->gloc, global_at);
           POS_TO_FLOAT(lpos, gpos)
           lineart_chain_append_point(rb,
                                      rlc,
                                      use_fbcoord,
                                      use_gpos,
                                      N,
-                                     new_rl->flags,
+                                     new_e->flags,
                                      rls->occlusion,
                                      rls->transparency_mask,
-                                     new_rl->r_obindex);
+                                     new_e->v2_obindex);
           last_occlusion = rls->occlusion;
           last_transparency = rls->transparency_mask;
         }
-        VERT_COORD_TO_FLOAT(new_rl->r)
+        VERT_COORD_TO_FLOAT(new_e->v2)
         lineart_chain_append_point(rb,
                                    rlc,
                                    use_fbcoord,
                                    use_gpos,
                                    N,
-                                   new_rl->flags,
+                                   new_e->flags,
                                    last_occlusion,
                                    last_transparency,
-                                   new_rl->r_obindex);
+                                   new_e->v2_obindex);
       }
       ba = MOD_lineart_get_bounding_area(rb, new_rv->fbcoord[0], new_rv->fbcoord[1]);
     }
@@ -465,7 +465,7 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
       rlc->type = LRT_EDGE_FLAG_CONTOUR;
     }
     else {
-      rlc->type = (rl->flags & LRT_EDGE_FLAG_ALL_TYPE);
+      rlc->type = (e->flags & LRT_EDGE_FLAG_ALL_TYPE);
     }
   }
   LRT_ITER_ALL_LINES_END
diff --git a/source/blender/gpencil_modifiers/intern/lineart/lineart_cpu.c b/source/blender/gpencil_modifiers/intern/lineart/lineart_cpu.c
index ca65fc9bd57..6c638478983 100644
--- a/source/blender/gpencil_modifiers/intern/lineart/lineart_cpu.c
+++ b/source/blender/gpencil_modifiers/intern/lineart/lineart_cpu.c
@@ -78,15 +78,15 @@
 
 #include "lineart_intern.h"
 
-static LineartBoundingArea *lineart_line_first_bounding_area(LineartRenderBuffer *rb,
-                                                             LineartLine *rl);
+static LineartBoundingArea *lineart_edge_first_bounding_area(LineartRenderBuffer *rb,
+                                                             LineartEdge *e);
 
 static void lineart_bounding_area_link_line(LineartRenderBuffer *rb,
                                             LineartBoundingArea *root_ba,
-                                            LineartLine *rl);
+                                            LineartEdge *e);
 
-static LineartBoundingArea *lineart_bounding_area_next(LineartBoundingArea *This,
-                                                       LineartLine *rl,
+static LineartBoundingArea *lineart_bounding_area_next(LineartBoundingArea *this,
+                                                       LineartEdge *e,
                                                        double x,
                                                        double y,
                                                        double k,
@@ -95,8 +95,8 @@ static LineartBoundingArea *lineart_bounding_area_next(LineartBoundingArea *This
                                                        double *next_x,
                                                        double *next_y);
 
-static bool lineart_get_line_bounding_areas(LineartRenderBuffer *rb,
-                                            LineartLine *rl,
+static bool lineart_get_edge_bounding_areas(LineartRenderBuffer *rb,
+                                            LineartEdge *e,
                                             int *rowbegin,
                                             int *rowend,
                                             int *colbegin,
@@ -110,9 +110,9 @@ static void lineart_bounding_area_link_triangle(LineartRenderBuffer *rb,
                                                 int recursive_level,
                                                 bool do_intersection);
 
-static bool lineart_triangle_line_image_space_occlusion(SpinLock *spl,
+static bool lineart_triangle_edge_image_space_occlusion(SpinLock *spl,
                                                         const LineartTriangle *rt,
-                                                        const LineartLine *rl,
+                                                        const LineartEdge *e,
                                                         const double *override_camera_loc,
                                                         const bool override_cam_is_persp,
                                                         const bool allow_overlapping_edges,
@@ -123,9 +123,9 @@ static bool lineart_triangle_line_image_space_occlusion(SpinLock *spl,
                                                         double *from,
                                                         double *to);
 
-static void lineart_add_line_to_list(LineartRenderBuffer *rb, LineartLine *rl);
+static void lineart_add_edge_to_list(LineartRenderBuffer *rb, LineartEdge *e);
 
-static void lineart_line_discard_segment(LineartRenderBuffer *rb, LineartLineSegment *rls)
+static void lineart_discard_segment(LineartRenderBuffer *rb, LineartLineSegment *rls)
 {
   BLI_spin_lock(&rb->lock_cuts);
 
@@ -138,7 +138,7 @@ static void lineart_line_discard_segment(LineartRenderBuffer *rb, LineartLineSeg
   BLI_spin_unlock(&rb->lock_cuts);
 }
 
-static LineartLineSegment *lineart_line_give_segment(LineartRenderBuffer *rb)
+static LineartLineSegment *lineart_give_segment(LineartRenderBuffer *rb)
 {
   BLI_spin_lock(&rb->lock_cuts);
 
@@ -156,9 +156,9 @@ static LineartLineSegment *lineart_line_give_segment(LineartRenderBuffer *rb)
                                                          sizeof(LineartLineSegment));
 }
 
-/* Cuts the line in image space and mark occlusion level for each segment. */
-static void lineart_line_cut(LineartRenderBuffer *rb,
-                             LineartLine *rl,
+/* Cuts the edge in image space and mark occlusion level for each segment. */
+static void lineart_edge_cut(LineartRenderBuffer *rb,
+                             LineartEdge *e,
                              double start,
                              double end,
                              unsigned char transparency_mask)
@@ -192,7 +192,7 @@ static void lineart_line_cut(LineartRenderBuffer *rb,
   /* Begin looking for starting position of the segment. */
   /* Not using a list iteration macro because of it more clear when using for loops to iterate
    * through the segments. */
-  for (rls = rl->segments.first; rls; rls = rls->next) {
+  for (rls = e->segments.first; rls; rls = rls->next) {
     if (LRT_DOUBLE_CLOSE_ENOUGH(rls->at, start)) {
       cut_start_before = rls;
       ns = cut_start_before;
@@ -204,7 +204,7 @@ static void lineart_line_cut(LineartRenderBuffer *rb,
     irls = rls->next;
     if (irls->at > start + 1e-09 && start > rls->at) {
       cut_start_before = irls;
-      ns = lineart_line_give_segment(rb);
+      ns = lineart_give_segment(rb);
       break;
     }
   }
@@ -230,14 +230,14 @@ static void lineart_line_cut(LineartRenderBuffer *rb,
     /* When an actual cut is needed in the line. */
     if (rls->at > end) {
       cut_end_before = rls;
-      ns2 = lineart_line_give_segment(rb);
+      ns2 = lineart_give_segment(rb);
       break;
     }
   }
 
   /* When we still can't find any existing cut in the line, we allocate new ones. */
   if (ns == NULL) {
-    ns = lineart_line_give_segment(rb);
+    ns = lineart_give_segment(rb);
   }
   if (ns2 == NULL) {
     if (untouched) {
@@ -245,7 +245,7 @@ static void lineart_line_cut(LineartRenderBuffer *rb,
       cut_end_before = ns2;
     }
     else {
-      ns2 = lineart_line_give_segment(rb);
+      ns2 = lineart_give_segment(rb);
     }
   }
 
@@ -255,17 +255,17 @@ static void lineart_line_cut(LineartRenderBuffer *rb,
       irls = cut_start_before->prev ? cut_start_before->prev : NULL;
       ns->occlusion = irls ? irls->occlusion : 0;
       ns->transparency_mask = irls->transparency_mask;
-      BLI_insertlinkbefore(&rl->segments, (void *)cut_start_before, (void *)ns);
+      BLI_insertlinkbefore(&e->segments, (void *)cut_start_before, (void *)ns);
     }
     /* Otherwise we already found a existing cutting point, no need to insert a new one. */
   }
   else {
     /* We have yet to reach a existing cutting point even after we searched the whole line, so we
      * append the new cut to the end. */
-    irls = rl->segments.last;
+    irls = e->segments.last;
     ns->occlusion = irls->occlusion;
     ns->transparency_mask = irls->transparency_mask;
-    BLI_addtail(&rl->segments, ns);
+    BLI_addtail(&e->segments, ns);
   }
   if (cut_end_before) {
     /* The same manipulation as on "cut_start_before". */
@@ -273,14 +273,14 @@ static void lineart_line_cut(LineartRenderBuffer *rb,
       irls = cut_end_before->prev ? cut_end_before->prev : NULL;
       ns2->occlusion = irls ? irls->occlusion : 0;
       ns2->transparency_mask = irls ? irls->transparency_mask : 0;
-      BLI_insertlinkbefore(&rl->segments, (void *)cut_end_before, (void *)ns2);
+      BLI_insertlinkbefore(&e->segments, (void *)cut_end_before, (void *)ns2);
     }
   }
   else {
-    irls = rl->segments.last;
+    irls = e->segments.last;
     ns2->occlusion = irls->occlusion;
     ns2->transparency_mask = irls->transparency_mask;
-    BLI_addtail(&rl->segments, ns2);
+    BLI_addtail(&e->segments, ns2);
   }
 
   /* If we touched the cut list, we assign the new cut position based on new cut position, this way
@@ -303,15 +303,15 @@ static void lineart_line_cut(LineartRenderBuffer *rb,
   /* Reduce adjacent cutting points of the same level, which saves memory. */
   char min_occ = 127;
   prev_rls = NULL;
-  for (rls = rl->segments.first; rls; rls = next_rls) {
+  for (rls = e->segments.first; rls; rls = next_rls) {
     next_rls = rls->next;
 
     if (prev_rls && prev_rls->occlusion == rls->occlusion &&
         prev_rls->transparency_mask == rls->transparency_mask) {
-      BLI_remlink(&rl->segments, rls);
+      BLI_remlink(&e->segments, rls);
       /* This puts the node back to the render buffer, if more cut happens, these unused nodes get
        * picked first. */
-      lineart_line_discard_segment(rb, rls);
+      lineart_discard_segment(rb, rls);
       continue;
     }
 
@@ -319,49 +319,49 @@ static void lineart_line_cut(LineartRenderBuffer *rb,
 
     prev_rls = rls;
   }
-  rl->min_occ = min_occ;
+  e->min_occ = min_occ;
 }
 
 /* To see if given line is connected to an adjacent intersection line. */
-BLI_INLINE bool lineart_occlusion_is_adjacent_intersection(LineartLine *rl, LineartTriangle *rt)
+BLI_INLINE bool lineart_occlusion_is_adjacent_intersection(LineartEdge *e, LineartTriangle *rt)
 {
-  LineartVertIntersection *l = (void *)rl->l;
-  LineartVertIntersection *r = (void *)rl->r;
-  return ((l->base.flag && l->intersecting_with == (void *)rt) ||
-          (r->base.flag && r->intersecting_with == (void *)rt));
+  LineartVertIntersection *v1 = (void *)e->v1;
+  LineartVertIntersection *v2 = (void *)e->v2;
+  return ((v1->base.flag && v1->intersecting_with == (void *)rt) ||
+          (v2->base.flag && v2->intersecting_with == (void *)rt));
 }
 
-static void lineart_occlusion_single_line(LineartRenderBuffer *rb, LineartLine *rl, int thread_id)
+static void lineart_occlusion_single_line(LineartRenderBuffer *rb, LineartEdge *e, int thread_id)
 {
-  double x = rl->l->fbcoord[0], y = rl->l->fbcoord[1];
-  LineartBoundingArea *ba = lineart_line_first_bounding_area(rb, rl);
+  double x = e->v1->fbcoord[0], y = e->v1->fbcoord[1];
+  LineartBoundingArea *ba = lineart_edge_first_bounding_area(rb, e);
   LineartBoundingArea *nba = ba;
   LineartTriangleThread *rt;
 
   /* These values are used for marching along the line. */
   double l, r;
-  double k = (rl->r->fbcoord[1] - rl->l->fbcoord[1]) /
-             (rl->r->fbcoord[0] - rl->l->fbcoord[0] + 1e-30);
-  int positive_x = (rl->r->fbcoord[0] - rl->l->fbcoord[0]) > 0 ?
+  double k = (e->v2->fbcoord[1] - e->v1->fbcoord[1]) /
+             (e->v2->fbcoord[0] - e->v1->fbcoord[0] + 1e-30);
+  int positive_x = (e->v2->fbcoord[0] - e->v1->fbcoord[0]) > 0 ?
                        1 :
-                       (rl->r->fbcoord[0] == rl->l->fbcoord[0] ? 0 : -1);
-  int positive_y = (rl->r->fbcoord[1] - rl->l->fbcoord[1]) > 0 ?
+                       (e->v2->fbcoord[0] == e->v1->fbcoord[0] ? 0 : -1);
+  int positive_y = (e->v2->fbcoord[1] - e->v1->fbcoord[1]) > 0 ?
                        1 :
-                       (rl->r->fbcoord[1] == rl->l->fbcoord[1] ? 0 : -1);
+                       (e->v2->fbcoord[1] == e->v1->fbcoord[1] ? 0 : -1);
 
   while (nba) {
 
     LISTBASE_FOREACH (LinkData *, lip, &nba->linked_triangles) {
       rt = lip->data;
       /* If we are already testing the line in this thread, then don't do it. */
-      if (rt->testing[thread_id] == rl || (rt->base.flags & LRT_TRIANGLE_INTERSECTION_ONLY) ||
-          lineart_occlusion_is_adjacent_intersection(rl, (LineartTriangle *)rt)) {
+      if (rt->testing_e[thread_id] == e || (rt->base.flags & LRT_TRIANGLE_INTERSECTION_ONLY) ||
+          lineart_occlusion_is_adjacent_intersection(e, (LineartTriangle *)rt)) {
         continue;
       }
-      rt->testing[thread_id] = rl;
-      if (lineart_triangle_line_image_space_occlusion(&rb->lock_task,
+      rt->testing_e[thread_id] = e;
+      if (lineart_triangle_edge_image_space_occlusion(&rb->lock_task,
                                                       (void *)rt,
-                                                      rl,
+                                                      e,
                                                       rb->camera_pos,
                                                       rb->cam_is_persp,
                                                       rb->allow_overlapping_edges,
@@ -371,22 +371,22 @@ static void lineart_occlusion_single_line(LineartRenderBuffer *rb, LineartLine *
                                                       rb->shift_y,
                                                       &l,
                                                       &r)) {
-        lineart_line_cut(rb, rl, l, r, rt->base.transparency_mask);
-        if (rl->min_occ > rb->max_occlusion_level) {
+        lineart_edge_cut(rb, e, l, r, rt->base.transparency_mask);
+        if (e->min_occ > rb->max_occlusion_level) {
           /* No need to caluclate any longer on this line because no level more than set value is
            * going to show up in the rendered result. */
           return;
         }
       }
     }
-    /* Marching along rl->l to rl->r, searching each possible bounding areas it may touch. */
-    nba = lineart_bounding_area_next(nba, rl, x, y, k, positive_x, positive_y, &x, &y);
+    /* Marching along e->v1 to e->v2, searching each possible bounding areas it may touch. */
+    nba = lineart_bounding_area_next(nba, e, x, y, k, positive_x, positive_y, &x, &y);
   }
 }
 
 static int lineart_occlusion_make_task_info(LineartRenderBuffer *rb, LineartRenderTaskInfo *rti)
 {
-  LineartLine *data;
+  LineartEdge *data;
   int i;
   int res = 0;
 
@@ -396,7 +396,7 @@ static int lineart_occlusion_make_task_info(LineartRenderBuffer *rb, LineartRend
   if (rb->name##_managed) { \
     data = rb->name##_managed; \
     rti->name = (void *)data; \
-    for (i = 0; i < LRT_THREAD_LINE_COUNT && data; i++) { \
+    for (i = 0; i < LRT_THREAD_EDGE_COUNT && data; i++) { \
       data = data->next; \
     } \
     rti->name##_end = data; \
@@ -423,28 +423,28 @@ static int lineart_occlusion_make_task_info(LineartRenderBuffer *rb, LineartRend
 static void lineart_occlusion_worker(TaskPool *__restrict UNUSED(pool), LineartRenderTaskInfo *rti)
 {
   LineartRenderBuffer *rb = rti->rb;
-  LineartLine *lip;
+  LineartEdge *eip;
 
   while (lineart_occlusion_make_task_info(rb, rti)) {
 
-    for (lip = (void *)rti->contour; lip && lip != rti->contour_end; lip = lip->next) {
-      lineart_occlusion_single_line(rb, lip, rti->thread_id);
+    for (eip = (void *)rti->contour; eip && eip != rti->contour_end; eip = eip->next) {
+      lineart_occlusion_single_line(rb, eip, rti->thread_id);
     }
 
-    for (lip = (void *)rti->crease; lip && lip != rti->crease_end; lip = lip->next) {
-      lineart_occlusion_single_line(rb, lip, rti->thread_id);
+    for (eip = (void *)rti->crease; eip && eip != rti->crease_end; eip = eip->next) {
+      lineart_occlusion_single_line(rb, eip, rti->thread_id);
     }
 
-    for (lip = (void *)rti->intersection; lip && lip != rti->intersection_end; lip = lip->next) {
-      lineart_occlusion_single_line(rb, lip, rti->thread_id);
+    for (eip = (void *)rti->intersection; eip && eip != rti->intersection_end; eip = eip->next) {
+      lineart_occlusion_single_line(rb, eip, rti->thread_id);
     }
 
-    for (lip = (void *)rti->material; lip && lip != rti->material_end; lip = lip->next) {
-      lineart_occlusion_single_line(rb, lip, rti->thread_id);
+    for (eip = (void *)rti->material; eip && eip != rti->material_end; eip = eip->next) {
+      lineart_occlusion_single_line(rb, eip, rti->thread_id);
     }
 
-    for (lip = (void *)rti->edge_mark; lip && lip != rti->edge_mark_end; lip = lip->next) {
-      lineart_occlusion_single_line(rb, lip, rti->thread_id);
+    for (eip = (void *)rti->edge_mark; eip && eip != rti->edge_mark_end; eip = eip->next) {
+      lineart_occlusion_single_line(rb, eip, rti->thread_id);
     }
   }
 }
@@ -668,15 +668,15 @@ static LineartElementLinkNode *lineart_memory_get_vert_space(LineartRenderBuffer
   return reln;
 }
 
-static LineartElementLinkNode *lineart_memory_get_line_space(LineartRenderBuffer *rb)
+static LineartElementLinkNode *lineart_memory_get_edge_space(LineartRenderBuffer *rb)
 {
   LineartElementLinkNode *reln;
 
-  LineartLine *render_lines = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartLine) * 64);
+  LineartEdge *render_edges = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartEdge) * 64);
 
   reln = lineart_list_append_pointer_pool_sized(&rb->line_buffer_pointers,
                                                 &rb->render_data_pool,
-                                                render_lines,
+                                                render_edges,
                                                 sizeof(LineartElementLinkNode));
   reln->element_count = 64;
   reln->crease_threshold = rb->crease_threshold;
@@ -699,10 +699,10 @@ static void lineart_triangle_set_cull_flag(LineartTriangle *rt, unsigned char fl
   rt->flags |= intersection_only;
 }
 
-static bool lineart_line_match(LineartTriangle *rt, LineartLine *rl, int v1, int v2)
+static bool lineart_edge_match(LineartTriangle *rt, LineartEdge *e, int v1, int v2)
 {
-  return ((rt->v[v1] == rl->l && rt->v[v2] == rl->r) ||
-          (rt->v[v2] == rl->l && rt->v[v1] == rl->r));
+  return ((rt->v[v1] == e->v1 && rt->v[v2] == e->v2) ||
+          (rt->v[v2] == e->v1 && rt->v[v1] == e->v2));
 }
 
 /* Does near-plane cut on 1 triangle only. When cutting with far-plane, the camera vectors gets
@@ -718,21 +718,21 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
                                          double (*vp)[4],
                                          Object *ob,
                                          int *r_v_count,
-                                         int *r_l_count,
+                                         int *r_e_count,
                                          int *r_t_count,
-                                         LineartElementLinkNode *veln,
-                                         LineartElementLinkNode *leln,
-                                         LineartElementLinkNode *teln)
+                                         LineartElementLinkNode *v_eln,
+                                         LineartElementLinkNode *e_eln,
+                                         LineartElementLinkNode *t_eln)
 {
   double vv1[3], vv2[3], dot1, dot2;
   double a;
   int v_count = *r_v_count;
-  int l_count = *r_l_count;
+  int e_count = *r_e_count;
   int t_count = *r_t_count;
-  int l_obi, r_obi;
+  int v1_obi, v2_obi;
   char new_flag = 0;
 
-  LineartLine *new_rl, *rl, *old_rl;
+  LineartEdge *new_e, *e, *old_e;
   LineartLineSegment *rls;
   LineartTriangleAdjacent *rta;
 
@@ -744,57 +744,57 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
    * lineart_geometry_object_load() for details. */
   rta = (void *)rt->intersecting_verts;
 
-  LineartVert *rv = &((LineartVert *)veln->pointer)[v_count];
-  LineartTriangle *rt1 = (void *)(((unsigned char *)teln->pointer) + rb->triangle_size * t_count);
-  LineartTriangle *rt2 = (void *)(((unsigned char *)teln->pointer) +
+  LineartVert *rv = &((LineartVert *)v_eln->pointer)[v_count];
+  LineartTriangle *rt1 = (void *)(((unsigned char *)t_eln->pointer) + rb->triangle_size * t_count);
+  LineartTriangle *rt2 = (void *)(((unsigned char *)t_eln->pointer) +
                                   rb->triangle_size * (t_count + 1));
 
-  new_rl = &((LineartLine *)leln->pointer)[l_count];
+  new_e = &((LineartEdge *)e_eln->pointer)[e_count];
   /* Init rl to the last rl entry. */
-  rl = new_rl;
+  e = new_e;
 
 #define INCREASE_RL \
-  l_count++; \
-  l_obi = rl->l_obindex; \
-  r_obi = rl->r_obindex; \
-  new_rl = &((LineartLine *)leln->pointer)[l_count]; \
-  rl = new_rl; \
-  rl->l_obindex = l_obi; \
-  rl->r_obindex = r_obi; \
+  e_count++; \
+  v1_obi = e->v1_obindex; \
+  v2_obi = e->v2_obindex; \
+  new_e = &((LineartEdge *)e_eln->pointer)[e_count]; \
+  e = new_e; \
+  e->v1_obindex = v1_obi; \
+  e->v2_obindex = v2_obi; \
   rls = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartLineSegment)); \
-  BLI_addtail(&rl->segments, rls);
+  BLI_addtail(&e->segments, rls);
 
-#define SELECT_RL(rl_num, llink, rlink, newrt) \
-  if (rta->rl[rl_num]) { \
-    old_rl = rta->rl[rl_num]; \
-    new_flag = old_rl->flags; \
-    old_rl->flags = LRT_EDGE_FLAG_CHAIN_PICKED; \
+#define SELECT_RL(e_num, v1_link, v2_link, newrt) \
+  if (rta->e[e_num]) { \
+    old_e = rta->e[e_num]; \
+    new_flag = old_e->flags; \
+    old_e->flags = LRT_EDGE_FLAG_CHAIN_PICKED; \
     INCREASE_RL \
-    rl->l = (llink); \
-    rl->r = (rlink); \
-    rl->flags = new_flag; \
-    rl->object_ref = ob; \
-    rl->tl = ((old_rl->tl == rt) ? (newrt) : (old_rl->tl)); \
-    rl->tr = ((old_rl->tr == rt) ? (newrt) : (old_rl->tr)); \
-    lineart_add_line_to_list(rb, rl); \
+    e->v1 = (v1_link); \
+    e->v2 = (v2_link); \
+    e->flags = new_flag; \
+    e->object_ref = ob; \
+    e->t1 = ((old_e->t1 == rt) ? (newrt) : (old_e->t1)); \
+    e->t2 = ((old_e->t2 == rt) ? (newrt) : (old_e->t2)); \
+    lineart_add_edge_to_list(rb, e); \
   }
 
-#define RELINK_RL(rl_num, newrt) \
-  if (rta->rl[rl_num]) { \
-    old_rl = rta->rl[rl_num]; \
-    old_rl->tl = ((old_rl->tl == rt) ? (newrt) : (old_rl->tl)); \
-    old_rl->tr = ((old_rl->tr == rt) ? (newrt) : (old_rl->tr)); \
+#define RELINK_RL(e_num, newrt) \
+  if (rta->e[e_num]) { \
+    old_e = rta->e[e_num]; \
+    old_e->t1 = ((old_e->t1 == rt) ? (newrt) : (old_e->t1)); \
+    old_e->t2 = ((old_e->t2 == rt) ? (newrt) : (old_e->t2)); \
   }
 
 #define REMOVE_TRIANGLE_RL \
-  if (rta->rl[0]) { \
-    rta->rl[0]->flags = LRT_EDGE_FLAG_CHAIN_PICKED; \
+  if (rta->e[0]) { \
+    rta->e[0]->flags = LRT_EDGE_FLAG_CHAIN_PICKED; \
   } \
-  if (rta->rl[1]) { \
-    rta->rl[1]->flags = LRT_EDGE_FLAG_CHAIN_PICKED; \
+  if (rta->e[1]) { \
+    rta->e[1]->flags = LRT_EDGE_FLAG_CHAIN_PICKED; \
   } \
-  if (rta->rl[2]) { \
-    rta->rl[2]->flags = LRT_EDGE_FLAG_CHAIN_PICKED; \
+  if (rta->e[2]) { \
+    rta->e[2]->flags = LRT_EDGE_FLAG_CHAIN_PICKED; \
   }
 
   switch (in0 + in1 + in2) {
@@ -854,19 +854,19 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
         /* New line connecting two new points. */
         INCREASE_RL
         if (allow_boundaries) {
-          rl->flags = LRT_EDGE_FLAG_CONTOUR;
-          lineart_prepend_line_direct(&rb->contours, rl);
+          e->flags = LRT_EDGE_FLAG_CONTOUR;
+          lineart_prepend_edge_direct(&rb->contours, e);
         }
-        /* Note: inverting rl->l/r (left/right point) doesn't matter as long as
+        /* Note: inverting e->v1/v2 (left/right point) doesn't matter as long as
          * rt->rl and rt->v has the same sequence. and the winding direction
          * can be either CW or CCW but needs to be consistent throughout the calculation.
          */
-        rl->l = &rv[1];
-        rl->r = &rv[0];
+        e->v1 = &rv[1];
+        e->v2 = &rv[0];
         /* Only one adjacent triangle, because the other side is the near plane. */
         /* Use tl or tr doesn't matter. */
-        rl->tl = rt1;
-        rl->object_ref = ob;
+        e->t1 = rt1;
+        e->object_ref = ob;
 
         /* New line connecting original point 0 and a new point, only when it's a selected line. */
         SELECT_RL(2, rt->v[0], &rv[0], rt1)
@@ -904,13 +904,13 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
 
         INCREASE_RL
         if (allow_boundaries) {
-          rl->flags = LRT_EDGE_FLAG_CONTOUR;
-          lineart_prepend_line_direct(&rb->contours, rl);
+          e->flags = LRT_EDGE_FLAG_CONTOUR;
+          lineart_prepend_edge_direct(&rb->contours, e);
         }
-        rl->l = &rv[0];
-        rl->r = &rv[1];
-        rl->tl = rt1;
-        rl->object_ref = ob;
+        e->v1 = &rv[0];
+        e->v2 = &rv[1];
+        e->t1 = rt1;
+        e->object_ref = ob;
 
         SELECT_RL(2, rt->v[2], &rv[0], rt1)
         SELECT_RL(1, rt->v[2], &rv[1], rt1)
@@ -945,13 +945,13 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
 
         INCREASE_RL
         if (allow_boundaries) {
-          rl->flags = LRT_EDGE_FLAG_CONTOUR;
-          lineart_prepend_line_direct(&rb->contours, rl);
+          e->flags = LRT_EDGE_FLAG_CONTOUR;
+          lineart_prepend_edge_direct(&rb->contours, e);
         }
-        rl->l = &rv[1];
-        rl->r = &rv[0];
-        rl->tl = rt1;
-        rl->object_ref = ob;
+        e->v1 = &rv[1];
+        e->v2 = &rv[0];
+        e->t1 = rt1;
+        e->object_ref = ob;
 
         SELECT_RL(1, rt->v[1], &rv[0], rt1)
         SELECT_RL(0, rt->v[1], &rv[1], rt1)
@@ -1017,13 +1017,13 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
         /* New line connects two new points. */
         INCREASE_RL
         if (allow_boundaries) {
-          rl->flags = LRT_EDGE_FLAG_CONTOUR;
-          lineart_prepend_line_direct(&rb->contours, rl);
+          e->flags = LRT_EDGE_FLAG_CONTOUR;
+          lineart_prepend_edge_direct(&rb->contours, e);
         }
-        rl->l = &rv[1];
-        rl->r = &rv[0];
-        rl->tl = rt1;
-        rl->object_ref = ob;
+        e->v1 = &rv[1];
+        e->v2 = &rv[0];
+        e->t1 = rt1;
+        e->object_ref = ob;
 
         /* New line connects new point 0 and old point 1,
          * this is a border line.
@@ -1070,13 +1070,13 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
 
         INCREASE_RL
         if (allow_boundaries) {
-          rl->flags = LRT_EDGE_FLAG_CONTOUR;
-          lineart_prepend_line_direct(&rb->contours, rl);
+          e->flags = LRT_EDGE_FLAG_CONTOUR;
+          lineart_prepend_edge_direct(&rb->contours, e);
         }
-        rl->l = &rv[1];
-        rl->r = &rv[0];
-        rl->tl = rt1;
-        rl->object_ref = ob;
+        e->v1 = &rv[1];
+        e->v2 = &rv[0];
+        e->t1 = rt1;
+        e->object_ref = ob;
 
         SELECT_RL(1, rt->v[2], &rv[0], rt1)
         SELECT_RL(0, rt->v[0], &rv[1], rt2)
@@ -1118,13 +1118,13 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
 
         INCREASE_RL
         if (allow_boundaries) {
-          rl->flags = LRT_EDGE_FLAG_CONTOUR;
-          lineart_prepend_line_direct(&rb->contours, rl);
+          e->flags = LRT_EDGE_FLAG_CONTOUR;
+          lineart_prepend_edge_direct(&rb->contours, e);
         }
-        rl->l = &rv[1];
-        rl->r = &rv[0];
-        rl->tl = rt1;
-        rl->object_ref = ob;
+        e->v1 = &rv[1];
+        e->v2 = &rv[0];
+        e->t1 = rt1;
+        e->object_ref = ob;
 
         SELECT_RL(2, rt->v[0], &rv[0], rt1)
         SELECT_RL(1, rt->v[1], &rv[1], rt2)
@@ -1147,7 +1147,7 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
       break;
   }
   *r_v_count = v_count;
-  *r_l_count = l_count;
+  *r_e_count = e_count;
   *r_t_count = t_count;
 
 #undef INCREASE_RL
@@ -1164,10 +1164,10 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
 static void lineart_main_cull_triangles(LineartRenderBuffer *rb, bool clip_far)
 {
   LineartTriangle *rt;
-  LineartElementLinkNode *veln, *teln, *leln;
+  LineartElementLinkNode *v_eln, *t_eln, *e_eln;
   double(*vp)[4] = rb->view_projection;
   int i;
-  int v_count = 0, t_count = 0, l_count = 0;
+  int v_count = 0, t_count = 0, e_count = 0;
   Object *ob;
   bool allow_boundaries = rb->allow_boundaries;
   double cam_pos[3];
@@ -1192,26 +1192,26 @@ static void lineart_main_cull_triangles(LineartRenderBuffer *rb, bool clip_far)
     add_v3_v3_db(cam_pos, clip_advance);
   }
 
-  veln = lineart_memory_get_vert_space(rb);
-  teln = lineart_memory_get_triangle_space(rb);
-  leln = lineart_memory_get_line_space(rb);
+  v_eln = lineart_memory_get_vert_space(rb);
+  t_eln = lineart_memory_get_triangle_space(rb);
+  e_eln = lineart_memory_get_edge_space(rb);
 
   /* Additional memory space for storing generated points and triangles. */
 #define LRT_CULL_ENSURE_MEMORY \
   if (v_count > 60) { \
-    veln->element_count = v_count; \
-    veln = lineart_memory_get_vert_space(rb); \
+    v_eln->element_count = v_count; \
+    v_eln = lineart_memory_get_vert_space(rb); \
     v_count = 0; \
   } \
   if (t_count > 60) { \
-    teln->element_count = t_count; \
-    teln = lineart_memory_get_triangle_space(rb); \
+    t_eln->element_count = t_count; \
+    t_eln = lineart_memory_get_triangle_space(rb); \
     t_count = 0; \
   } \
-  if (l_count > 60) { \
-    leln->element_count = l_count; \
-    leln = lineart_memory_get_line_space(rb); \
-    l_count = 0; \
+  if (e_count > 60) { \
+    e_eln->element_count = e_count; \
+    e_eln = lineart_memory_get_edge_space(rb); \
+    e_count = 0; \
   }
 
 #define LRT_CULL_DECIDE_INSIDE \
@@ -1274,14 +1274,14 @@ static void lineart_main_cull_triangles(LineartRenderBuffer *rb, bool clip_far)
                                    vp,
                                    ob,
                                    &v_count,
-                                   &l_count,
+                                   &e_count,
                                    &t_count,
-                                   veln,
-                                   leln,
-                                   teln);
+                                   v_eln,
+                                   e_eln,
+                                   t_eln);
     }
-    teln->element_count = t_count;
-    veln->element_count = v_count;
+    t_eln->element_count = t_count;
+    v_eln->element_count = v_count;
   }
 
 #undef LRT_CULL_ENSURE_MEMORY
@@ -1421,39 +1421,39 @@ static char lineart_identify_feature_line(LineartRenderBuffer *rb,
   return 0;
 }
 
-static void lineart_add_line_to_list(LineartRenderBuffer *rb, LineartLine *rl)
+static void lineart_add_edge_to_list(LineartRenderBuffer *rb, LineartEdge *e)
 {
-  switch (rl->flags) {
+  switch (e->flags) {
     case LRT_EDGE_FLAG_CONTOUR:
-      lineart_prepend_line_direct(&rb->contours, rl);
+      lineart_prepend_edge_direct(&rb->contours, e);
       break;
     case LRT_EDGE_FLAG_CREASE:
-      lineart_prepend_line_direct(&rb->crease_lines, rl);
+      lineart_prepend_edge_direct(&rb->crease_lines, e);
       break;
     case LRT_EDGE_FLAG_MATERIAL:
-      lineart_prepend_line_direct(&rb->material_lines, rl);
+      lineart_prepend_edge_direct(&rb->material_lines, e);
       break;
     case LRT_EDGE_FLAG_EDGE_MARK:
-      lineart_prepend_line_direct(&rb->edge_marks, rl);
+      lineart_prepend_edge_direct(&rb->edge_marks, e);
       break;
     case LRT_EDGE_FLAG_INTERSECTION:
-      lineart_prepend_line_direct(&rb->intersection_lines, rl);
+      lineart_prepend_edge_direct(&rb->intersection_lines, e);
       break;
   }
 }
 
 static void lineart_triangle_adjacent_assign(LineartTriangle *rt,
                                              LineartTriangleAdjacent *rta,
-                                             LineartLine *rl)
+                                             LineartEdge *e)
 {
-  if (lineart_line_match(rt, rl, 0, 1)) {
-    rta->rl[0] = rl;
+  if (lineart_edge_match(rt, e, 0, 1)) {
+    rta->e[0] = e;
   }
-  else if (lineart_line_match(rt, rl, 1, 2)) {
-    rta->rl[1] = rl;
+  else if (lineart_edge_match(rt, e, 1, 2)) {
+    rta->e[1] = e;
   }
-  else if (lineart_line_match(rt, rl, 2, 0)) {
-    rta->rl[2] = rl;
+  else if (lineart_edge_match(rt, e, 2, 0)) {
+    rta->e[2] = e;
   }
 }
 
@@ -1470,14 +1470,14 @@ static void lineart_geometry_object_load(Depsgraph *dg,
   BMFace *f;
   BMEdge *e;
   BMLoop *loop;
-  LineartLine *rl;
+  LineartEdge *la_e;
   LineartTriangle *rt;
   LineartTriangleAdjacent *orta;
   double new_mvp[4][4], new_mv[4][4], normal[4][4];
   float imat[4][4];
   LineartElementLinkNode *reln;
   LineartVert *orv;
-  LineartLine *orl;
+  LineartEdge *o_la_e;
   LineartTriangle *ort;
   Object *orig_ob;
   int CanFindFreestyle = 0;
@@ -1653,7 +1653,7 @@ static void lineart_geometry_object_load(Depsgraph *dg,
 
     /* Use BM_ELEM_TAG in f->head.hflag to store needed faces in the first iteration. */
 
-    int allocate_rl = 0;
+    int allocate_la_e = 0;
     for (i = 0; i < bm->totedge; i++) {
       e = BM_edge_at_index(bm, i);
 
@@ -1662,7 +1662,7 @@ static void lineart_geometry_object_load(Depsgraph *dg,
           rb, e, ort, orv, use_crease, ob->type == OB_FONT, CanFindFreestyle, bm);
       if (eflag) {
         /* Only allocate for feature lines (instead of all lines) to save memory. */
-        allocate_rl++;
+        allocate_la_e++;
       }
       /* Here we just use bm's flag for when loading actual lines, then we don't need to call
        * lineart_identify_feature_line() again, e->head.hflag deleted after loading anyway. Always
@@ -1670,13 +1670,13 @@ static void lineart_geometry_object_load(Depsgraph *dg,
       e->head.hflag = eflag;
     }
 
-    orl = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartLine) * allocate_rl);
+    o_la_e = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartEdge) * allocate_la_e);
     reln = lineart_list_append_pointer_pool_sized(
-        &rb->line_buffer_pointers, &rb->render_data_pool, orl, sizeof(LineartElementLinkNode));
-    reln->element_count = allocate_rl;
+        &rb->line_buffer_pointers, &rb->render_data_pool, o_la_e, sizeof(LineartElementLinkNode));
+    reln->element_count = allocate_la_e;
     reln->object_ref = orig_ob;
 
-    rl = orl;
+    la_e = o_la_e;
     for (i = 0; i < bm->totedge; i++) {
       e = BM_edge_at_index(bm, i);
 
@@ -1685,32 +1685,32 @@ static void lineart_geometry_object_load(Depsgraph *dg,
         continue;
       }
 
-      rl->l = &orv[BM_elem_index_get(e->v1)];
-      rl->r = &orv[BM_elem_index_get(e->v2)];
-      rl->l_obindex = rl->l->index - global_i;
-      rl->r_obindex = rl->r->index - global_i;
+      la_e->v1 = &orv[BM_elem_index_get(e->v1)];
+      la_e->v2 = &orv[BM_elem_index_get(e->v2)];
+      la_e->v1_obindex = la_e->v1->index - global_i;
+      la_e->v2_obindex = la_e->v2->index - global_i;
       if (e->l) {
         int findex = BM_elem_index_get(e->l->f);
-        rl->tl = lineart_triangle_from_index(rb, ort, findex);
-        lineart_triangle_adjacent_assign(rl->tl, &orta[findex], rl);
+        la_e->t1 = lineart_triangle_from_index(rb, ort, findex);
+        lineart_triangle_adjacent_assign(la_e->t1, &orta[findex], la_e);
         if (e->l->radial_next && e->l->radial_next != e->l) {
           findex = BM_elem_index_get(e->l->radial_next->f);
-          rl->tr = lineart_triangle_from_index(rb, ort, findex);
-          lineart_triangle_adjacent_assign(rl->tr, &orta[findex], rl);
+          la_e->t2 = lineart_triangle_from_index(rb, ort, findex);
+          lineart_triangle_adjacent_assign(la_e->t2, &orta[findex], la_e);
         }
       }
-      rl->flags = e->head.hflag;
-      rl->object_ref = orig_ob;
+      la_e->flags = e->head.hflag;
+      la_e->object_ref = orig_ob;
 
       LineartLineSegment *rls = lineart_mem_aquire(&rb->render_data_pool,
                                                    sizeof(LineartLineSegment));
-      BLI_addtail(&rl->segments, rls);
+      BLI_addtail(&la_e->segments, rls);
       if (usage == OBJECT_LRT_INHERENT || usage == OBJECT_LRT_INCLUDE ||
           usage == OBJECT_LRT_NO_INTERSECTION) {
-        lineart_add_line_to_list(rb, rl);
+        lineart_add_edge_to_list(rb, la_e);
       }
 
-      rl++;
+      la_e++;
     }
 
     LRT_MESH_FINISH
@@ -1846,11 +1846,11 @@ static bool lineart_triangle_get_other_verts(const LineartTriangle *rt,
 }
 
 static bool lineart_edge_from_triangle(const LineartTriangle *rt,
-                                       const LineartLine *rl,
+                                       const LineartEdge *e,
                                        bool allow_overlapping_edges)
 {
   /* Normally we just determine from the pointer address. */
-  if (rl->tl == rt || rl->tr == rt) {
+  if (e->t1 == rt || e->t2 == rt) {
     return true;
   }
   /* If allows overlapping, then we compare the vertex coordinates one by one to determine if one
@@ -1863,10 +1863,10 @@ static bool lineart_edge_from_triangle(const LineartTriangle *rt,
    (LRT_DOUBLE_CLOSE_ENOUGH(rt->v[i]->gloc[0], pt->gloc[0]) && \
     LRT_DOUBLE_CLOSE_ENOUGH(rt->v[i]->gloc[1], pt->gloc[1]) && \
     LRT_DOUBLE_CLOSE_ENOUGH(rt->v[i]->gloc[2], pt->gloc[2])))
-    if ((LRT_TRI_SAME_POINT(rt, 0, rl->l) || LRT_TRI_SAME_POINT(rt, 1, rl->l) ||
-         LRT_TRI_SAME_POINT(rt, 2, rl->l)) &&
-        (LRT_TRI_SAME_POINT(rt, 0, rl->r) || LRT_TRI_SAME_POINT(rt, 1, rl->r) ||
-         LRT_TRI_SAME_POINT(rt, 2, rl->r))) {
+    if ((LRT_TRI_SAME_POINT(rt, 0, e->v1) || LRT_TRI_SAME_POINT(rt, 1, e->v1) ||
+         LRT_TRI_SAME_POINT(rt, 2, e->v1)) &&
+        (LRT_TRI_SAME_POINT(rt, 0, e->v2) || LRT_TRI_SAME_POINT(rt, 1, e->v2) ||
+         LRT_TRI_SAME_POINT(rt, 2, e->v2))) {
       return true;
     }
 #undef LRT_TRI_SAME_POINT
@@ -1904,11 +1904,11 @@ static bool lineart_edge_from_triangle(const LineartTriangle *rt,
 /* This is the main function to calculate
  * the occlusion status between 1(one) triangle and 1(one) line.
  * if returns true, then from/to will carry the occludded segments
- * in ratio from rl->l to rl->r. The line is later cut with these two values.
+ * in ratio from e->v1 to e->v2. The line is later cut with these two values.
  */
-static bool lineart_triangle_line_image_space_occlusion(SpinLock *UNUSED(spl),
+static bool lineart_triangle_edge_image_space_occlusion(SpinLock *UNUSED(spl),
                                                         const LineartTriangle *rt,
-                                                        const LineartLine *rl,
+                                                        const LineartEdge *e,
                                                         const double *override_camera_loc,
                                                         const bool override_cam_is_persp,
                                                         const bool allow_overlapping_edges,
@@ -1934,7 +1934,7 @@ static bool lineart_triangle_line_image_space_occlusion(SpinLock *UNUSED(spl),
   double gloc[4], trans[4];
   double cut = -1;
 
-  double *LFBC = rl->l->fbcoord, *RFBC = rl->r->fbcoord, *FBC0 = rt->v[0]->fbcoord,
+  double *LFBC = e->v1->fbcoord, *RFBC = e->v2->fbcoord, *FBC0 = rt->v[0]->fbcoord,
          *FBC1 = rt->v[1]->fbcoord, *FBC2 = rt->v[2]->fbcoord;
 
   /* Overlapping not possible, return early. */
@@ -1947,7 +1947,7 @@ static bool lineart_triangle_line_image_space_occlusion(SpinLock *UNUSED(spl),
   }
 
   /* If the the line is one of the edge in the triangle, then it's not occludded. */
-  if (lineart_edge_from_triangle(rt, rl, allow_overlapping_edges)) {
+  if (lineart_edge_from_triangle(rt, e, allow_overlapping_edges)) {
     return false;
   }
 
@@ -1959,8 +1959,8 @@ static bool lineart_triangle_line_image_space_occlusion(SpinLock *UNUSED(spl),
   /* Sort the intersection distance. */
   INTERSECT_SORT_MIN_TO_MAX_3(is[0], is[1], is[2], order);
 
-  sub_v3_v3v3_db(Lv, rl->l->gloc, rt->v[0]->gloc);
-  sub_v3_v3v3_db(Rv, rl->r->gloc, rt->v[0]->gloc);
+  sub_v3_v3v3_db(Lv, e->v1->gloc, rt->v[0]->gloc);
+  sub_v3_v3v3_db(Rv, e->v2->gloc, rt->v[0]->gloc);
 
   copy_v3_v3_db(Cv, camera_dir);
 
@@ -2017,22 +2017,22 @@ static bool lineart_triangle_line_image_space_occlusion(SpinLock *UNUSED(spl),
 
   /* Transform the cut from geometry space to image space. */
   if (override_cam_is_persp) {
-    interp_v3_v3v3_db(gloc, rl->l->gloc, rl->r->gloc, cut);
+    interp_v3_v3v3_db(gloc, e->v1->gloc, e->v2->gloc, cut);
     mul_v4_m4v3_db(trans, vp, gloc);
     mul_v3db_db(trans, (1 / trans[3]));
   }
   else {
-    interp_v3_v3v3_db(trans, rl->l->fbcoord, rl->r->fbcoord, cut);
+    interp_v3_v3v3_db(trans, e->v1->fbcoord, e->v2->fbcoord, cut);
   }
   trans[0] -= cam_shift_x * 2;
   trans[1] -= cam_shift_y * 2;
 
   /* To accomodate k=0 and k=inf (vertical) lines. here the cut is in image space. */
-  if (fabs(rl->l->fbcoord[0] - rl->r->fbcoord[0]) > fabs(rl->l->fbcoord[1] - rl->r->fbcoord[1])) {
-    cut = ratiod(rl->l->fbcoord[0], rl->r->fbcoord[0], trans[0]);
+  if (fabs(e->v1->fbcoord[0] - e->v2->fbcoord[0]) > fabs(e->v1->fbcoord[1] - e->v2->fbcoord[1])) {
+    cut = ratiod(e->v1->fbcoord[0], e->v2->fbcoord[0], trans[0]);
   }
   else {
-    cut = ratiod(rl->l->fbcoord[1], rl->r->fbcoord[1], trans[1]);
+    cut = ratiod(e->v1->fbcoord[1], e->v2->fbcoord[1], trans[1]);
   }
 
   /* Determine the pair of edges that the line has crossed. */
@@ -2295,13 +2295,13 @@ static LineartVert *lineart_triangle_2v_intersection_test(LineartRenderBuffer *r
 }
 
 /* Test if two triangles intersect. Generates one intersection line if the check succeeds */
-static LineartLine *lineart_triangle_intersect(LineartRenderBuffer *rb,
+static LineartEdge *lineart_triangle_intersect(LineartRenderBuffer *rb,
                                                LineartTriangle *rt,
                                                LineartTriangle *testing)
 {
-  LineartVert *l = 0, *r = 0;
-  LineartVert **next = &l;
-  LineartLine *result;
+  LineartVert *v1 = 0, *v2 = 0;
+  LineartVert **next = &v1;
+  LineartEdge *result;
   LineartVert *E0T = 0;
   LineartVert *E1T = 0;
   LineartVert *E2T = 0;
@@ -2324,18 +2324,18 @@ static LineartLine *lineart_triangle_intersect(LineartRenderBuffer *rb,
     LineartVert *new_share;
     lineart_triangle_get_other_verts(rt, share, &sv1, &sv2);
 
-    l = new_share = lineart_mem_aquire(&rb->render_data_pool, (sizeof(LineartVertIntersection)));
+    v1 = new_share = lineart_mem_aquire(&rb->render_data_pool, (sizeof(LineartVertIntersection)));
 
     new_share->flag = LRT_VERT_HAS_INTERSECTION_DATA;
 
     copy_v3_v3_db(new_share->gloc, share->gloc);
 
-    r = lineart_triangle_2v_intersection_test(rb, sv1, sv2, rt, testing, 0);
+    v2 = lineart_triangle_2v_intersection_test(rb, sv1, sv2, rt, testing, 0);
 
-    if (r == NULL) {
+    if (v2 == NULL) {
       lineart_triangle_get_other_verts(testing, share, &sv1, &sv2);
-      r = lineart_triangle_2v_intersection_test(rb, sv1, sv2, testing, rt, 0);
-      if (r == NULL) {
+      v2 = lineart_triangle_2v_intersection_test(rb, sv1, sv2, testing, rt, 0);
+      if (v2 == NULL) {
         return 0;
       }
       lineart_prepend_pool(&testing->intersecting_verts, &rb->render_data_pool, new_share);
@@ -2351,49 +2351,49 @@ static LineartLine *lineart_triangle_intersect(LineartRenderBuffer *rb,
     if (E0T && (!(*next))) {
       (*next) = E0T;
       lineart_vert_set_intersection_2v((*next), rt->v[0], rt->v[1]);
-      next = &r;
+      next = &v2;
     }
-    E1T = lineart_triangle_2v_intersection_test(rb, rt->v[1], rt->v[2], rt, testing, l);
+    E1T = lineart_triangle_2v_intersection_test(rb, rt->v[1], rt->v[2], rt, testing, v1);
     if (E1T && (!(*next))) {
       (*next) = E1T;
       lineart_vert_set_intersection_2v((*next), rt->v[1], rt->v[2]);
-      next = &r;
+      next = &v2;
     }
     if (!(*next)) {
-      E2T = lineart_triangle_2v_intersection_test(rb, rt->v[2], rt->v[0], rt, testing, l);
+      E2T = lineart_triangle_2v_intersection_test(rb, rt->v[2], rt->v[0], rt, testing, v1);
     }
     if (E2T && (!(*next))) {
       (*next) = E2T;
       lineart_vert_set_intersection_2v((*next), rt->v[2], rt->v[0]);
-      next = &r;
+      next = &v2;
     }
 
     if (!(*next)) {
       TE0 = lineart_triangle_2v_intersection_test(
-          rb, testing->v[0], testing->v[1], testing, rt, l);
+          rb, testing->v[0], testing->v[1], testing, rt, v1);
     }
     if (TE0 && (!(*next))) {
       (*next) = TE0;
       lineart_vert_set_intersection_2v((*next), testing->v[0], testing->v[1]);
-      next = &r;
+      next = &v2;
     }
     if (!(*next)) {
       TE1 = lineart_triangle_2v_intersection_test(
-          rb, testing->v[1], testing->v[2], testing, rt, l);
+          rb, testing->v[1], testing->v[2], testing, rt, v1);
     }
     if (TE1 && (!(*next))) {
       (*next) = TE1;
       lineart_vert_set_intersection_2v((*next), testing->v[1], testing->v[2]);
-      next = &r;
+      next = &v2;
     }
     if (!(*next)) {
       TE2 = lineart_triangle_2v_intersection_test(
-          rb, testing->v[2], testing->v[0], testing, rt, l);
+          rb, testing->v[2], testing->v[0], testing, rt, v1);
     }
     if (TE2 && (!(*next))) {
       (*next) = TE2;
       lineart_vert_set_intersection_2v((*next), testing->v[2], testing->v[0]);
-      next = &r;
+      next = &v2;
     }
 
     if (!(*next)) {
@@ -2403,39 +2403,39 @@ static LineartLine *lineart_triangle_intersect(LineartRenderBuffer *rb,
 
   /* The intersection line has been generated only in geometry space, so we need to transform them
    * as well. */
-  mul_v4_m4v3_db(l->fbcoord, rb->view_projection, l->gloc);
-  mul_v4_m4v3_db(r->fbcoord, rb->view_projection, r->gloc);
-  mul_v3db_db(l->fbcoord, (1 / l->fbcoord[3]));
-  mul_v3db_db(r->fbcoord, (1 / r->fbcoord[3]));
+  mul_v4_m4v3_db(v1->fbcoord, rb->view_projection, v1->gloc);
+  mul_v4_m4v3_db(v2->fbcoord, rb->view_projection, v2->gloc);
+  mul_v3db_db(v1->fbcoord, (1 / v1->fbcoord[3]));
+  mul_v3db_db(v2->fbcoord, (1 / v2->fbcoord[3]));
 
-  l->fbcoord[0] -= rb->shift_x * 2;
-  l->fbcoord[1] -= rb->shift_y * 2;
-  r->fbcoord[0] -= rb->shift_x * 2;
-  r->fbcoord[1] -= rb->shift_y * 2;
+  v1->fbcoord[0] -= rb->shift_x * 2;
+  v1->fbcoord[1] -= rb->shift_y * 2;
+  v2->fbcoord[0] -= rb->shift_x * 2;
+  v2->fbcoord[1] -= rb->shift_y * 2;
 
   /* This z transformation is not the same as the rest of the part, because the data don't go
    * through normal perspective division calls in the pipeline, but this way the 3D result and
    * occlution on the generated line is correct, and we don't really use 2D for viewport stroke
    * generation anyway.*/
-  l->fbcoord[2] = ZMin * ZMax / (ZMax - fabs(l->fbcoord[2]) * (ZMax - ZMin));
-  r->fbcoord[2] = ZMin * ZMax / (ZMax - fabs(r->fbcoord[2]) * (ZMax - ZMin));
+  v1->fbcoord[2] = ZMin * ZMax / (ZMax - fabs(v1->fbcoord[2]) * (ZMax - ZMin));
+  v2->fbcoord[2] = ZMin * ZMax / (ZMax - fabs(v2->fbcoord[2]) * (ZMax - ZMin));
 
-  ((LineartVertIntersection *)l)->intersecting_with = rt;
-  ((LineartVertIntersection *)r)->intersecting_with = testing;
+  ((LineartVertIntersection *)v1)->intersecting_with = rt;
+  ((LineartVertIntersection *)v2)->intersecting_with = testing;
 
-  result = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartLine));
-  result->l = l;
-  result->r = r;
-  result->tl = rt;
-  result->tr = testing;
+  result = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartEdge));
+  result->v1 = v1;
+  result->v2 = v2;
+  result->t1 = rt;
+  result->t2 = testing;
 
   LineartLineSegment *rls = lineart_mem_aquire(&rb->render_data_pool, sizeof(LineartLineSegment));
   BLI_addtail(&result->segments, rls);
   /* Don't need to OR flags right now, just a type mark. */
   result->flags = LRT_EDGE_FLAG_INTERSECTION;
-  lineart_prepend_line_direct(&rb->intersection_lines, result);
+  lineart_prepend_edge_direct(&rb->intersection_lines, result);
   int r1, r2, c1, c2, row, col;
-  if (lineart_get_line_bounding_areas(rb, result, &r1, &r2, &c1, &c2)) {
+  if (lineart_get_edge_bounding_areas(rb, result, &r1, &r2, &c1, &c2)) {
     for (row = r1; row != r2 + 1; row++) {
       for (col = c1; col != c2 + 1; col++) {
         lineart_bounding_area_link_line(
@@ -2476,7 +2476,7 @@ static void lineart_triangle_intersect_in_bounding_area(LineartRenderBuffer *rb,
     testing_triangle = lip->data;
     rtt = (LineartTriangleThread *)testing_triangle;
 
-    if (testing_triangle == rt || rtt->testing[0] == (LineartLine *)rt ||
+    if (testing_triangle == rt || rtt->testing_e[0] == (LineartEdge *)rt ||
         (testing_triangle->flags & LRT_TRIANGLE_NO_INTERSECTION) ||
         ((testing_triangle->flags & LRT_TRIANGLE_INTERSECTION_ONLY) &&
          (rt->flags & LRT_TRIANGLE_INTERSECTION_ONLY)) ||
@@ -2484,7 +2484,7 @@ static void lineart_triangle_intersect_in_bounding_area(LineartRenderBuffer *rb,
       continue;
     }
 
-    rtt->testing[0] = (LineartLine *)rt;
+    rtt->testing_e[0] = (LineartEdge *)rt;
     double *RG0 = testing_triangle->v[0]->gloc, *RG1 = testing_triangle->v[1]->gloc,
            *RG2 = testing_triangle->v[2]->gloc;
 
@@ -2619,11 +2619,11 @@ static LineartRenderBuffer *lineart_create_render_buffer(Scene *scene,
   /* See lineart_edge_from_triangle() for how this option may impact performance. */
   rb->allow_overlapping_edges = (lmd->calculation_flags & LRT_ALLOW_OVERLAPPING_EDGES) != 0;
 
-  rb->use_contour = (lmd->line_types & LRT_EDGE_FLAG_CONTOUR) != 0;
-  rb->use_crease = (lmd->line_types & LRT_EDGE_FLAG_CREASE) != 0;
-  rb->use_material = (lmd->line_types & LRT_EDGE_FLAG_MATERIAL) != 0;
-  rb->use_edge_marks = (lmd->line_types & LRT_EDGE_FLAG_EDGE_MARK) != 0;
-  rb->use_intersections = (lmd->line_types & LRT_EDGE_FLAG_INTERSECTION) != 0;
+  rb->use_contour = (lmd->edge_types & LRT_EDGE_FLAG_CONTOUR) != 0;
+  rb->use_crease = (lmd->edge_types & LRT_EDGE_FLAG_CREASE) != 0;
+  rb->use_material = (lmd->edge_types & LRT_EDGE_FLAG_MATERIAL) != 0;
+  rb->use_edge_marks = (lmd->edge_types & LRT_EDGE_FLAG_EDGE_MARK) != 0;
+  rb->use_intersections = (lmd->edge_types & LRT_EDGE_FLAG_INTERSECTION) != 0;
 
   BLI_spin_init(&rb->lock_task);
   BLI_spin_init(&rb->lock_cuts);
@@ -2637,7 +2637,7 @@ static int lineart_triangle_size_get(const Scene *scene, LineartRenderBuffer *rb
   if (rb->thread_count == 0) {
     rb->thread_count = BKE_render_num_threads(&scene->r);
   }
-  return sizeof(LineartTriangle) + (sizeof(LineartLine *) * (rb->thread_count));
+  return sizeof(LineartTriangle) + (sizeof(LineartEdge *) * (rb->thread_count));
 }
 
 static void lineart_main_bounding_area_make_initial(LineartRenderBuffer *rb)
@@ -2854,7 +2854,7 @@ static void lineart_bounding_area_split(LineartRenderBuffer *rb,
   LineartBoundingArea *ba = lineart_mem_aquire(&rb->render_data_pool,
                                                sizeof(LineartBoundingArea) * 4);
   LineartTriangle *rt;
-  LineartLine *rl;
+  LineartEdge *e;
 
   ba[0].l = root->cx;
   ba[0].r = root->r;
@@ -2909,8 +2909,8 @@ static void lineart_bounding_area_split(LineartRenderBuffer *rb,
     }
   }
 
-  while ((rl = lineart_list_pop_pointer_no_free(&root->linked_lines)) != NULL) {
-    lineart_bounding_area_link_line(rb, root, rl);
+  while ((e = lineart_list_pop_pointer_no_free(&root->linked_lines)) != NULL) {
+    lineart_bounding_area_link_line(rb, root, e);
   }
 
   rb->bounding_area_count += 3;
@@ -3052,27 +3052,27 @@ static void lineart_bounding_area_link_triangle(LineartRenderBuffer *rb,
 
 static void lineart_bounding_area_link_line(LineartRenderBuffer *rb,
                                             LineartBoundingArea *root_ba,
-                                            LineartLine *rl)
+                                            LineartEdge *e)
 {
   if (root_ba->child == NULL) {
-    lineart_list_append_pointer_pool(&root_ba->linked_lines, &rb->render_data_pool, rl);
+    lineart_list_append_pointer_pool(&root_ba->linked_lines, &rb->render_data_pool, e);
   }
   else {
     if (lineart_bounding_area_line_intersect(
-            rb, rl->l->fbcoord, rl->r->fbcoord, &root_ba->child[0])) {
-      lineart_bounding_area_link_line(rb, &root_ba->child[0], rl);
+            rb, e->v1->fbcoord, e->v2->fbcoord, &root_ba->child[0])) {
+      lineart_bounding_area_link_line(rb, &root_ba->child[0], e);
     }
     if (lineart_bounding_area_line_intersect(
-            rb, rl->l->fbcoord, rl->r->fbcoord, &root_ba->child[1])) {
-      lineart_bounding_area_link_line(rb, &root_ba->child[1], rl);
+            rb, e->v1->fbcoord, e->v2->fbcoord, &root_ba->child[1])) {
+      lineart_bounding_area_link_line(rb, &root_ba->child[1], e);
     }
     if (lineart_bounding_area_line_intersect(
-            rb, rl->l->fbcoord, rl->r->fbcoord, &root_ba->child[2])) {
-      lineart_bounding_area_link_line(rb, &root_ba->child[2], rl);
+            rb, e->v1->fbcoord, e->v2->fbcoord, &root_ba->child[2])) {
+      lineart_bounding_area_link_line(rb, &root_ba->child[2], e);
     }
     if (lineart_bounding_area_line_intersect(
-            rb, rl->l->fbcoord, rl->r->fbcoord, &root_ba->child[3])) {
-      lineart_bounding_area_link_line(rb, &root_ba->child[3], rl);
+            rb, e->v1->fbcoord, e->v2->fbcoord, &root_ba->child[3])) {
+      lineart_bounding_area_link_line(rb, &root_ba->child[3], e);
     }
   }
 }
@@ -3083,11 +3083,11 @@ static void lineart_main_link_lines(LineartRenderBuffer *rb)
   LRT_ITER_ALL_LINES_BEGIN
   {
     int r1, r2, c1, c2, row, col;
-    if (lineart_get_line_bounding_areas(rb, rl, &r1, &r2, &c1, &c2)) {
+    if (lineart_get_edge_bounding_areas(rb, e, &r1, &r2, &c1, &c2)) {
       for (row = r1; row != r2 + 1; row++) {
         for (col = c1; col != c2 + 1; col++) {
           lineart_bounding_area_link_line(
-              rb, &rb->initial_bounding_areas[row * LRT_BA_ROWS + col], rl);
+              rb, &rb->initial_bounding_areas[row * LRT_BA_ROWS + col], e);
         }
       }
     }
@@ -3139,8 +3139,8 @@ static bool lineart_get_triangle_bounding_areas(LineartRenderBuffer *rb,
   return true;
 }
 
-static bool lineart_get_line_bounding_areas(LineartRenderBuffer *rb,
-                                            LineartLine *rl,
+static bool lineart_get_edge_bounding_areas(LineartRenderBuffer *rb,
+                                            LineartEdge *e,
                                             int *rowbegin,
                                             int *rowend,
                                             int *colbegin,
@@ -3149,18 +3149,18 @@ static bool lineart_get_line_bounding_areas(LineartRenderBuffer *rb,
   double sp_w = rb->width_per_tile, sp_h = rb->height_per_tile;
   double b[4];
 
-  if (!rl->l || !rl->r) {
+  if (!e->v1 || !e->v2) {
     return false;
   }
 
-  if (rl->l->fbcoord[0] != rl->l->fbcoord[0] || rl->r->fbcoord[0] != rl->r->fbcoord[0]) {
+  if (e->v1->fbcoord[0] != e->v1->fbcoord[0] || e->v2->fbcoord[0] != e->v2->fbcoord[0]) {
     return false;
   }
 
-  b[0] = MIN2(rl->l->fbcoord[0], rl->r->fbcoord[0]);
-  b[1] = MAX2(rl->l->fbcoord[0], rl->r->fbcoord[0]);
-  b[2] = MIN2(rl->l->fbcoord[1], rl->r->fbcoord[1]);
-  b[3] = MAX2(rl->l->fbcoord[1], rl->r->fbcoord[1]);
+  b[0] = MIN2(e->v1->fbcoord[0], e->v2->fbcoord[0]);
+  b[1] = MAX2(e->v1->fbcoord[0], e->v2->fbcoord[0]);
+  b[2] = MIN2(e->v1->fbcoord[1], e->v2->fbcoord[1]);
+  b[3] = MAX2(e->v1->fbcoord[1], e->v2->fbcoord[1]);
 
   if (b[0] > 1 || b[1] < -1 || b[2] > 1 || b[3] < -1) {
     return false;
@@ -3305,12 +3305,12 @@ static void lineart_main_add_triangles(LineartRenderBuffer *rb)
   }
 }
 
-/* This function gets the tile for the point rl->l, and later use lineart_bounding_area_next() to
+/* This function gets the tile for the point e->v1, and later use lineart_bounding_area_next() to
  * get next along the way. */
-static LineartBoundingArea *lineart_line_first_bounding_area(LineartRenderBuffer *rb,
-                                                             LineartLine *rl)
+static LineartBoundingArea *lineart_edge_first_bounding_area(LineartRenderBuffer *rb,
+                                                             LineartEdge *e)
 {
-  double data[2] = {rl->l->fbcoord[0], rl->l->fbcoord[1]};
+  double data[2] = {e->v1->fbcoord[0], e->v1->fbcoord[1]};
   double LU[2] = {-1, 1}, RU[2] = {1, 1}, LB[2] = {-1, -1}, RB[2] = {1, -1};
   double r = 1, sr = 1;
 
@@ -3318,23 +3318,23 @@ static LineartBoundingArea *lineart_line_first_bounding_area(LineartRenderBuffer
     return lineart_get_bounding_area(rb, data[0], data[1]);
   }
 
-  if (lineart_LineIntersectTest2d(rl->l->fbcoord, rl->r->fbcoord, LU, RU, &sr) && sr < r &&
+  if (lineart_LineIntersectTest2d(e->v1->fbcoord, e->v2->fbcoord, LU, RU, &sr) && sr < r &&
       sr > 0) {
     r = sr;
   }
-  if (lineart_LineIntersectTest2d(rl->l->fbcoord, rl->r->fbcoord, LB, RB, &sr) && sr < r &&
+  if (lineart_LineIntersectTest2d(e->v1->fbcoord, e->v2->fbcoord, LB, RB, &sr) && sr < r &&
       sr > 0) {
     r = sr;
   }
-  if (lineart_LineIntersectTest2d(rl->l->fbcoord, rl->r->fbcoord, LB, LU, &sr) && sr < r &&
+  if (lineart_LineIntersectTest2d(e->v1->fbcoord, e->v2->fbcoord, LB, LU, &sr) && sr < r &&
       sr > 0) {
     r = sr;
   }
-  if (lineart_LineIntersectTest2d(rl->l->fbcoord, rl->r->fbcoord, RB, RU, &sr) && sr < r &&
+  if (lineart_LineIntersectTest2d(e->v1->fbcoord, e->v2->fbcoord, RB, RU, &sr) && sr < r &&
       sr > 0) {
     r = sr;
   }
-  interp_v2_v2v2_db(data, rl->l->fbcoord, rl->r->fbcoord, r);
+  interp_v2_v2v2_db(data, e->v1->fbcoord, e->v2->fbcoord, r);
 
   return lineart_get_bounding_area(rb, data[0], data[1]);
 }
@@ -3342,7 +3342,7 @@ static LineartBoundingArea *lineart_line_first_bounding_area(LineartRenderBuffer
 /* This march along one render line in image space and
  * get the next bounding area the line is crossing. */
 static LineartBoundingArea *lineart_bounding_area_next(LineartBoundingArea *this,
-                                                       LineartLine *rl,
+                                                       LineartEdge *e,
                                                        double x,
                                                        double y,
                                                        double k,
@@ -3364,8 +3364,8 @@ static LineartBoundingArea *lineart_bounding_area_next(LineartBoundingArea *this
     if (positive_y > 0) {
       uy = this->u;
       ux = x + (uy - y) / k;
-      r1 = ratiod(rl->l->fbcoord[0], rl->r->fbcoord[0], rx);
-      r2 = ratiod(rl->l->fbcoord[0], rl->r->fbcoord[0], ux);
+      r1 = ratiod(e->v1->fbcoord[0], e->v2->fbcoord[0], rx);
+      r2 = ratiod(e->v1->fbcoord[0], e->v2->fbcoord[0], ux);
       if (MIN2(r1, r2) > 1) {
         return 0;
       }
@@ -3397,8 +3397,8 @@ static LineartBoundingArea *lineart_bounding_area_next(LineartBoundingArea *this
     else if (positive_y < 0) {
       by = this->b;
       bx = x + (by - y) / k;
-      r1 = ratiod(rl->l->fbcoord[0], rl->r->fbcoord[0], rx);
-      r2 = ratiod(rl->l->fbcoord[0], rl->r->fbcoord[0], bx);
+      r1 = ratiod(e->v1->fbcoord[0], e->v2->fbcoord[0], rx);
+      r2 = ratiod(e->v1->fbcoord[0], e->v2->fbcoord[0], bx);
       if (MIN2(r1, r2) > 1) {
         return 0;
       }
@@ -3425,7 +3425,7 @@ static LineartBoundingArea *lineart_bounding_area_next(LineartBoundingArea *this
     }
     /* If the line is compeletely horizontal, in which Y diffence == 0. */
     else {
-      r1 = ratiod(rl->l->fbcoord[0], rl->r->fbcoord[0], this->r);
+      r1 = ratiod(e->v1->fbcoord[0], e->v2->fbcoord[0], this->r);
       if (r1 > 1) {
         return 0;
       }
@@ -3449,8 +3449,8 @@ static LineartBoundingArea *lineart_bounding_area_next(LineartBoundingArea *this
     if (positive_y > 0) {
       uy = this->u;
       ux = x + (uy - y) / k;
-      r1 = ratiod(rl->l->fbcoord[0], rl->r->fbcoord[0], lx);
-      r2 = ratiod(rl->l->fbcoord[0], rl->r->fbcoord[0], ux);
+      r1 = ratiod(e->v1->fbcoord[0], e->v2->fbcoord[0], lx);
+      r2 = ratiod(e->v1->fbcoord[0], e->v2->fbcoord[0], ux);
       if (MIN2(r1, r2) > 1) {
         return 0;
       }
@@ -3480,8 +3480,8 @@ static LineartBoundingArea *lineart_bounding_area_next(LineartBoundingArea *this
     else if (positive_y < 0) {
       by = this->b;
       bx = x + (by - y) / k;
-      r1 = ratiod(rl->l->fbcoord[0], rl->r->fbcoord[0], lx);
-      r2 = ratiod(rl->l->fbcoord[0], rl->r->fbcoord[0], bx);
+      r1 = ratiod(e->v1->fbcoord[0], e->v2->fbcoord[0], lx);
+      r2 = ratiod(e->v1->fbcoord[0], e->v2->fbcoord[0], bx);
       if (MIN2(r1, r2) > 1) {
         return 0;
       }
@@ -3508,7 +3508,7 @@ static LineartBoundingArea *lineart_bounding_area_next(LineartBoundingArea *this
     }
     /* Again, horizontal. */
     else {
-      r1 = ratiod(rl->l->fbcoord[0], rl->r->fbcoord[0], this->l);
+      r1 = ratiod(e->v1->fbcoord[0], e->v2->fbcoord[0], this->l);
       if (r1 > 1) {
         return 0;
       }
@@ -3525,7 +3525,7 @@ static LineartBoundingArea *lineart_bounding_area_next(LineartBoundingArea *this
   /* If the line is completely vertical, hence X difference == 0. */
   else {
     if (positive_y > 0) {
-      r1 = ratiod(rl->l->fbcoord[1], rl->r->fbcoord[1], this->u);
+      r1 = ratiod(e->v1->fbcoord[1], e->v2->fbcoord[1], this->u);
       if (r1 > 1) {
         return 0;
       }
@@ -3539,7 +3539,7 @@ static LineartBoundingArea *lineart_bounding_area_next(LineartBoundingArea *this
       }
     }
     else if (positive_y < 0) {
-      r1 = ratiod(rl->l->fbcoord[1], rl->r->fbcoord[1], this->b);
+      r1 = ratiod(e->v1->fbcoord[1], e->v2->fbcoord[1], this->b);
       if (r1 > 1) {
         return 0;
       }
@@ -3632,7 +3632,7 @@ int MOD_lineart_compute_feature_lines(Depsgraph *depsgraph, LineartGpencilModifi
     MOD_lineart_chain_feature_lines(rb);
 
     /* We are unable to take care of occlusion if we only connect end points, so here we do a spit,
-     * where the splitting point could be any cut in rl->segments. */
+     * where the splitting point could be any cut in e->segments. */
     MOD_lineart_chain_split_for_fixed_occlusion(rb);
 
     /* Then we connect chains based on the _proximity_ of their end points in geometry or image
@@ -3674,7 +3674,7 @@ int MOD_lineart_compute_feature_lines(Depsgraph *depsgraph, LineartGpencilModifi
   return OPERATOR_FINISHED;
 }
 
-static int lineart_rb_line_types(LineartRenderBuffer *rb)
+static int lineart_rb_edge_types(LineartRenderBuffer *rb)
 {
   int types = 0;
   types |= rb->use_contour ? LRT_EDGE_FLAG_CONTOUR : 0;
@@ -3732,7 +3732,7 @@ static void lineart_gpencil_generate(LineartRenderBuffer *rb,
   float mat[4][4];
   unit_m4(mat);
 
-  int enabled_types = lineart_rb_line_types(rb);
+  int enabled_types = lineart_rb_edge_types(rb);
   bool invert_input = modifier_flags & LRT_GPENCIL_INVERT_SOURCE_VGROUP;
   bool match_output = modifier_flags & LRT_GPENCIL_MATCH_OUTPUT_VGROUP;
   bool preserve_weight = modifier_flags & LRT_GPENCIL_SOFT_SELECTION;
@@ -3867,7 +3867,7 @@ void MOD_lineart_gpencil_generate(LineartRenderBuffer *rb,
                                   int level_start,
                                   int level_end,
                                   int mat_nr,
-                                  short line_types,
+                                  short edge_types,
                                   unsigned char transparency_flags,
                                   unsigned char transparency_mask,
                                   short thickness,
@@ -3891,18 +3891,18 @@ void MOD_lineart_gpencil_generate(LineartRenderBuffer *rb,
     }
     source_object = (Object *)source_reference;
     /* Note that intersection lines will only be in collection. */
-    use_types = line_types & (~LRT_EDGE_FLAG_INTERSECTION);
+    use_types = edge_types & (~LRT_EDGE_FLAG_INTERSECTION);
   }
   else if (source_type == LRT_SOURCE_COLLECTION) {
     if (!source_reference) {
       return;
     }
     source_collection = (Collection *)source_reference;
-    use_types = line_types;
+    use_types = edge_types;
   }
   else {
     /* Whole scene. */
-    use_types = line_types;
+    use_types = edge_types;
   }
   float gp_obmat_inverse[4][4];
   invert_m4_m4(gp_obmat_inverse, ob->obmat);
diff --git a/source/blender/gpencil_modifiers/intern/lineart/lineart_intern.h b/source/blender/gpencil_modifiers/intern/lineart/lineart_intern.h
index 34f6e62546d..2c3130b46c9 100644
--- a/source/blender/gpencil_modifiers/intern/lineart/lineart_intern.h
+++ b/source/blender/gpencil_modifiers/intern/lineart/lineart_intern.h
@@ -35,7 +35,7 @@
 
 struct LineartStaticMemPool;
 struct LineartStaticMemPoolNode;
-struct LineartLine;
+struct LineartEdge;
 struct LineartRenderBuffer;
 
 void *lineart_list_append_pointer_pool(ListBase *h, struct LineartStaticMemPool *smp, void *data);
@@ -58,7 +58,7 @@ void *lineart_mem_aquire(struct LineartStaticMemPool *smp, size_t size);
 void *lineart_mem_aquire_thread(struct LineartStaticMemPool *smp, size_t size);
 void lineart_mem_destroy(struct LineartStaticMemPool *smp);
 
-void lineart_prepend_line_direct(struct LineartLine **first, void *node);
+void lineart_prepend_edge_direct(struct LineartEdge **first, void *node);
 void lineart_prepend_pool(LinkNode **first, struct LineartStaticMemPool *smp, void *link);
 
 void lineart_matrix_ortho_44d(double (*mProjection)[4],
@@ -76,13 +76,13 @@ int lineart_count_intersection_segment_count(struct LineartRenderBuffer *rb);
 void lineart_count_and_print_render_buffer_memory(struct LineartRenderBuffer *rb);
 
 #define LRT_ITER_ALL_LINES_BEGIN \
-  LineartLine *rl, *next_rl, **current_list; \
-  rl = rb->contours; \
-  for (current_list = &rb->contours; rl; rl = next_rl) { \
-    next_rl = rl->next;
+  LineartEdge *e, *next_e, **current_list; \
+  e = rb->contours; \
+  for (current_list = &rb->contours; e; e = next_e) { \
+    next_e = e->next;
 
 #define LRT_ITER_ALL_LINES_NEXT \
-  while (!next_rl) { \
+  while (!next_e) { \
     if (current_list == &rb->contours) { \
       current_list = &rb->crease_lines; \
     } \
@@ -98,7 +98,7 @@ void lineart_count_and_print_render_buffer_memory(struct LineartRenderBuffer *rb
     else { \
       break; \
     } \
-    next_rl = *current_list; \
+    next_e = *current_list; \
   }
 
 #define LRT_ITER_ALL_LINES_END \
diff --git a/source/blender/gpencil_modifiers/intern/lineart/lineart_ops.c b/source/blender/gpencil_modifiers/intern/lineart/lineart_ops.c
index 56490a84279..9d5d52b8388 100644
--- a/source/blender/gpencil_modifiers/intern/lineart/lineart_ops.c
+++ b/source/blender/gpencil_modifiers/intern/lineart/lineart_ops.c
@@ -105,7 +105,7 @@ static bool bake_strokes(Object *ob, Depsgraph *dg, GpencilModifierData *md, int
       lmd->level_start,
       lmd->use_multiple_levels ? lmd->level_end : lmd->level_start,
       lmd->target_material ? BKE_gpencil_object_material_index_get(ob, lmd->target_material) : 0,
-      lmd->line_types,
+      lmd->edge_types,
       lmd->transparency_flags,
       lmd->transparency_mask,
       lmd->thickness,
diff --git a/source/blender/gpencil_modifiers/intern/lineart/lineart_util.c b/source/blender/gpencil_modifiers/intern/lineart/lineart_util.c
index 8e8c39391c3..b38124fc7a5 100644
--- a/source/blender/gpencil_modifiers/intern/lineart/lineart_util.c
+++ b/source/blender/gpencil_modifiers/intern/lineart/lineart_util.c
@@ -130,11 +130,11 @@ void lineart_mem_destroy(LineartStaticMemPool *smp)
   }
 }
 
-void lineart_prepend_line_direct(LineartLine **first, void *node)
+void lineart_prepend_edge_direct(LineartEdge **first, void *node)
 {
-  LineartLine *ln = (LineartLine *)node;
-  ln->next = (*first);
-  (*first) = ln;
+  LineartEdge *e_n = (LineartEdge *)node;
+  e_n->next = (*first);
+  (*first) = e_n;
 }
 
 void lineart_prepend_pool(LinkNode **first, LineartStaticMemPool *smp, void *link)
@@ -215,7 +215,7 @@ void lineart_count_and_print_render_buffer_memory(LineartRenderBuffer *rb)
 
   LISTBASE_FOREACH (LineartElementLinkNode *, reln, &rb->line_buffer_pointers) {
     count_this++;
-    sum_this += reln->element_count * sizeof(LineartLine);
+    sum_this += reln->element_count * sizeof(LineartEdge);
   }
   printf("             allocated %lu edge blocks, total %lu Bytes.\n", count_this, sum_this);
   total += sum_this;