Cleanup: Line art naming changes.

Make variable naming consistent with struct names.

Reviewed By: Sebastian Parborg (zeddb)

Differential Revision: https://developer.blender.org/D11382

3 files changed, 760 insertions, 760 deletions

diff --git a/source/blender/gpencil_modifiers/intern/lineart/MOD_lineart.h b/source/blender/gpencil_modifiers/intern/lineart/MOD_lineart.h
index 44ff0616fe9..56b1ff87f0b 100644
--- a/source/blender/gpencil_modifiers/intern/lineart/MOD_lineart.h
+++ b/source/blender/gpencil_modifiers/intern/lineart/MOD_lineart.h
@@ -93,8 +93,8 @@ typedef struct LineartElementLinkNode {
   float crease_threshold;
 } LineartElementLinkNode;
 
-typedef struct LineartLineSegment {
-  struct LineartLineSegment *next, *prev;
+typedef struct LineartEdgeSegment {
+  struct LineartEdgeSegment *next, *prev;
   /** at==0: left  at==1: right  (this is in 2D projected space) */
   double at;
   /** Occlusion level after "at" point */
@@ -107,7 +107,7 @@ typedef struct LineartLineSegment {
    * enough for most cases.
    */
   unsigned char transparency_mask;
-} LineartLineSegment;
+} LineartEdgeSegment;
 
 typedef struct LineartVert {
   double gloc[3];
@@ -163,8 +163,8 @@ typedef struct LineartEdge {
   struct Object *object_ref;
 } LineartEdge;
 
-typedef struct LineartLineChain {
-  struct LineartLineChain *next, *prev;
+typedef struct LineartEdgeChain {
+  struct LineartEdgeChain *next, *prev;
   ListBase chain;
 
   /** Calculated before draw command. */
@@ -179,10 +179,10 @@ typedef struct LineartLineChain {
   unsigned char transparency_mask;
 
   struct Object *object_ref;
-} LineartLineChain;
+} LineartEdgeChain;
 
-typedef struct LineartLineChainItem {
-  struct LineartLineChainItem *next, *prev;
+typedef struct LineartEdgeChainItem {
+  struct LineartEdgeChainItem *next, *prev;
   /** Need z value for fading */
   float pos[3];
   /** For restoring position to 3d space */
@@ -192,12 +192,12 @@ typedef struct LineartLineChainItem {
   char occlusion;
   unsigned char transparency_mask;
   size_t index;
-} LineartLineChainItem;
+} LineartEdgeChainItem;
 
 typedef struct LineartChainRegisterEntry {
   struct LineartChainRegisterEntry *next, *prev;
-  LineartLineChain *rlc;
-  LineartLineChainItem *rlci;
+  LineartEdgeChain *ec;
+  LineartEdgeChainItem *eci;
   char picked;
 
   /* left/right mark.
@@ -390,7 +390,7 @@ typedef struct LineartBoundingArea {
   short triangle_count;
 
   ListBase linked_triangles;
-  ListBase linked_lines;
+  ListBase linked_edges;
 
   /** Reserved for image space reduction && multi-thread chaining. */
   ListBase linked_chains;
@@ -529,7 +529,7 @@ void MOD_lineart_chain_connect(LineartRenderBuffer *rb);
 void MOD_lineart_chain_discard_short(LineartRenderBuffer *rb, const float threshold);
 void MOD_lineart_chain_split_angle(LineartRenderBuffer *rb, float angle_threshold_rad);
 
-int MOD_lineart_chain_count(const LineartLineChain *rlc);
+int MOD_lineart_chain_count(const LineartEdgeChain *ec);
 void MOD_lineart_chain_clear_picked_flag(struct LineartRenderBuffer *rb);
 
 bool MOD_lineart_compute_feature_lines(struct Depsgraph *depsgraph,
@@ -565,6 +565,6 @@ void MOD_lineart_gpencil_generate(LineartRenderBuffer *rb,
                                   const char *vgname,
                                   int modifier_flags);
 
-float MOD_lineart_chain_compute_length(LineartLineChain *rlc);
+float MOD_lineart_chain_compute_length(LineartEdgeChain *ec);
 
 void ED_operatortypes_lineart(void);
diff --git a/source/blender/gpencil_modifiers/intern/lineart/lineart_chain.c b/source/blender/gpencil_modifiers/intern/lineart/lineart_chain.c
index 4ad8eed6ddd..c8e4e93843a 100644
--- a/source/blender/gpencil_modifiers/intern/lineart/lineart_chain.c
+++ b/source/blender/gpencil_modifiers/intern/lineart/lineart_chain.c
@@ -31,16 +31,16 @@
 
 #include <math.h>
 
-#define LRT_OTHER_RV(e, rv) ((rv) == (e)->v1 ? (e)->v2 : ((rv) == (e)->v2 ? (e)->v1 : NULL))
+#define LRT_OTHER_VERT(e, vt) ((vt) == (e)->v1 ? (e)->v2 : ((vt) == (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 LineartEdge *lineart_line_get_connected(LineartBoundingArea *ba,
-                                               LineartVert *rv,
-                                               LineartVert **new_rv,
+                                               LineartVert *vt,
+                                               LineartVert **new_vt,
                                                int match_flag)
 {
-  LISTBASE_FOREACH (LinkData *, lip, &ba->linked_lines) {
+  LISTBASE_FOREACH (LinkData *, lip, &ba->linked_edges) {
     LineartEdge *n_e = lip->data;
 
     if ((!(n_e->flags & LRT_EDGE_FLAG_ALL_TYPE)) || (n_e->flags & LRT_EDGE_FLAG_CHAIN_PICKED)) {
@@ -51,18 +51,18 @@ static LineartEdge *lineart_line_get_connected(LineartBoundingArea *ba,
       continue;
     }
 
-    *new_rv = LRT_OTHER_RV(n_e, rv);
-    if (*new_rv) {
+    *new_vt = LRT_OTHER_VERT(n_e, vt);
+    if (*new_vt) {
       return n_e;
     }
 
     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);
+      if (vt->fbcoord[0] == n_e->v1->fbcoord[0] && vt->fbcoord[1] == n_e->v1->fbcoord[1]) {
+        *new_vt = LRT_OTHER_VERT(n_e, n_e->v1);
         return n_e;
       }
-      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);
+      if (vt->fbcoord[0] == n_e->v2->fbcoord[0] && vt->fbcoord[1] == n_e->v2->fbcoord[1]) {
+        *new_vt = LRT_OTHER_VERT(n_e, n_e->v2);
         return n_e;
       }
     }
@@ -71,33 +71,33 @@ static LineartEdge *lineart_line_get_connected(LineartBoundingArea *ba,
   return NULL;
 }
 
-static LineartLineChain *lineart_chain_create(LineartRenderBuffer *rb)
+static LineartEdgeChain *lineart_chain_create(LineartRenderBuffer *rb)
 {
-  LineartLineChain *rlc;
-  rlc = lineart_mem_acquire(&rb->render_data_pool, sizeof(LineartLineChain));
+  LineartEdgeChain *ec;
+  ec = lineart_mem_acquire(&rb->render_data_pool, sizeof(LineartEdgeChain));
 
-  BLI_addtail(&rb->chains, rlc);
+  BLI_addtail(&rb->chains, ec);
 
-  return rlc;
+  return ec;
 }
 
-static bool lineart_point_overlapping(LineartLineChainItem *rlci,
+static bool lineart_point_overlapping(LineartEdgeChainItem *eci,
                                       float x,
                                       float y,
                                       double threshold)
 {
-  if (!rlci) {
+  if (!eci) {
     return false;
   }
-  if (((rlci->pos[0] + threshold) >= x) && ((rlci->pos[0] - threshold) <= x) &&
-      ((rlci->pos[1] + threshold) >= y) && ((rlci->pos[1] - threshold) <= y)) {
+  if (((eci->pos[0] + threshold) >= x) && ((eci->pos[0] - threshold) <= x) &&
+      ((eci->pos[1] + threshold) >= y) && ((eci->pos[1] - threshold) <= y)) {
     return true;
   }
   return false;
 }
 
-static LineartLineChainItem *lineart_chain_append_point(LineartRenderBuffer *rb,
-                                                        LineartLineChain *rlc,
+static LineartEdgeChainItem *lineart_chain_append_point(LineartRenderBuffer *rb,
+                                                        LineartEdgeChain *ec,
                                                         float *fbcoord,
                                                         float *gpos,
                                                         float *normal,
@@ -106,35 +106,35 @@ static LineartLineChainItem *lineart_chain_append_point(LineartRenderBuffer *rb,
                                                         unsigned char transparency_mask,
                                                         size_t index)
 {
-  LineartLineChainItem *rlci;
+  LineartEdgeChainItem *eci;
 
-  if (lineart_point_overlapping(rlc->chain.last, fbcoord[0], fbcoord[1], 1e-5)) {
+  if (lineart_point_overlapping(ec->chain.last, fbcoord[0], fbcoord[1], 1e-5)) {
     /* Because the new chain point is overlapping, just replace the type and occlusion level of the
      * current point. This makes it so that the line to the point after this one has the correct
      * type and level. */
-    LineartLineChainItem *old_rlci = rlc->chain.last;
+    LineartEdgeChainItem *old_rlci = ec->chain.last;
     old_rlci->line_type = type;
     old_rlci->occlusion = level;
     old_rlci->transparency_mask = transparency_mask;
     return old_rlci;
   }
 
-  rlci = lineart_mem_acquire(&rb->render_data_pool, sizeof(LineartLineChainItem));
+  eci = lineart_mem_acquire(&rb->render_data_pool, sizeof(LineartEdgeChainItem));
 
-  copy_v2_v2(rlci->pos, fbcoord);
-  copy_v3_v3(rlci->gpos, gpos);
-  rlci->index = index;
-  copy_v3_v3(rlci->normal, normal);
-  rlci->line_type = type & LRT_EDGE_FLAG_ALL_TYPE;
-  rlci->occlusion = level;
-  rlci->transparency_mask = transparency_mask;
-  BLI_addtail(&rlc->chain, rlci);
+  copy_v2_v2(eci->pos, fbcoord);
+  copy_v3_v3(eci->gpos, gpos);
+  eci->index = index;
+  copy_v3_v3(eci->normal, normal);
+  eci->line_type = type & LRT_EDGE_FLAG_ALL_TYPE;
+  eci->occlusion = level;
+  eci->transparency_mask = transparency_mask;
+  BLI_addtail(&ec->chain, eci);
 
-  return rlci;
+  return eci;
 }
 
-static LineartLineChainItem *lineart_chain_prepend_point(LineartRenderBuffer *rb,
-                                                         LineartLineChain *rlc,
+static LineartEdgeChainItem *lineart_chain_prepend_point(LineartRenderBuffer *rb,
+                                                         LineartEdgeChain *ec,
                                                          float *fbcoord,
                                                          float *gpos,
                                                          float *normal,
@@ -143,32 +143,32 @@ static LineartLineChainItem *lineart_chain_prepend_point(LineartRenderBuffer *rb
                                                          unsigned char transparency_mask,
                                                          size_t index)
 {
-  LineartLineChainItem *rlci;
+  LineartEdgeChainItem *eci;
 
-  if (lineart_point_overlapping(rlc->chain.first, fbcoord[0], fbcoord[1], 1e-5)) {
-    return rlc->chain.first;
+  if (lineart_point_overlapping(ec->chain.first, fbcoord[0], fbcoord[1], 1e-5)) {
+    return ec->chain.first;
   }
 
-  rlci = lineart_mem_acquire(&rb->render_data_pool, sizeof(LineartLineChainItem));
+  eci = lineart_mem_acquire(&rb->render_data_pool, sizeof(LineartEdgeChainItem));
 
-  copy_v2_v2(rlci->pos, fbcoord);
-  copy_v3_v3(rlci->gpos, gpos);
-  rlci->index = index;
-  copy_v3_v3(rlci->normal, normal);
-  rlci->line_type = type & LRT_EDGE_FLAG_ALL_TYPE;
-  rlci->occlusion = level;
-  rlci->transparency_mask = transparency_mask;
-  BLI_addhead(&rlc->chain, rlci);
+  copy_v2_v2(eci->pos, fbcoord);
+  copy_v3_v3(eci->gpos, gpos);
+  eci->index = index;
+  copy_v3_v3(eci->normal, normal);
+  eci->line_type = type & LRT_EDGE_FLAG_ALL_TYPE;
+  eci->occlusion = level;
+  eci->transparency_mask = transparency_mask;
+  BLI_addhead(&ec->chain, eci);
 
-  return rlci;
+  return eci;
 }
 
 void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
 {
-  LineartLineChain *rlc;
-  LineartLineChainItem *rlci;
+  LineartEdgeChain *ec;
+  LineartEdgeChainItem *eci;
   LineartBoundingArea *ba;
-  LineartLineSegment *rls;
+  LineartEdgeSegment *es;
   int last_occlusion;
   unsigned char last_transparency;
   /* Used when converting from double. */
@@ -192,14 +192,14 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
 
     e->flags |= LRT_EDGE_FLAG_CHAIN_PICKED;
 
-    rlc = lineart_chain_create(rb);
+    ec = 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 = e->object_ref;
+    ec->object_ref = e->object_ref;
 
     LineartEdge *new_e = e;
-    LineartVert *new_rv;
+    LineartVert *new_vt;
     float N[3] = {0};
 
     if (e->t1) {
@@ -218,19 +218,19 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
 
     /*  Step 1: grow left. */
     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);
+    new_vt = e->v1;
+    es = e->segments.first;
+    VERT_COORD_TO_FLOAT(new_vt);
     lineart_chain_prepend_point(rb,
-                                rlc,
+                                ec,
                                 use_fbcoord,
                                 use_gpos,
                                 N,
                                 e->flags,
-                                rls->occlusion,
-                                rls->transparency_mask,
+                                es->occlusion,
+                                es->transparency_mask,
                                 e->v1_obindex);
-    while (ba && (new_e = lineart_line_get_connected(ba, new_rv, &new_rv, e->flags))) {
+    while (ba && (new_e = lineart_line_get_connected(ba, new_vt, &new_vt, e->flags))) {
       new_e->flags |= LRT_EDGE_FLAG_CHAIN_PICKED;
 
       if (new_e->t1 || new_e->t2) {
@@ -248,41 +248,41 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
         normalize_v3(N);
       }
 
-      if (new_rv == new_e->v1) {
-        for (rls = new_e->segments.last; rls; rls = rls->prev) {
+      if (new_vt == new_e->v1) {
+        for (es = new_e->segments.last; es; es = es->prev) {
           double gpos[3], lpos[3];
           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_e->v1->fbcoord, new_e->v2->fbcoord, rls->at);
+          double global_at = lfb[3] * es->at / (es->at * lfb[3] + (1 - es->at) * rfb[3]);
+          interp_v3_v3v3_db(lpos, new_e->v1->fbcoord, new_e->v2->fbcoord, es->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,
+                                      ec,
                                       use_fbcoord,
                                       use_gpos,
                                       N,
                                       new_e->flags,
-                                      rls->occlusion,
-                                      rls->transparency_mask,
+                                      es->occlusion,
+                                      es->transparency_mask,
                                       new_e->v1_obindex);
-          last_occlusion = rls->occlusion;
-          last_transparency = rls->transparency_mask;
+          last_occlusion = es->occlusion;
+          last_transparency = es->transparency_mask;
         }
       }
-      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) {
+      else if (new_vt == new_e->v2) {
+        es = new_e->segments.first;
+        last_occlusion = es->occlusion;
+        last_transparency = es->transparency_mask;
+        es = es->next;
+        for (; es; es = es->next) {
           double gpos[3], lpos[3];
           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_e->v1->fbcoord, new_e->v2->fbcoord, rls->at);
+          double global_at = lfb[3] * es->at / (es->at * lfb[3] + (1 - es->at) * rfb[3]);
+          interp_v3_v3v3_db(lpos, new_e->v1->fbcoord, new_e->v2->fbcoord, es->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,
+                                      ec,
                                       use_fbcoord,
                                       use_gpos,
                                       N,
@@ -290,12 +290,12 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
                                       last_occlusion,
                                       last_transparency,
                                       new_e->v2_obindex);
-          last_occlusion = rls->occlusion;
-          last_transparency = rls->transparency_mask;
+          last_occlusion = es->occlusion;
+          last_transparency = es->transparency_mask;
         }
         VERT_COORD_TO_FLOAT(new_e->v2);
         lineart_chain_prepend_point(rb,
-                                    rlc,
+                                    ec,
                                     use_fbcoord,
                                     use_gpos,
                                     N,
@@ -304,7 +304,7 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
                                     last_transparency,
                                     new_e->v2_obindex);
       }
-      ba = MOD_lineart_get_bounding_area(rb, new_rv->fbcoord[0], new_rv->fbcoord[1]);
+      ba = MOD_lineart_get_bounding_area(rb, new_vt->fbcoord[0], new_vt->fbcoord[1]);
     }
 
     /* Restore normal value. */
@@ -324,31 +324,31 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
     }
     /*  Step 2: Adding all cuts from the given line, so we can continue connecting the right side
      * of the line. */
-    rls = e->segments.first;
-    last_occlusion = ((LineartLineSegment *)rls)->occlusion;
-    last_transparency = ((LineartLineSegment *)rls)->transparency_mask;
-    for (rls = rls->next; rls; rls = rls->next) {
+    es = e->segments.first;
+    last_occlusion = ((LineartEdgeSegment *)es)->occlusion;
+    last_transparency = ((LineartEdgeSegment *)es)->transparency_mask;
+    for (es = es->next; es; es = es->next) {
       double gpos[3], lpos[3];
       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, e->v1->fbcoord, e->v2->fbcoord, rls->at);
+      double global_at = lfb[3] * es->at / (es->at * lfb[3] + (1 - es->at) * rfb[3]);
+      interp_v3_v3v3_db(lpos, e->v1->fbcoord, e->v2->fbcoord, es->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,
+                                 ec,
                                  use_fbcoord,
                                  use_gpos,
                                  N,
                                  e->flags,
-                                 rls->occlusion,
-                                 rls->transparency_mask,
+                                 es->occlusion,
+                                 es->transparency_mask,
                                  e->v1_obindex);
-      last_occlusion = rls->occlusion;
-      last_transparency = rls->transparency_mask;
+      last_occlusion = es->occlusion;
+      last_transparency = es->transparency_mask;
     }
     VERT_COORD_TO_FLOAT(e->v2)
     lineart_chain_append_point(rb,
-                               rlc,
+                               ec,
                                use_fbcoord,
                                use_gpos,
                                N,
@@ -359,8 +359,8 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
 
     /*  Step 3: grow right. */
     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_vt = e->v2;
+    while (ba && (new_e = lineart_line_get_connected(ba, new_vt, &new_vt, e->flags))) {
       new_e->flags |= LRT_EDGE_FLAG_CHAIN_PICKED;
 
       if (new_e->t1 || new_e->t2) {
@@ -379,27 +379,27 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
       }
 
       /* Fix leading vertex type. */
-      rlci = rlc->chain.last;
-      rlci->line_type = new_e->flags & LRT_EDGE_FLAG_ALL_TYPE;
+      eci = ec->chain.last;
+      eci->line_type = new_e->flags & LRT_EDGE_FLAG_ALL_TYPE;
 
-      if (new_rv == new_e->v1) {
-        rls = new_e->segments.last;
-        last_occlusion = rls->occlusion;
-        last_transparency = rls->transparency_mask;
+      if (new_vt == new_e->v1) {
+        es = new_e->segments.last;
+        last_occlusion = es->occlusion;
+        last_transparency = es->transparency_mask;
         /* Fix leading vertex occlusion. */
-        rlci->occlusion = last_occlusion;
-        rlci->transparency_mask = last_transparency;
-        for (rls = new_e->segments.last; rls; rls = rls->prev) {
+        eci->occlusion = last_occlusion;
+        eci->transparency_mask = last_transparency;
+        for (es = new_e->segments.last; es; es = es->prev) {
           double gpos[3], lpos[3];
           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_e->v1->fbcoord, new_e->v2->fbcoord, rls->at);
+          double global_at = lfb[3] * es->at / (es->at * lfb[3] + (1 - es->at) * rfb[3]);
+          interp_v3_v3v3_db(lpos, new_e->v1->fbcoord, new_e->v2->fbcoord, es->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;
+          last_occlusion = es->prev ? es->prev->occlusion : last_occlusion;
+          last_transparency = es->prev ? es->prev->transparency_mask : last_transparency;
           POS_TO_FLOAT(lpos, gpos)
           lineart_chain_append_point(rb,
-                                     rlc,
+                                     ec,
                                      use_fbcoord,
                                      use_gpos,
                                      N,
@@ -409,35 +409,35 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
                                      new_e->v1_obindex);
         }
       }
-      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;
-        rlci->transparency_mask = last_transparency;
-        rls = rls->next;
-        for (; rls; rls = rls->next) {
+      else if (new_vt == new_e->v2) {
+        es = new_e->segments.first;
+        last_occlusion = es->occlusion;
+        last_transparency = es->transparency_mask;
+        eci->occlusion = last_occlusion;
+        eci->transparency_mask = last_transparency;
+        es = es->next;
+        for (; es; es = es->next) {
           double gpos[3], lpos[3];
           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_e->v1->fbcoord, new_e->v2->fbcoord, rls->at);
+          double global_at = lfb[3] * es->at / (es->at * lfb[3] + (1 - es->at) * rfb[3]);
+          interp_v3_v3v3_db(lpos, new_e->v1->fbcoord, new_e->v2->fbcoord, es->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,
+                                     ec,
                                      use_fbcoord,
                                      use_gpos,
                                      N,
                                      new_e->flags,
-                                     rls->occlusion,
-                                     rls->transparency_mask,
+                                     es->occlusion,
+                                     es->transparency_mask,
                                      new_e->v2_obindex);
-          last_occlusion = rls->occlusion;
-          last_transparency = rls->transparency_mask;
+          last_occlusion = es->occlusion;
+          last_transparency = es->transparency_mask;
         }
         VERT_COORD_TO_FLOAT(new_e->v2)
         lineart_chain_append_point(rb,
-                                   rlc,
+                                   ec,
                                    use_fbcoord,
                                    use_gpos,
                                    N,
@@ -446,57 +446,57 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
                                    last_transparency,
                                    new_e->v2_obindex);
       }
-      ba = MOD_lineart_get_bounding_area(rb, new_rv->fbcoord[0], new_rv->fbcoord[1]);
+      ba = MOD_lineart_get_bounding_area(rb, new_vt->fbcoord[0], new_vt->fbcoord[1]);
     }
     if (rb->fuzzy_everything) {
-      rlc->type = LRT_EDGE_FLAG_CONTOUR;
+      ec->type = LRT_EDGE_FLAG_CONTOUR;
     }
     else {
-      rlc->type = (e->flags & LRT_EDGE_FLAG_ALL_TYPE);
+      ec->type = (e->flags & LRT_EDGE_FLAG_ALL_TYPE);
     }
   }
   LRT_ITER_ALL_LINES_END
 }
 
-static LineartBoundingArea *lineart_bounding_area_get_rlci_recursive(LineartRenderBuffer *rb,
-                                                                     LineartBoundingArea *root,
-                                                                     LineartLineChainItem *rlci)
+static LineartBoundingArea *lineart_bounding_area_get_eci_recursive(LineartRenderBuffer *rb,
+                                                                    LineartBoundingArea *root,
+                                                                    LineartEdgeChainItem *eci)
 {
   if (root->child == NULL) {
     return root;
   }
 
   LineartBoundingArea *ch = root->child;
-#define IN_BOUND(ba, rlci) \
-  ba.l <= rlci->pos[0] && ba.r >= rlci->pos[0] && ba.b <= rlci->pos[1] && ba.u >= rlci->pos[1]
+#define IN_BOUND(ba, eci) \
+  ba.l <= eci->pos[0] && ba.r >= eci->pos[0] && ba.b <= eci->pos[1] && ba.u >= eci->pos[1]
 
-  if (IN_BOUND(ch[0], rlci)) {
-    return lineart_bounding_area_get_rlci_recursive(rb, &ch[0], rlci);
+  if (IN_BOUND(ch[0], eci)) {
+    return lineart_bounding_area_get_eci_recursive(rb, &ch[0], eci);
   }
-  if (IN_BOUND(ch[1], rlci)) {
-    return lineart_bounding_area_get_rlci_recursive(rb, &ch[1], rlci);
+  if (IN_BOUND(ch[1], eci)) {
+    return lineart_bounding_area_get_eci_recursive(rb, &ch[1], eci);
   }
-  if (IN_BOUND(ch[2], rlci)) {
-    return lineart_bounding_area_get_rlci_recursive(rb, &ch[2], rlci);
+  if (IN_BOUND(ch[2], eci)) {
+    return lineart_bounding_area_get_eci_recursive(rb, &ch[2], eci);
   }
-  if (IN_BOUND(ch[3], rlci)) {
-    return lineart_bounding_area_get_rlci_recursive(rb, &ch[3], rlci);
+  if (IN_BOUND(ch[3], eci)) {
+    return lineart_bounding_area_get_eci_recursive(rb, &ch[3], eci);
   }
 #undef IN_BOUND
   return NULL;
 }
 
 static LineartBoundingArea *lineart_bounding_area_get_end_point(LineartRenderBuffer *rb,
-                                                                LineartLineChainItem *rlci)
+                                                                LineartEdgeChainItem *eci)
 {
-  if (!rlci) {
+  if (!eci) {
     return NULL;
   }
-  LineartBoundingArea *root = MOD_lineart_get_parent_bounding_area(rb, rlci->pos[0], rlci->pos[1]);
+  LineartBoundingArea *root = MOD_lineart_get_parent_bounding_area(rb, eci->pos[0], eci->pos[1]);
   if (root == NULL) {
     return NULL;
   }
-  return lineart_bounding_area_get_rlci_recursive(rb, root, rlci);
+  return lineart_bounding_area_get_eci_recursive(rb, root, eci);
 }
 
 /**
@@ -507,61 +507,61 @@ static LineartBoundingArea *lineart_bounding_area_get_end_point(LineartRenderBuf
  */
 static void lineart_bounding_area_link_point_recursive(LineartRenderBuffer *rb,
                                                        LineartBoundingArea *root,
-                                                       LineartLineChain *rlc,
-                                                       LineartLineChainItem *rlci)
+                                                       LineartEdgeChain *ec,
+                                                       LineartEdgeChainItem *eci)
 {
   if (root->child == NULL) {
     LineartChainRegisterEntry *cre = lineart_list_append_pointer_pool_sized(
-        &root->linked_chains, &rb->render_data_pool, rlc, sizeof(LineartChainRegisterEntry));
+        &root->linked_chains, &rb->render_data_pool, ec, sizeof(LineartChainRegisterEntry));
 
-    cre->rlci = rlci;
+    cre->eci = eci;
 
-    if (rlci == rlc->chain.first) {
+    if (eci == ec->chain.first) {
       cre->is_left = 1;
     }
   }
   else {
     LineartBoundingArea *ch = root->child;
 
-#define IN_BOUND(ba, rlci) \
-  ba.l <= rlci->pos[0] && ba.r >= rlci->pos[0] && ba.b <= rlci->pos[1] && ba.u >= rlci->pos[1]
+#define IN_BOUND(ba, eci) \
+  ba.l <= eci->pos[0] && ba.r >= eci->pos[0] && ba.b <= eci->pos[1] && ba.u >= eci->pos[1]
 
-    if (IN_BOUND(ch[0], rlci)) {
-      lineart_bounding_area_link_point_recursive(rb, &ch[0], rlc, rlci);
+    if (IN_BOUND(ch[0], eci)) {
+      lineart_bounding_area_link_point_recursive(rb, &ch[0], ec, eci);
     }
-    else if (IN_BOUND(ch[1], rlci)) {
-      lineart_bounding_area_link_point_recursive(rb, &ch[1], rlc, rlci);
+    else if (IN_BOUND(ch[1], eci)) {
+      lineart_bounding_area_link_point_recursive(rb, &ch[1], ec, eci);
     }
-    else if (IN_BOUND(ch[2], rlci)) {
-      lineart_bounding_area_link_point_recursive(rb, &ch[2], rlc, rlci);
+    else if (IN_BOUND(ch[2], eci)) {
+      lineart_bounding_area_link_point_recursive(rb, &ch[2], ec, eci);
     }
-    else if (IN_BOUND(ch[3], rlci)) {
-      lineart_bounding_area_link_point_recursive(rb, &ch[3], rlc, rlci);
+    else if (IN_BOUND(ch[3], eci)) {
+      lineart_bounding_area_link_point_recursive(rb, &ch[3], ec, eci);
     }
 
 #undef IN_BOUND
   }
 }
 
-static void lineart_bounding_area_link_chain(LineartRenderBuffer *rb, LineartLineChain *rlc)
+static void lineart_bounding_area_link_chain(LineartRenderBuffer *rb, LineartEdgeChain *ec)
 {
-  LineartLineChainItem *pl = rlc->chain.first;
-  LineartLineChainItem *pr = rlc->chain.last;
+  LineartEdgeChainItem *pl = ec->chain.first;
+  LineartEdgeChainItem *pr = ec->chain.last;
   LineartBoundingArea *ba1 = MOD_lineart_get_parent_bounding_area(rb, pl->pos[0], pl->pos[1]);
   LineartBoundingArea *ba2 = MOD_lineart_get_parent_bounding_area(rb, pr->pos[0], pr->pos[1]);
 
   if (ba1) {
-    lineart_bounding_area_link_point_recursive(rb, ba1, rlc, pl);
+    lineart_bounding_area_link_point_recursive(rb, ba1, ec, pl);
   }
   if (ba2) {
-    lineart_bounding_area_link_point_recursive(rb, ba2, rlc, pr);
+    lineart_bounding_area_link_point_recursive(rb, ba2, ec, pr);
   }
 }
 
 void MOD_lineart_chain_split_for_fixed_occlusion(LineartRenderBuffer *rb)
 {
-  LineartLineChain *rlc, *new_rlc;
-  LineartLineChainItem *rlci, *next_rlci;
+  LineartEdgeChain *ec, *new_rlc;
+  LineartEdgeChainItem *eci, *next_rlci;
   ListBase swap = {0};
 
   swap.first = rb->chains.first;
@@ -569,59 +569,59 @@ void MOD_lineart_chain_split_for_fixed_occlusion(LineartRenderBuffer *rb)
 
   rb->chains.last = rb->chains.first = NULL;
 
-  while ((rlc = BLI_pophead(&swap)) != NULL) {
-    rlc->next = rlc->prev = NULL;
-    BLI_addtail(&rb->chains, rlc);
-    LineartLineChainItem *first_rlci = (LineartLineChainItem *)rlc->chain.first;
+  while ((ec = BLI_pophead(&swap)) != NULL) {
+    ec->next = ec->prev = NULL;
+    BLI_addtail(&rb->chains, ec);
+    LineartEdgeChainItem *first_rlci = (LineartEdgeChainItem *)ec->chain.first;
     int fixed_occ = first_rlci->occlusion;
     unsigned char fixed_mask = first_rlci->transparency_mask;
-    rlc->level = fixed_occ;
-    rlc->transparency_mask = fixed_mask;
-    for (rlci = first_rlci->next; rlci; rlci = next_rlci) {
-      next_rlci = rlci->next;
-      if (rlci->occlusion != fixed_occ || rlci->transparency_mask != fixed_mask) {
+    ec->level = fixed_occ;
+    ec->transparency_mask = fixed_mask;
+    for (eci = first_rlci->next; eci; eci = next_rlci) {
+      next_rlci = eci->next;
+      if (eci->occlusion != fixed_occ || eci->transparency_mask != fixed_mask) {
         if (next_rlci) {
-          if (lineart_point_overlapping(next_rlci, rlci->pos[0], rlci->pos[1], 1e-5)) {
+          if (lineart_point_overlapping(next_rlci, eci->pos[0], eci->pos[1], 1e-5)) {
             continue;
           }
         }
         else {
           /* Set the same occlusion level for the end vertex, so when further connection is needed
            * the backwards occlusion info is also correct.  */
-          rlci->occlusion = fixed_occ;
-          rlci->transparency_mask = fixed_mask;
+          eci->occlusion = fixed_occ;
+          eci->transparency_mask = fixed_mask;
           /* No need to split at the last point anyway. */
           break;
         }
         new_rlc = lineart_chain_create(rb);
-        new_rlc->chain.first = rlci;
-        new_rlc->chain.last = rlc->chain.last;
-        rlc->chain.last = rlci->prev;
-        ((LineartLineChainItem *)rlc->chain.last)->next = 0;
-        rlci->prev = 0;
+        new_rlc->chain.first = eci;
+        new_rlc->chain.last = ec->chain.last;
+        ec->chain.last = eci->prev;
+        ((LineartEdgeChainItem *)ec->chain.last)->next = 0;
+        eci->prev = 0;
 
         /* End the previous one. */
         lineart_chain_append_point(rb,
-                                   rlc,
-                                   rlci->pos,
-                                   rlci->gpos,
-                                   rlci->normal,
-                                   rlci->line_type,
+                                   ec,
+                                   eci->pos,
+                                   eci->gpos,
+                                   eci->normal,
+                                   eci->line_type,
                                    fixed_occ,
                                    fixed_mask,
-                                   rlci->index);
-        new_rlc->object_ref = rlc->object_ref;
-        new_rlc->type = rlc->type;
-        rlc = new_rlc;
-        fixed_occ = rlci->occlusion;
-        fixed_mask = rlci->transparency_mask;
-        rlc->level = fixed_occ;
-        rlc->transparency_mask = fixed_mask;
+                                   eci->index);
+        new_rlc->object_ref = ec->object_ref;
+        new_rlc->type = ec->type;
+        ec = new_rlc;
+        fixed_occ = eci->occlusion;
+        fixed_mask = eci->transparency_mask;
+        ec->level = fixed_occ;
+        ec->transparency_mask = fixed_mask;
       }
     }
   }
-  LISTBASE_FOREACH (LineartLineChain *, irlc, &rb->chains) {
-    lineart_bounding_area_link_chain(rb, irlc);
+  LISTBASE_FOREACH (LineartEdgeChain *, iec, &rb->chains) {
+    lineart_bounding_area_link_chain(rb, iec);
   }
 }
 
@@ -629,12 +629,12 @@ void MOD_lineart_chain_split_for_fixed_occlusion(LineartRenderBuffer *rb)
  * Note: segment type (crease/material/contour...) is ambiguous after this.
  */
 static void lineart_chain_connect(LineartRenderBuffer *UNUSED(rb),
-                                  LineartLineChain *onto,
-                                  LineartLineChain *sub,
+                                  LineartEdgeChain *onto,
+                                  LineartEdgeChain *sub,
                                   int reverse_1,
                                   int reverse_2)
 {
-  LineartLineChainItem *rlci;
+  LineartEdgeChainItem *eci;
   if (onto->type == LRT_EDGE_FLAG_INTERSECTION) {
     if (sub->object_ref) {
       onto->object_ref = sub->object_ref;
@@ -650,38 +650,38 @@ static void lineart_chain_connect(LineartRenderBuffer *UNUSED(rb),
     if (reverse_2) { /*  L--R R-L. */
       BLI_listbase_reverse(&sub->chain);
     }
-    rlci = sub->chain.first;
-    if (lineart_point_overlapping(onto->chain.last, rlci->pos[0], rlci->pos[1], 1e-5)) {
+    eci = sub->chain.first;
+    if (lineart_point_overlapping(onto->chain.last, eci->pos[0], eci->pos[1], 1e-5)) {
       BLI_pophead(&sub->chain);
       if (sub->chain.first == NULL) {
         return;
       }
     }
-    ((LineartLineChainItem *)onto->chain.last)->next = sub->chain.first;
-    ((LineartLineChainItem *)sub->chain.first)->prev = onto->chain.last;
+    ((LineartEdgeChainItem *)onto->chain.last)->next = sub->chain.first;
+    ((LineartEdgeChainItem *)sub->chain.first)->prev = onto->chain.last;
     onto->chain.last = sub->chain.last;
   }
   else {              /*  L-R L--R. */
     if (!reverse_2) { /*  R-L L--R. */
       BLI_listbase_reverse(&sub->chain);
     }
-    rlci = onto->chain.first;
-    if (lineart_point_overlapping(sub->chain.last, rlci->pos[0], rlci->pos[1], 1e-5)) {
+    eci = onto->chain.first;
+    if (lineart_point_overlapping(sub->chain.last, eci->pos[0], eci->pos[1], 1e-5)) {
       BLI_pophead(&onto->chain);
       if (onto->chain.first == NULL) {
         return;
       }
     }
-    ((LineartLineChainItem *)sub->chain.last)->next = onto->chain.first;
-    ((LineartLineChainItem *)onto->chain.first)->prev = sub->chain.last;
+    ((LineartEdgeChainItem *)sub->chain.last)->next = onto->chain.first;
+    ((LineartEdgeChainItem *)onto->chain.first)->prev = sub->chain.last;
     onto->chain.first = sub->chain.first;
   }
 }
 
 static LineartChainRegisterEntry *lineart_chain_get_closest_cre(LineartRenderBuffer *rb,
                                                                 LineartBoundingArea *ba,
-                                                                LineartLineChain *rlc,
-                                                                LineartLineChainItem *rlci,
+                                                                LineartEdgeChain *ec,
+                                                                LineartEdgeChainItem *eci,
                                                                 int occlusion,
                                                                 unsigned char transparency_mask,
                                                                 float dist,
@@ -694,12 +694,12 @@ static LineartChainRegisterEntry *lineart_chain_get_closest_cre(LineartRenderBuf
   /* Keep using for loop because `cre` could be removed from the iteration before getting to the
    * next one. */
   LISTBASE_FOREACH_MUTABLE (LineartChainRegisterEntry *, cre, &ba->linked_chains) {
-    if (cre->rlc->object_ref != rlc->object_ref) {
+    if (cre->ec->object_ref != ec->object_ref) {
       if (!rb->fuzzy_everything) {
         if (rb->fuzzy_intersections) {
           /* If none of those are intersection lines... */
-          if ((!(cre->rlc->type & LRT_EDGE_FLAG_INTERSECTION)) &&
-              (!(rlc->type & LRT_EDGE_FLAG_INTERSECTION))) {
+          if ((!(cre->ec->type & LRT_EDGE_FLAG_INTERSECTION)) &&
+              (!(ec->type & LRT_EDGE_FLAG_INTERSECTION))) {
             continue; /* We don't want to chain along different objects at the moment. */
           }
         }
@@ -708,18 +708,18 @@ static LineartChainRegisterEntry *lineart_chain_get_closest_cre(LineartRenderBuf
         }
       }
     }
-    if (cre->rlc->picked || cre->picked) {
+    if (cre->ec->picked || cre->picked) {
       continue;
     }
-    if (cre->rlc == rlc || (!cre->rlc->chain.first) || (cre->rlc->level != occlusion) ||
-        (cre->rlc->transparency_mask != transparency_mask)) {
+    if (cre->ec == ec || (!cre->ec->chain.first) || (cre->ec->level != occlusion) ||
+        (cre->ec->transparency_mask != transparency_mask)) {
       continue;
     }
     if (!rb->fuzzy_everything) {
-      if (cre->rlc->type != rlc->type) {
+      if (cre->ec->type != ec->type) {
         if (rb->fuzzy_intersections) {
-          if (!(cre->rlc->type == LRT_EDGE_FLAG_INTERSECTION ||
-                rlc->type == LRT_EDGE_FLAG_INTERSECTION)) {
+          if (!(cre->ec->type == LRT_EDGE_FLAG_INTERSECTION ||
+                ec->type == LRT_EDGE_FLAG_INTERSECTION)) {
             continue; /* Fuzzy intersections but no intersection line found. */
           }
         }
@@ -729,7 +729,7 @@ static LineartChainRegisterEntry *lineart_chain_get_closest_cre(LineartRenderBuf
       }
     }
 
-    float new_len = len_v2v2(cre->rlci->pos, rlci->pos);
+    float new_len = len_v2v2(cre->eci->pos, eci->pos);
     if (new_len < dist) {
       closest_cre = cre;
       dist = new_len;
@@ -748,7 +748,7 @@ static LineartChainRegisterEntry *lineart_chain_get_closest_cre(LineartRenderBuf
     LISTBASE_FOREACH (LinkData *, ld, list) { \
       LineartBoundingArea *sba = (LineartBoundingArea *)ld->data; \
       adjacent_closest = lineart_chain_get_closest_cre( \
-          rb, sba, rlc, rlci, occlusion, transparency_mask, dist, &adjacent_new_len, ba); \
+          rb, sba, ec, eci, occlusion, transparency_mask, dist, &adjacent_new_len, ba); \
       if (adjacent_new_len < dist) { \
         dist = adjacent_new_len; \
         closest_cre = adjacent_closest; \
@@ -756,10 +756,10 @@ static LineartChainRegisterEntry *lineart_chain_get_closest_cre(LineartRenderBuf
     } \
   }
   if (!caller_ba) {
-    LRT_TEST_ADJACENT_AREAS(rlci->pos[0] - ba->l, &ba->lp);
-    LRT_TEST_ADJACENT_AREAS(ba->r - rlci->pos[0], &ba->rp);
-    LRT_TEST_ADJACENT_AREAS(ba->u - rlci->pos[1], &ba->up);
-    LRT_TEST_ADJACENT_AREAS(rlci->pos[1] - ba->b, &ba->bp);
+    LRT_TEST_ADJACENT_AREAS(eci->pos[0] - ba->l, &ba->lp);
+    LRT_TEST_ADJACENT_AREAS(ba->r - eci->pos[0], &ba->rp);
+    LRT_TEST_ADJACENT_AREAS(ba->u - eci->pos[1], &ba->up);
+    LRT_TEST_ADJACENT_AREAS(eci->pos[1] - ba->b, &ba->bp);
   }
   if (result_new_len) {
     (*result_new_len) = dist;
@@ -774,8 +774,8 @@ static LineartChainRegisterEntry *lineart_chain_get_closest_cre(LineartRenderBuf
  */
 void MOD_lineart_chain_connect(LineartRenderBuffer *rb)
 {
-  LineartLineChain *rlc;
-  LineartLineChainItem *rlci_l, *rlci_r;
+  LineartEdgeChain *ec;
+  LineartEdgeChainItem *rlci_l, *rlci_r;
   LineartBoundingArea *ba_l, *ba_r;
   LineartChainRegisterEntry *closest_cre_l, *closest_cre_r, *closest_cre;
   float dist = rb->chaining_image_threshold;
@@ -793,24 +793,24 @@ void MOD_lineart_chain_connect(LineartRenderBuffer *rb)
 
   rb->chains.last = rb->chains.first = NULL;
 
-  while ((rlc = BLI_pophead(&swap)) != NULL) {
-    rlc->next = rlc->prev = NULL;
-    if (rlc->picked) {
+  while ((ec = BLI_pophead(&swap)) != NULL) {
+    ec->next = ec->prev = NULL;
+    if (ec->picked) {
       continue;
     }
-    BLI_addtail(&rb->chains, rlc);
+    BLI_addtail(&rb->chains, ec);
 
-    occlusion = rlc->level;
-    transparency_mask = rlc->transparency_mask;
+    occlusion = ec->level;
+    transparency_mask = ec->transparency_mask;
 
-    rlci_l = rlc->chain.first;
-    rlci_r = rlc->chain.last;
+    rlci_l = ec->chain.first;
+    rlci_r = ec->chain.last;
     while ((ba_l = lineart_bounding_area_get_end_point(rb, rlci_l)) &&
            (ba_r = lineart_bounding_area_get_end_point(rb, rlci_r))) {
       closest_cre_l = lineart_chain_get_closest_cre(
-          rb, ba_l, rlc, rlci_l, occlusion, transparency_mask, dist, &dist_l, NULL);
+          rb, ba_l, ec, rlci_l, occlusion, transparency_mask, dist, &dist_l, NULL);
       closest_cre_r = lineart_chain_get_closest_cre(
-          rb, ba_r, rlc, rlci_r, occlusion, transparency_mask, dist, &dist_r, NULL);
+          rb, ba_r, ec, rlci_r, occlusion, transparency_mask, dist, &dist_r, NULL);
       if (closest_cre_l && closest_cre_r) {
         if (dist_l < dist_r) {
           closest_cre = closest_cre_l;
@@ -834,56 +834,56 @@ void MOD_lineart_chain_connect(LineartRenderBuffer *rb)
         break;
       }
       closest_cre->picked = 1;
-      closest_cre->rlc->picked = 1;
+      closest_cre->ec->picked = 1;
       if (closest_cre->is_left) {
-        lineart_chain_connect(rb, rlc, closest_cre->rlc, reverse_main, 0);
+        lineart_chain_connect(rb, ec, closest_cre->ec, reverse_main, 0);
       }
       else {
-        lineart_chain_connect(rb, rlc, closest_cre->rlc, reverse_main, 1);
+        lineart_chain_connect(rb, ec, closest_cre->ec, reverse_main, 1);
       }
-      BLI_remlink(&swap, closest_cre->rlc);
-      rlci_l = rlc->chain.first;
-      rlci_r = rlc->chain.last;
+      BLI_remlink(&swap, closest_cre->ec);
+      rlci_l = ec->chain.first;
+      rlci_r = ec->chain.last;
     }
-    rlc->picked = 1;
+    ec->picked = 1;
   }
 }
 
 /**
  * Length is in image space.
  */
-float MOD_lineart_chain_compute_length(LineartLineChain *rlc)
+float MOD_lineart_chain_compute_length(LineartEdgeChain *ec)
 {
-  LineartLineChainItem *rlci;
+  LineartEdgeChainItem *eci;
   float offset_accum = 0;
   float dist;
   float last_point[2];
 
-  rlci = rlc->chain.first;
-  copy_v2_v2(last_point, rlci->pos);
-  for (rlci = rlc->chain.first; rlci; rlci = rlci->next) {
-    dist = len_v2v2(rlci->pos, last_point);
+  eci = ec->chain.first;
+  copy_v2_v2(last_point, eci->pos);
+  for (eci = ec->chain.first; eci; eci = eci->next) {
+    dist = len_v2v2(eci->pos, last_point);
     offset_accum += dist;
-    copy_v2_v2(last_point, rlci->pos);
+    copy_v2_v2(last_point, eci->pos);
   }
   return offset_accum;
 }
 
 void MOD_lineart_chain_discard_short(LineartRenderBuffer *rb, const float threshold)
 {
-  LineartLineChain *rlc, *next_rlc;
-  for (rlc = rb->chains.first; rlc; rlc = next_rlc) {
-    next_rlc = rlc->next;
-    if (MOD_lineart_chain_compute_length(rlc) < threshold) {
-      BLI_remlink(&rb->chains, rlc);
+  LineartEdgeChain *ec, *next_rlc;
+  for (ec = rb->chains.first; ec; ec = next_rlc) {
+    next_rlc = ec->next;
+    if (MOD_lineart_chain_compute_length(ec) < threshold) {
+      BLI_remlink(&rb->chains, ec);
     }
   }
 }
 
-int MOD_lineart_chain_count(const LineartLineChain *rlc)
+int MOD_lineart_chain_count(const LineartEdgeChain *ec)
 {
   int count = 0;
-  LISTBASE_FOREACH (LineartLineChainItem *, rlci, &rlc->chain) {
+  LISTBASE_FOREACH (LineartEdgeChainItem *, eci, &ec->chain) {
     count++;
   }
   return count;
@@ -894,8 +894,8 @@ void MOD_lineart_chain_clear_picked_flag(LineartRenderBuffer *rb)
   if (rb == NULL) {
     return;
   }
-  LISTBASE_FOREACH (LineartLineChain *, rlc, &rb->chains) {
-    rlc->picked = 0;
+  LISTBASE_FOREACH (LineartEdgeChain *, ec, &rb->chains) {
+    ec->picked = 0;
   }
 }
 
@@ -905,8 +905,8 @@ void MOD_lineart_chain_clear_picked_flag(LineartRenderBuffer *rb)
  */
 void MOD_lineart_chain_split_angle(LineartRenderBuffer *rb, float angle_threshold_rad)
 {
-  LineartLineChain *rlc, *new_rlc;
-  LineartLineChainItem *rlci, *next_rlci, *prev_rlci;
+  LineartEdgeChain *ec, *new_rlc;
+  LineartEdgeChainItem *eci, *next_rlci, *prev_rlci;
   ListBase swap = {0};
 
   swap.first = rb->chains.first;
@@ -914,43 +914,43 @@ void MOD_lineart_chain_split_angle(LineartRenderBuffer *rb, float angle_threshol
 
   rb->chains.last = rb->chains.first = NULL;
 
-  while ((rlc = BLI_pophead(&swap)) != NULL) {
-    rlc->next = rlc->prev = NULL;
-    BLI_addtail(&rb->chains, rlc);
-    LineartLineChainItem *first_rlci = (LineartLineChainItem *)rlc->chain.first;
-    for (rlci = first_rlci->next; rlci; rlci = next_rlci) {
-      next_rlci = rlci->next;
-      prev_rlci = rlci->prev;
+  while ((ec = BLI_pophead(&swap)) != NULL) {
+    ec->next = ec->prev = NULL;
+    BLI_addtail(&rb->chains, ec);
+    LineartEdgeChainItem *first_rlci = (LineartEdgeChainItem *)ec->chain.first;
+    for (eci = first_rlci->next; eci; eci = next_rlci) {
+      next_rlci = eci->next;
+      prev_rlci = eci->prev;
       float angle = M_PI;
       if (next_rlci && prev_rlci) {
-        angle = angle_v2v2v2(prev_rlci->pos, rlci->pos, next_rlci->pos);
+        angle = angle_v2v2v2(prev_rlci->pos, eci->pos, next_rlci->pos);
       }
       else {
         break; /* No need to split at the last point anyway.*/
       }
       if (angle < angle_threshold_rad) {
         new_rlc = lineart_chain_create(rb);
-        new_rlc->chain.first = rlci;
-        new_rlc->chain.last = rlc->chain.last;
-        rlc->chain.last = rlci->prev;
-        ((LineartLineChainItem *)rlc->chain.last)->next = 0;
-        rlci->prev = 0;
+        new_rlc->chain.first = eci;
+        new_rlc->chain.last = ec->chain.last;
+        ec->chain.last = eci->prev;
+        ((LineartEdgeChainItem *)ec->chain.last)->next = 0;
+        eci->prev = 0;
 
         /* End the previous one. */
         lineart_chain_append_point(rb,
-                                   rlc,
-                                   rlci->pos,
-                                   rlci->gpos,
-                                   rlci->normal,
-                                   rlci->line_type,
-                                   rlc->level,
-                                   rlci->transparency_mask,
-                                   rlci->index);
-        new_rlc->object_ref = rlc->object_ref;
-        new_rlc->type = rlc->type;
-        new_rlc->level = rlc->level;
-        new_rlc->transparency_mask = rlc->transparency_mask;
-        rlc = new_rlc;
+                                   ec,
+                                   eci->pos,
+                                   eci->gpos,
+                                   eci->normal,
+                                   eci->line_type,
+                                   ec->level,
+                                   eci->transparency_mask,
+                                   eci->index);
+        new_rlc->object_ref = ec->object_ref;
+        new_rlc->type = ec->type;
+        new_rlc->level = ec->level;
+        new_rlc->transparency_mask = ec->transparency_mask;
+        ec = new_rlc;
       }
     }
   }
diff --git a/source/blender/gpencil_modifiers/intern/lineart/lineart_cpu.c b/source/blender/gpencil_modifiers/intern/lineart/lineart_cpu.c
index ef412f7fed4..d43b9a3426f 100644
--- a/source/blender/gpencil_modifiers/intern/lineart/lineart_cpu.c
+++ b/source/blender/gpencil_modifiers/intern/lineart/lineart_cpu.c
@@ -63,7 +63,7 @@
 static LineartBoundingArea *lineart_edge_first_bounding_area(LineartRenderBuffer *rb,
                                                              LineartEdge *e);
 
-static void lineart_bounding_area_link_line(LineartRenderBuffer *rb,
+static void lineart_bounding_area_link_edge(LineartRenderBuffer *rb,
                                             LineartBoundingArea *root_ba,
                                             LineartEdge *e);
 
@@ -86,14 +86,14 @@ static bool lineart_get_edge_bounding_areas(LineartRenderBuffer *rb,
 
 static void lineart_bounding_area_link_triangle(LineartRenderBuffer *rb,
                                                 LineartBoundingArea *root_ba,
-                                                LineartTriangle *rt,
+                                                LineartTriangle *tri,
                                                 double *LRUB,
                                                 int recursive,
                                                 int recursive_level,
                                                 bool do_intersection);
 
 static bool lineart_triangle_edge_image_space_occlusion(SpinLock *spl,
-                                                        const LineartTriangle *rt,
+                                                        const LineartTriangle *tri,
                                                         const LineartEdge *e,
                                                         const double *override_camera_loc,
                                                         const bool override_cam_is_persp,
@@ -107,35 +107,35 @@ static bool lineart_triangle_edge_image_space_occlusion(SpinLock *spl,
 
 static void lineart_add_edge_to_list(LineartRenderBuffer *rb, LineartEdge *e);
 
-static void lineart_discard_segment(LineartRenderBuffer *rb, LineartLineSegment *rls)
+static void lineart_discard_segment(LineartRenderBuffer *rb, LineartEdgeSegment *es)
 {
   BLI_spin_lock(&rb->lock_cuts);
 
-  memset(rls, 0, sizeof(LineartLineSegment));
+  memset(es, 0, sizeof(LineartEdgeSegment));
 
   /* Storing the node for potentially reuse the memory for new segment data.
    * Line Art data is not freed after all calculations are done. */
-  BLI_addtail(&rb->wasted_cuts, rls);
+  BLI_addtail(&rb->wasted_cuts, es);
 
   BLI_spin_unlock(&rb->lock_cuts);
 }
 
-static LineartLineSegment *lineart_give_segment(LineartRenderBuffer *rb)
+static LineartEdgeSegment *lineart_give_segment(LineartRenderBuffer *rb)
 {
   BLI_spin_lock(&rb->lock_cuts);
 
   /* See if there is any already allocated memory we can reuse. */
   if (rb->wasted_cuts.first) {
-    LineartLineSegment *rls = (LineartLineSegment *)BLI_pophead(&rb->wasted_cuts);
+    LineartEdgeSegment *es = (LineartEdgeSegment *)BLI_pophead(&rb->wasted_cuts);
     BLI_spin_unlock(&rb->lock_cuts);
-    memset(rls, 0, sizeof(LineartLineSegment));
-    return rls;
+    memset(es, 0, sizeof(LineartEdgeSegment));
+    return es;
   }
   BLI_spin_unlock(&rb->lock_cuts);
 
   /* Otherwise allocate some new memory. */
-  return (LineartLineSegment *)lineart_mem_acquire_thread(&rb->render_data_pool,
-                                                          sizeof(LineartLineSegment));
+  return (LineartEdgeSegment *)lineart_mem_acquire_thread(&rb->render_data_pool,
+                                                          sizeof(LineartEdgeSegment));
 }
 
 /**
@@ -144,9 +144,9 @@ static LineartLineSegment *lineart_give_segment(LineartRenderBuffer *rb)
 static void lineart_edge_cut(
     LineartRenderBuffer *rb, LineartEdge *e, double start, double end, uchar transparency_mask)
 {
-  LineartLineSegment *rls, *irls, *next_rls, *prev_rls;
-  LineartLineSegment *cut_start_before = 0, *cut_end_before = 0;
-  LineartLineSegment *ns = 0, *ns2 = 0;
+  LineartEdgeSegment *es, *ies, *next_es, *prev_es;
+  LineartEdgeSegment *cut_start_before = 0, *cut_end_before = 0;
+  LineartEdgeSegment *ns = 0, *ns2 = 0;
   int untouched = 0;
 
   /* If for some reason the occlusion function may give a result that has zero length, or reversed
@@ -173,18 +173,18 @@ static void lineart_edge_cut(
   /* 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 = e->segments.first; rls; rls = rls->next) {
-    if (LRT_DOUBLE_CLOSE_ENOUGH(rls->at, start)) {
-      cut_start_before = rls;
+  for (es = e->segments.first; es; es = es->next) {
+    if (LRT_DOUBLE_CLOSE_ENOUGH(es->at, start)) {
+      cut_start_before = es;
       ns = cut_start_before;
       break;
     }
-    if (rls->next == NULL) {
+    if (es->next == NULL) {
       break;
     }
-    irls = rls->next;
-    if (irls->at > start + 1e-09 && start > rls->at) {
-      cut_start_before = irls;
+    ies = es->next;
+    if (ies->at > start + 1e-09 && start > es->at) {
+      cut_start_before = ies;
       ns = lineart_give_segment(rb);
       break;
     }
@@ -192,25 +192,25 @@ static void lineart_edge_cut(
   if (!cut_start_before && LRT_DOUBLE_CLOSE_ENOUGH(1, end)) {
     untouched = 1;
   }
-  for (rls = cut_start_before; rls; rls = rls->next) {
+  for (es = cut_start_before; es; es = es->next) {
     /* We tried to cut at existing cutting point (e.g. where the line's occluded by a triangle
      * strip). */
-    if (LRT_DOUBLE_CLOSE_ENOUGH(rls->at, end)) {
-      cut_end_before = rls;
+    if (LRT_DOUBLE_CLOSE_ENOUGH(es->at, end)) {
+      cut_end_before = es;
       ns2 = cut_end_before;
       break;
     }
-    /* This check is to prevent `rls->at == 1.0` (where we don't need to cut because we are at the
+    /* This check is to prevent `es->at == 1.0` (where we don't need to cut because we are at the
      * end point). */
-    if (!rls->next && LRT_DOUBLE_CLOSE_ENOUGH(1, end)) {
-      cut_end_before = rls;
+    if (!es->next && LRT_DOUBLE_CLOSE_ENOUGH(1, end)) {
+      cut_end_before = es;
       ns2 = cut_end_before;
       untouched = 1;
       break;
     }
     /* When an actual cut is needed in the line. */
-    if (rls->at > end) {
-      cut_end_before = rls;
+    if (es->at > end) {
+      cut_end_before = es;
       ns2 = lineart_give_segment(rb);
       break;
     }
@@ -233,9 +233,9 @@ static void lineart_edge_cut(
   if (cut_start_before) {
     if (cut_start_before != ns) {
       /* Insert cutting points for when a new cut is needed. */
-      irls = cut_start_before->prev ? cut_start_before->prev : NULL;
-      ns->occlusion = irls ? irls->occlusion : 0;
-      ns->transparency_mask = irls->transparency_mask;
+      ies = cut_start_before->prev ? cut_start_before->prev : NULL;
+      ns->occlusion = ies ? ies->occlusion : 0;
+      ns->transparency_mask = ies->transparency_mask;
       BLI_insertlinkbefore(&e->segments, cut_start_before, ns);
     }
     /* Otherwise we already found a existing cutting point, no need to insert a new one. */
@@ -243,24 +243,24 @@ static void lineart_edge_cut(
   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 = e->segments.last;
-    ns->occlusion = irls->occlusion;
-    ns->transparency_mask = irls->transparency_mask;
+    ies = e->segments.last;
+    ns->occlusion = ies->occlusion;
+    ns->transparency_mask = ies->transparency_mask;
     BLI_addtail(&e->segments, ns);
   }
   if (cut_end_before) {
     /* The same manipulation as on "cut_start_before". */
     if (cut_end_before != ns2) {
-      irls = cut_end_before->prev ? cut_end_before->prev : NULL;
-      ns2->occlusion = irls ? irls->occlusion : 0;
-      ns2->transparency_mask = irls ? irls->transparency_mask : 0;
+      ies = cut_end_before->prev ? cut_end_before->prev : NULL;
+      ns2->occlusion = ies ? ies->occlusion : 0;
+      ns2->transparency_mask = ies ? ies->transparency_mask : 0;
       BLI_insertlinkbefore(&e->segments, cut_end_before, ns2);
     }
   }
   else {
-    irls = e->segments.last;
-    ns2->occlusion = irls->occlusion;
-    ns2->transparency_mask = irls->transparency_mask;
+    ies = e->segments.last;
+    ns2->occlusion = ies->occlusion;
+    ns2->transparency_mask = ies->transparency_mask;
     BLI_addtail(&e->segments, ns2);
   }
 
@@ -276,29 +276,29 @@ static void lineart_edge_cut(
   }
 
   /* Register 1 level of occlusion for all touched segments. */
-  for (rls = ns; rls && rls != ns2; rls = rls->next) {
-    rls->occlusion++;
-    rls->transparency_mask |= transparency_mask;
+  for (es = ns; es && es != ns2; es = es->next) {
+    es->occlusion++;
+    es->transparency_mask |= transparency_mask;
   }
 
   /* Reduce adjacent cutting points of the same level, which saves memory. */
   char min_occ = 127;
-  prev_rls = NULL;
-  for (rls = e->segments.first; rls; rls = next_rls) {
-    next_rls = rls->next;
+  prev_es = NULL;
+  for (es = e->segments.first; es; es = next_es) {
+    next_es = es->next;
 
-    if (prev_rls && prev_rls->occlusion == rls->occlusion &&
-        prev_rls->transparency_mask == rls->transparency_mask) {
-      BLI_remlink(&e->segments, rls);
+    if (prev_es && prev_es->occlusion == es->occlusion &&
+        prev_es->transparency_mask == es->transparency_mask) {
+      BLI_remlink(&e->segments, es);
       /* This puts the node back to the render buffer, if more cut happens, these unused nodes get
        * picked first. */
-      lineart_discard_segment(rb, rls);
+      lineart_discard_segment(rb, es);
       continue;
     }
 
-    min_occ = MIN2(min_occ, rls->occlusion);
+    min_occ = MIN2(min_occ, es->occlusion);
 
-    prev_rls = rls;
+    prev_es = es;
   }
   e->min_occ = min_occ;
 }
@@ -306,12 +306,12 @@ static void lineart_edge_cut(
 /**
  * To see if given line is connected to an adjacent intersection line.
  */
-BLI_INLINE bool lineart_occlusion_is_adjacent_intersection(LineartEdge *e, LineartTriangle *rt)
+BLI_INLINE bool lineart_occlusion_is_adjacent_intersection(LineartEdge *e, LineartTriangle *tri)
 {
   LineartVertIntersection *v1 = (void *)e->v1;
   LineartVertIntersection *v2 = (void *)e->v2;
-  return ((v1->base.flag && v1->intersecting_with == rt) ||
-          (v2->base.flag && v2->intersecting_with == rt));
+  return ((v1->base.flag && v1->intersecting_with == tri) ||
+          (v2->base.flag && v2->intersecting_with == tri));
 }
 
 static void lineart_occlusion_single_line(LineartRenderBuffer *rb, LineartEdge *e, int thread_id)
@@ -319,7 +319,7 @@ static void lineart_occlusion_single_line(LineartRenderBuffer *rb, LineartEdge *
   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;
+  LineartTriangleThread *tri;
 
   /* These values are used for marching along the line. */
   double l, r;
@@ -335,15 +335,15 @@ static void lineart_occlusion_single_line(LineartRenderBuffer *rb, LineartEdge *
   while (nba) {
 
     LISTBASE_FOREACH (LinkData *, lip, &nba->linked_triangles) {
-      rt = lip->data;
+      tri = lip->data;
       /* If we are already testing the line in this thread, then don't do it. */
-      if (rt->testing_e[thread_id] == e || (rt->base.flags & LRT_TRIANGLE_INTERSECTION_ONLY) ||
-          lineart_occlusion_is_adjacent_intersection(e, (LineartTriangle *)rt)) {
+      if (tri->testing_e[thread_id] == e || (tri->base.flags & LRT_TRIANGLE_INTERSECTION_ONLY) ||
+          lineart_occlusion_is_adjacent_intersection(e, (LineartTriangle *)tri)) {
         continue;
       }
-      rt->testing_e[thread_id] = e;
+      tri->testing_e[thread_id] = e;
       if (lineart_triangle_edge_image_space_occlusion(&rb->lock_task,
-                                                      (const LineartTriangle *)rt,
+                                                      (const LineartTriangle *)tri,
                                                       e,
                                                       rb->camera_pos,
                                                       rb->cam_is_persp,
@@ -354,7 +354,7 @@ static void lineart_occlusion_single_line(LineartRenderBuffer *rb, LineartEdge *
                                                       rb->shift_y,
                                                       &l,
                                                       &r)) {
-        lineart_edge_cut(rb, e, l, r, rt->base.transparency_mask);
+        lineart_edge_cut(rb, e, l, r, tri->base.transparency_mask);
         if (e->min_occ > rb->max_occlusion_level) {
           /* No need to calculate any longer on this line because no level more than set value is
            * going to show up in the rendered result. */
@@ -678,24 +678,24 @@ static LineartElementLinkNode *lineart_memory_get_edge_space(LineartRenderBuffer
   return reln;
 }
 
-static void lineart_triangle_post(LineartTriangle *rt, LineartTriangle *orig)
+static void lineart_triangle_post(LineartTriangle *tri, LineartTriangle *orig)
 {
   /* Just re-assign normal and set cull flag. */
-  copy_v3_v3_db(rt->gn, orig->gn);
-  rt->flags = LRT_CULL_GENERATED;
+  copy_v3_v3_db(tri->gn, orig->gn);
+  tri->flags = LRT_CULL_GENERATED;
 }
 
-static void lineart_triangle_set_cull_flag(LineartTriangle *rt, uchar flag)
+static void lineart_triangle_set_cull_flag(LineartTriangle *tri, uchar flag)
 {
-  uchar intersection_only = (rt->flags & LRT_TRIANGLE_INTERSECTION_ONLY);
-  rt->flags = flag;
-  rt->flags |= intersection_only;
+  uchar intersection_only = (tri->flags & LRT_TRIANGLE_INTERSECTION_ONLY);
+  tri->flags = flag;
+  tri->flags |= intersection_only;
 }
 
-static bool lineart_edge_match(LineartTriangle *rt, LineartEdge *e, int v1, int v2)
+static bool lineart_edge_match(LineartTriangle *tri, LineartEdge *e, int v1, int v2)
 {
-  return ((rt->v[v1] == e->v1 && rt->v[v2] == e->v2) ||
-          (rt->v[v2] == e->v1 && rt->v[v1] == e->v2));
+  return ((tri->v[v1] == e->v1 && tri->v[v2] == e->v2) ||
+          (tri->v[v2] == e->v1 && tri->v[v1] == e->v2));
 }
 
 /**
@@ -703,7 +703,7 @@ static bool lineart_edge_match(LineartTriangle *rt, LineartEdge *e, int v1, int
  * reversed by the caller so don't need to implement one in a different direction.
  */
 static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
-                                         LineartTriangle *rt,
+                                         LineartTriangle *tri,
                                          int in0,
                                          int in1,
                                          int in2,
@@ -728,26 +728,26 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
   char new_flag = 0;
 
   LineartEdge *new_e, *e, *old_e;
-  LineartLineSegment *rls;
-  LineartTriangleAdjacent *rta;
+  LineartEdgeSegment *es;
+  LineartTriangleAdjacent *ta;
 
-  if (rt->flags & (LRT_CULL_USED | LRT_CULL_GENERATED | LRT_CULL_DISCARD)) {
+  if (tri->flags & (LRT_CULL_USED | LRT_CULL_GENERATED | LRT_CULL_DISCARD)) {
     return;
   }
 
-  /* See definition of rt->intersecting_verts and the usage in
+  /* See definition of tri->intersecting_verts and the usage in
    * lineart_geometry_object_load() for details. */
-  rta = (void *)rt->intersecting_verts;
+  ta = (void *)tri->intersecting_verts;
 
-  LineartVert *rv = &((LineartVert *)v_eln->pointer)[v_count];
-  LineartTriangle *rt1 = (void *)(((uchar *)t_eln->pointer) + rb->triangle_size * t_count);
-  LineartTriangle *rt2 = (void *)(((uchar *)t_eln->pointer) + rb->triangle_size * (t_count + 1));
+  LineartVert *vt = &((LineartVert *)v_eln->pointer)[v_count];
+  LineartTriangle *tri1 = (void *)(((uchar *)t_eln->pointer) + rb->triangle_size * t_count);
+  LineartTriangle *tri2 = (void *)(((uchar *)t_eln->pointer) + rb->triangle_size * (t_count + 1));
 
   new_e = &((LineartEdge *)e_eln->pointer)[e_count];
-  /* Init `rl` to the last `rl` entry. */
+  /* Init `edge` to the last `edge` entry. */
   e = new_e;
 
-#define INCREASE_RL \
+#define INCREASE_EDGE \
   e_count++; \
   v1_obi = e->v1_obindex; \
   v2_obi = e->v2_obindex; \
@@ -755,40 +755,40 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
   e = new_e; \
   e->v1_obindex = v1_obi; \
   e->v2_obindex = v2_obi; \
-  rls = lineart_mem_acquire(&rb->render_data_pool, sizeof(LineartLineSegment)); \
-  BLI_addtail(&e->segments, rls);
+  es = lineart_mem_acquire(&rb->render_data_pool, sizeof(LineartEdgeSegment)); \
+  BLI_addtail(&e->segments, es);
 
-#define SELECT_RL(e_num, v1_link, v2_link, newrt) \
-  if (rta->e[e_num]) { \
-    old_e = rta->e[e_num]; \
+#define SELECT_EDGE(e_num, v1_link, v2_link, new_tri) \
+  if (ta->e[e_num]) { \
+    old_e = ta->e[e_num]; \
     new_flag = old_e->flags; \
     old_e->flags = LRT_EDGE_FLAG_CHAIN_PICKED; \
-    INCREASE_RL \
+    INCREASE_EDGE \
     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)); \
+    e->t1 = ((old_e->t1 == tri) ? (new_tri) : (old_e->t1)); \
+    e->t2 = ((old_e->t2 == tri) ? (new_tri) : (old_e->t2)); \
     lineart_add_edge_to_list(rb, e); \
   }
 
-#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 RELINK_EDGE(e_num, new_tri) \
+  if (ta->e[e_num]) { \
+    old_e = ta->e[e_num]; \
+    old_e->t1 = ((old_e->t1 == tri) ? (new_tri) : (old_e->t1)); \
+    old_e->t2 = ((old_e->t2 == tri) ? (new_tri) : (old_e->t2)); \
   }
 
-#define REMOVE_TRIANGLE_RL \
-  if (rta->e[0]) { \
-    rta->e[0]->flags = LRT_EDGE_FLAG_CHAIN_PICKED; \
+#define REMOVE_TRIANGLE_EDGE \
+  if (ta->e[0]) { \
+    ta->e[0]->flags = LRT_EDGE_FLAG_CHAIN_PICKED; \
   } \
-  if (rta->e[1]) { \
-    rta->e[1]->flags = LRT_EDGE_FLAG_CHAIN_PICKED; \
+  if (ta->e[1]) { \
+    ta->e[1]->flags = LRT_EDGE_FLAG_CHAIN_PICKED; \
   } \
-  if (rta->e[2]) { \
-    rta->e[2]->flags = LRT_EDGE_FLAG_CHAIN_PICKED; \
+  if (ta->e[2]) { \
+    ta->e[2]->flags = LRT_EDGE_FLAG_CHAIN_PICKED; \
   }
 
   switch (in0 + in1 + in2) {
@@ -797,13 +797,13 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
     case 3:
       /* Triangle completely behind near plane, throw it away
        * also remove render lines form being computed. */
-      lineart_triangle_set_cull_flag(rt, LRT_CULL_DISCARD);
-      REMOVE_TRIANGLE_RL
+      lineart_triangle_set_cull_flag(tri, LRT_CULL_DISCARD);
+      REMOVE_TRIANGLE_EDGE
       return;
     case 2:
       /* Two points behind near plane, cut those and
        * generate 2 new points, 3 lines and 1 triangle. */
-      lineart_triangle_set_cull_flag(rt, LRT_CULL_USED);
+      lineart_triangle_set_cull_flag(tri, LRT_CULL_USED);
 
       /**
        * (!in0) means "when point 0 is visible".
@@ -828,136 +828,136 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
       if (!in0) {
 
         /* Cut point for line 2---|-----0. */
-        sub_v3_v3v3_db(vv1, rt->v[0]->gloc, cam_pos);
-        sub_v3_v3v3_db(vv2, cam_pos, rt->v[2]->gloc);
+        sub_v3_v3v3_db(vv1, tri->v[0]->gloc, cam_pos);
+        sub_v3_v3v3_db(vv2, cam_pos, tri->v[2]->gloc);
         dot1 = dot_v3v3_db(vv1, view_dir);
         dot2 = dot_v3v3_db(vv2, view_dir);
         a = dot1 / (dot1 + dot2);
         /* Assign it to a new point. */
-        interp_v3_v3v3_db(rv[0].gloc, rt->v[0]->gloc, rt->v[2]->gloc, a);
-        mul_v4_m4v3_db(rv[0].fbcoord, vp, rv[0].gloc);
-        rv[0].index = rt->v[2]->index;
+        interp_v3_v3v3_db(vt[0].gloc, tri->v[0]->gloc, tri->v[2]->gloc, a);
+        mul_v4_m4v3_db(vt[0].fbcoord, vp, vt[0].gloc);
+        vt[0].index = tri->v[2]->index;
 
         /* Cut point for line 1---|-----0. */
-        sub_v3_v3v3_db(vv1, rt->v[0]->gloc, cam_pos);
-        sub_v3_v3v3_db(vv2, cam_pos, rt->v[1]->gloc);
+        sub_v3_v3v3_db(vv1, tri->v[0]->gloc, cam_pos);
+        sub_v3_v3v3_db(vv2, cam_pos, tri->v[1]->gloc);
         dot1 = dot_v3v3_db(vv1, view_dir);
         dot2 = dot_v3v3_db(vv2, view_dir);
         a = dot1 / (dot1 + dot2);
         /* Assign it to another new point. */
-        interp_v3_v3v3_db(rv[1].gloc, rt->v[0]->gloc, rt->v[1]->gloc, a);
-        mul_v4_m4v3_db(rv[1].fbcoord, vp, rv[1].gloc);
-        rv[1].index = rt->v[1]->index;
+        interp_v3_v3v3_db(vt[1].gloc, tri->v[0]->gloc, tri->v[1]->gloc, a);
+        mul_v4_m4v3_db(vt[1].fbcoord, vp, vt[1].gloc);
+        vt[1].index = tri->v[1]->index;
 
         /* New line connecting two new points. */
-        INCREASE_RL
+        INCREASE_EDGE
         if (allow_boundaries) {
           e->flags = LRT_EDGE_FLAG_CONTOUR;
           lineart_prepend_edge_direct(&rb->contours, e);
         }
         /* 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
+         * `tri->edge` and `tri->v` has the same sequence. and the winding direction
          * can be either CW or CCW but needs to be consistent throughout the calculation. */
-        e->v1 = &rv[1];
-        e->v2 = &rv[0];
+        e->v1 = &vt[1];
+        e->v2 = &vt[0];
         /* Only one adjacent triangle, because the other side is the near plane. */
         /* Use `tl` or `tr` doesn't matter. */
-        e->t1 = rt1;
+        e->t1 = tri1;
         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)
+        SELECT_EDGE(2, tri->v[0], &vt[0], tri1)
         /* New line connecting original point 0 and another new point. */
-        SELECT_RL(0, rt->v[0], &rv[1], rt1)
+        SELECT_EDGE(0, tri->v[0], &vt[1], tri1)
 
         /* Re-assign triangle point array to two new points. */
-        rt1->v[0] = rt->v[0];
-        rt1->v[1] = &rv[1];
-        rt1->v[2] = &rv[0];
+        tri1->v[0] = tri->v[0];
+        tri1->v[1] = &vt[1];
+        tri1->v[2] = &vt[0];
 
-        lineart_triangle_post(rt1, rt);
+        lineart_triangle_post(tri1, tri);
 
         v_count += 2;
         t_count += 1;
       }
       else if (!in2) {
-        sub_v3_v3v3_db(vv1, rt->v[2]->gloc, cam_pos);
-        sub_v3_v3v3_db(vv2, cam_pos, rt->v[0]->gloc);
+        sub_v3_v3v3_db(vv1, tri->v[2]->gloc, cam_pos);
+        sub_v3_v3v3_db(vv2, cam_pos, tri->v[0]->gloc);
         dot1 = dot_v3v3_db(vv1, view_dir);
         dot2 = dot_v3v3_db(vv2, view_dir);
         a = dot1 / (dot1 + dot2);
-        interp_v3_v3v3_db(rv[0].gloc, rt->v[2]->gloc, rt->v[0]->gloc, a);
-        mul_v4_m4v3_db(rv[0].fbcoord, vp, rv[0].gloc);
-        rv[0].index = rt->v[0]->index;
+        interp_v3_v3v3_db(vt[0].gloc, tri->v[2]->gloc, tri->v[0]->gloc, a);
+        mul_v4_m4v3_db(vt[0].fbcoord, vp, vt[0].gloc);
+        vt[0].index = tri->v[0]->index;
 
-        sub_v3_v3v3_db(vv1, rt->v[2]->gloc, cam_pos);
-        sub_v3_v3v3_db(vv2, cam_pos, rt->v[1]->gloc);
+        sub_v3_v3v3_db(vv1, tri->v[2]->gloc, cam_pos);
+        sub_v3_v3v3_db(vv2, cam_pos, tri->v[1]->gloc);
         dot1 = dot_v3v3_db(vv1, view_dir);
         dot2 = dot_v3v3_db(vv2, view_dir);
         a = dot1 / (dot1 + dot2);
-        interp_v3_v3v3_db(rv[1].gloc, rt->v[2]->gloc, rt->v[1]->gloc, a);
-        mul_v4_m4v3_db(rv[1].fbcoord, vp, rv[1].gloc);
-        rv[1].index = rt->v[1]->index;
+        interp_v3_v3v3_db(vt[1].gloc, tri->v[2]->gloc, tri->v[1]->gloc, a);
+        mul_v4_m4v3_db(vt[1].fbcoord, vp, vt[1].gloc);
+        vt[1].index = tri->v[1]->index;
 
-        INCREASE_RL
+        INCREASE_EDGE
         if (allow_boundaries) {
           e->flags = LRT_EDGE_FLAG_CONTOUR;
           lineart_prepend_edge_direct(&rb->contours, e);
         }
-        e->v1 = &rv[0];
-        e->v2 = &rv[1];
-        e->t1 = rt1;
+        e->v1 = &vt[0];
+        e->v2 = &vt[1];
+        e->t1 = tri1;
         e->object_ref = ob;
 
-        SELECT_RL(2, rt->v[2], &rv[0], rt1)
-        SELECT_RL(1, rt->v[2], &rv[1], rt1)
+        SELECT_EDGE(2, tri->v[2], &vt[0], tri1)
+        SELECT_EDGE(1, tri->v[2], &vt[1], tri1)
 
-        rt1->v[0] = &rv[0];
-        rt1->v[1] = &rv[1];
-        rt1->v[2] = rt->v[2];
+        tri1->v[0] = &vt[0];
+        tri1->v[1] = &vt[1];
+        tri1->v[2] = tri->v[2];
 
-        lineart_triangle_post(rt1, rt);
+        lineart_triangle_post(tri1, tri);
 
         v_count += 2;
         t_count += 1;
       }
       else if (!in1) {
-        sub_v3_v3v3_db(vv1, rt->v[1]->gloc, cam_pos);
-        sub_v3_v3v3_db(vv2, cam_pos, rt->v[2]->gloc);
+        sub_v3_v3v3_db(vv1, tri->v[1]->gloc, cam_pos);
+        sub_v3_v3v3_db(vv2, cam_pos, tri->v[2]->gloc);
         dot1 = dot_v3v3_db(vv1, view_dir);
         dot2 = dot_v3v3_db(vv2, view_dir);
         a = dot1 / (dot1 + dot2);
-        interp_v3_v3v3_db(rv[0].gloc, rt->v[1]->gloc, rt->v[2]->gloc, a);
-        mul_v4_m4v3_db(rv[0].fbcoord, vp, rv[0].gloc);
-        rv[0].index = rt->v[2]->index;
+        interp_v3_v3v3_db(vt[0].gloc, tri->v[1]->gloc, tri->v[2]->gloc, a);
+        mul_v4_m4v3_db(vt[0].fbcoord, vp, vt[0].gloc);
+        vt[0].index = tri->v[2]->index;
 
-        sub_v3_v3v3_db(vv1, rt->v[1]->gloc, cam_pos);
-        sub_v3_v3v3_db(vv2, cam_pos, rt->v[0]->gloc);
+        sub_v3_v3v3_db(vv1, tri->v[1]->gloc, cam_pos);
+        sub_v3_v3v3_db(vv2, cam_pos, tri->v[0]->gloc);
         dot1 = dot_v3v3_db(vv1, view_dir);
         dot2 = dot_v3v3_db(vv2, view_dir);
         a = dot1 / (dot1 + dot2);
-        interp_v3_v3v3_db(rv[1].gloc, rt->v[1]->gloc, rt->v[0]->gloc, a);
-        mul_v4_m4v3_db(rv[1].fbcoord, vp, rv[1].gloc);
-        rv[1].index = rt->v[0]->index;
+        interp_v3_v3v3_db(vt[1].gloc, tri->v[1]->gloc, tri->v[0]->gloc, a);
+        mul_v4_m4v3_db(vt[1].fbcoord, vp, vt[1].gloc);
+        vt[1].index = tri->v[0]->index;
 
-        INCREASE_RL
+        INCREASE_EDGE
         if (allow_boundaries) {
           e->flags = LRT_EDGE_FLAG_CONTOUR;
           lineart_prepend_edge_direct(&rb->contours, e);
         }
-        e->v1 = &rv[1];
-        e->v2 = &rv[0];
-        e->t1 = rt1;
+        e->v1 = &vt[1];
+        e->v2 = &vt[0];
+        e->t1 = tri1;
         e->object_ref = ob;
 
-        SELECT_RL(1, rt->v[1], &rv[0], rt1)
-        SELECT_RL(0, rt->v[1], &rv[1], rt1)
+        SELECT_EDGE(1, tri->v[1], &vt[0], tri1)
+        SELECT_EDGE(0, tri->v[1], &vt[1], tri1)
 
-        rt1->v[0] = &rv[0];
-        rt1->v[1] = rt->v[1];
-        rt1->v[2] = &rv[1];
+        tri1->v[0] = &vt[0];
+        tri1->v[1] = tri->v[1];
+        tri1->v[2] = &vt[1];
 
-        lineart_triangle_post(rt1, rt);
+        lineart_triangle_post(tri1, tri);
 
         v_count += 2;
         t_count += 1;
@@ -966,7 +966,7 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
     case 1:
       /* One point behind near plane, cut those and
        * generate 2 new points, 4 lines and 2 triangles. */
-      lineart_triangle_set_cull_flag(rt, LRT_CULL_USED);
+      lineart_triangle_set_cull_flag(tri, LRT_CULL_USED);
 
       /**
        * (in0) means "when point 0 is invisible".
@@ -993,152 +993,152 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
        */
       if (in0) {
         /* Cut point for line 0---|------1. */
-        sub_v3_v3v3_db(vv1, rt->v[1]->gloc, cam_pos);
-        sub_v3_v3v3_db(vv2, cam_pos, rt->v[0]->gloc);
+        sub_v3_v3v3_db(vv1, tri->v[1]->gloc, cam_pos);
+        sub_v3_v3v3_db(vv2, cam_pos, tri->v[0]->gloc);
         dot1 = dot_v3v3_db(vv1, view_dir);
         dot2 = dot_v3v3_db(vv2, view_dir);
         a = dot2 / (dot1 + dot2);
         /* Assign to a new point. */
-        interp_v3_v3v3_db(rv[0].gloc, rt->v[0]->gloc, rt->v[1]->gloc, a);
-        mul_v4_m4v3_db(rv[0].fbcoord, vp, rv[0].gloc);
-        rv[0].index = rt->v[0]->index;
+        interp_v3_v3v3_db(vt[0].gloc, tri->v[0]->gloc, tri->v[1]->gloc, a);
+        mul_v4_m4v3_db(vt[0].fbcoord, vp, vt[0].gloc);
+        vt[0].index = tri->v[0]->index;
 
         /* Cut point for line 0---|------2. */
-        sub_v3_v3v3_db(vv1, rt->v[2]->gloc, cam_pos);
-        sub_v3_v3v3_db(vv2, cam_pos, rt->v[0]->gloc);
+        sub_v3_v3v3_db(vv1, tri->v[2]->gloc, cam_pos);
+        sub_v3_v3v3_db(vv2, cam_pos, tri->v[0]->gloc);
         dot1 = dot_v3v3_db(vv1, view_dir);
         dot2 = dot_v3v3_db(vv2, view_dir);
         a = dot2 / (dot1 + dot2);
         /* Assign to other new point. */
-        interp_v3_v3v3_db(rv[1].gloc, rt->v[0]->gloc, rt->v[2]->gloc, a);
-        mul_v4_m4v3_db(rv[1].fbcoord, vp, rv[1].gloc);
-        rv[1].index = rt->v[0]->index;
+        interp_v3_v3v3_db(vt[1].gloc, tri->v[0]->gloc, tri->v[2]->gloc, a);
+        mul_v4_m4v3_db(vt[1].fbcoord, vp, vt[1].gloc);
+        vt[1].index = tri->v[0]->index;
 
         /* New line connects two new points. */
-        INCREASE_RL
+        INCREASE_EDGE
         if (allow_boundaries) {
           e->flags = LRT_EDGE_FLAG_CONTOUR;
           lineart_prepend_edge_direct(&rb->contours, e);
         }
-        e->v1 = &rv[1];
-        e->v2 = &rv[0];
-        e->t1 = rt1;
+        e->v1 = &vt[1];
+        e->v2 = &vt[0];
+        e->t1 = tri1;
         e->object_ref = ob;
 
         /* New line connects new point 0 and old point 1,
          * this is a border line. */
 
-        SELECT_RL(0, rt->v[1], &rv[0], rt1)
-        SELECT_RL(2, rt->v[2], &rv[1], rt2)
-        RELINK_RL(1, rt2)
+        SELECT_EDGE(0, tri->v[1], &vt[0], tri1)
+        SELECT_EDGE(2, tri->v[2], &vt[1], tri2)
+        RELINK_EDGE(1, tri2)
 
         /* We now have one triangle closed. */
-        rt1->v[0] = rt->v[1];
-        rt1->v[1] = &rv[1];
-        rt1->v[2] = &rv[0];
+        tri1->v[0] = tri->v[1];
+        tri1->v[1] = &vt[1];
+        tri1->v[2] = &vt[0];
         /* Close the second triangle. */
-        rt2->v[0] = &rv[1];
-        rt2->v[1] = rt->v[1];
-        rt2->v[2] = rt->v[2];
+        tri2->v[0] = &vt[1];
+        tri2->v[1] = tri->v[1];
+        tri2->v[2] = tri->v[2];
 
-        lineart_triangle_post(rt1, rt);
-        lineart_triangle_post(rt2, rt);
+        lineart_triangle_post(tri1, tri);
+        lineart_triangle_post(tri2, tri);
 
         v_count += 2;
         t_count += 2;
       }
       else if (in1) {
 
-        sub_v3_v3v3_db(vv1, rt->v[1]->gloc, cam_pos);
-        sub_v3_v3v3_db(vv2, cam_pos, rt->v[2]->gloc);
+        sub_v3_v3v3_db(vv1, tri->v[1]->gloc, cam_pos);
+        sub_v3_v3v3_db(vv2, cam_pos, tri->v[2]->gloc);
         dot1 = dot_v3v3_db(vv1, view_dir);
         dot2 = dot_v3v3_db(vv2, view_dir);
         a = dot1 / (dot1 + dot2);
-        interp_v3_v3v3_db(rv[0].gloc, rt->v[1]->gloc, rt->v[2]->gloc, a);
-        mul_v4_m4v3_db(rv[0].fbcoord, vp, rv[0].gloc);
-        rv[0].index = rt->v[1]->index;
+        interp_v3_v3v3_db(vt[0].gloc, tri->v[1]->gloc, tri->v[2]->gloc, a);
+        mul_v4_m4v3_db(vt[0].fbcoord, vp, vt[0].gloc);
+        vt[0].index = tri->v[1]->index;
 
-        sub_v3_v3v3_db(vv1, rt->v[1]->gloc, cam_pos);
-        sub_v3_v3v3_db(vv2, cam_pos, rt->v[0]->gloc);
+        sub_v3_v3v3_db(vv1, tri->v[1]->gloc, cam_pos);
+        sub_v3_v3v3_db(vv2, cam_pos, tri->v[0]->gloc);
         dot1 = dot_v3v3_db(vv1, view_dir);
         dot2 = dot_v3v3_db(vv2, view_dir);
         a = dot1 / (dot1 + dot2);
-        interp_v3_v3v3_db(rv[1].gloc, rt->v[1]->gloc, rt->v[0]->gloc, a);
-        mul_v4_m4v3_db(rv[1].fbcoord, vp, rv[1].gloc);
-        rv[1].index = rt->v[1]->index;
+        interp_v3_v3v3_db(vt[1].gloc, tri->v[1]->gloc, tri->v[0]->gloc, a);
+        mul_v4_m4v3_db(vt[1].fbcoord, vp, vt[1].gloc);
+        vt[1].index = tri->v[1]->index;
 
-        INCREASE_RL
+        INCREASE_EDGE
         if (allow_boundaries) {
           e->flags = LRT_EDGE_FLAG_CONTOUR;
           lineart_prepend_edge_direct(&rb->contours, e);
         }
-        e->v1 = &rv[1];
-        e->v2 = &rv[0];
-        e->t1 = rt1;
+        e->v1 = &vt[1];
+        e->v2 = &vt[0];
+        e->t1 = tri1;
         e->object_ref = ob;
 
-        SELECT_RL(1, rt->v[2], &rv[0], rt1)
-        SELECT_RL(0, rt->v[0], &rv[1], rt2)
-        RELINK_RL(2, rt2)
+        SELECT_EDGE(1, tri->v[2], &vt[0], tri1)
+        SELECT_EDGE(0, tri->v[0], &vt[1], tri2)
+        RELINK_EDGE(2, tri2)
 
-        rt1->v[0] = rt->v[2];
-        rt1->v[1] = &rv[1];
-        rt1->v[2] = &rv[0];
+        tri1->v[0] = tri->v[2];
+        tri1->v[1] = &vt[1];
+        tri1->v[2] = &vt[0];
 
-        rt2->v[0] = &rv[1];
-        rt2->v[1] = rt->v[2];
-        rt2->v[2] = rt->v[0];
+        tri2->v[0] = &vt[1];
+        tri2->v[1] = tri->v[2];
+        tri2->v[2] = tri->v[0];
 
-        lineart_triangle_post(rt1, rt);
-        lineart_triangle_post(rt2, rt);
+        lineart_triangle_post(tri1, tri);
+        lineart_triangle_post(tri2, tri);
 
         v_count += 2;
         t_count += 2;
       }
       else if (in2) {
 
-        sub_v3_v3v3_db(vv1, rt->v[2]->gloc, cam_pos);
-        sub_v3_v3v3_db(vv2, cam_pos, rt->v[0]->gloc);
+        sub_v3_v3v3_db(vv1, tri->v[2]->gloc, cam_pos);
+        sub_v3_v3v3_db(vv2, cam_pos, tri->v[0]->gloc);
         dot1 = dot_v3v3_db(vv1, view_dir);
         dot2 = dot_v3v3_db(vv2, view_dir);
         a = dot1 / (dot1 + dot2);
-        interp_v3_v3v3_db(rv[0].gloc, rt->v[2]->gloc, rt->v[0]->gloc, a);
-        mul_v4_m4v3_db(rv[0].fbcoord, vp, rv[0].gloc);
-        rv[0].index = rt->v[2]->index;
+        interp_v3_v3v3_db(vt[0].gloc, tri->v[2]->gloc, tri->v[0]->gloc, a);
+        mul_v4_m4v3_db(vt[0].fbcoord, vp, vt[0].gloc);
+        vt[0].index = tri->v[2]->index;
 
-        sub_v3_v3v3_db(vv1, rt->v[2]->gloc, cam_pos);
-        sub_v3_v3v3_db(vv2, cam_pos, rt->v[1]->gloc);
+        sub_v3_v3v3_db(vv1, tri->v[2]->gloc, cam_pos);
+        sub_v3_v3v3_db(vv2, cam_pos, tri->v[1]->gloc);
         dot1 = dot_v3v3_db(vv1, view_dir);
         dot2 = dot_v3v3_db(vv2, view_dir);
         a = dot1 / (dot1 + dot2);
-        interp_v3_v3v3_db(rv[1].gloc, rt->v[2]->gloc, rt->v[1]->gloc, a);
-        mul_v4_m4v3_db(rv[1].fbcoord, vp, rv[1].gloc);
-        rv[1].index = rt->v[2]->index;
+        interp_v3_v3v3_db(vt[1].gloc, tri->v[2]->gloc, tri->v[1]->gloc, a);
+        mul_v4_m4v3_db(vt[1].fbcoord, vp, vt[1].gloc);
+        vt[1].index = tri->v[2]->index;
 
-        INCREASE_RL
+        INCREASE_EDGE
         if (allow_boundaries) {
           e->flags = LRT_EDGE_FLAG_CONTOUR;
           lineart_prepend_edge_direct(&rb->contours, e);
         }
-        e->v1 = &rv[1];
-        e->v2 = &rv[0];
-        e->t1 = rt1;
+        e->v1 = &vt[1];
+        e->v2 = &vt[0];
+        e->t1 = tri1;
         e->object_ref = ob;
 
-        SELECT_RL(2, rt->v[0], &rv[0], rt1)
-        SELECT_RL(1, rt->v[1], &rv[1], rt2)
-        RELINK_RL(0, rt2)
+        SELECT_EDGE(2, tri->v[0], &vt[0], tri1)
+        SELECT_EDGE(1, tri->v[1], &vt[1], tri2)
+        RELINK_EDGE(0, tri2)
 
-        rt1->v[0] = rt->v[0];
-        rt1->v[1] = &rv[1];
-        rt1->v[2] = &rv[0];
+        tri1->v[0] = tri->v[0];
+        tri1->v[1] = &vt[1];
+        tri1->v[2] = &vt[0];
 
-        rt2->v[0] = &rv[1];
-        rt2->v[1] = rt->v[0];
-        rt2->v[2] = rt->v[1];
+        tri2->v[0] = &vt[1];
+        tri2->v[1] = tri->v[0];
+        tri2->v[2] = tri->v[1];
 
-        lineart_triangle_post(rt1, rt);
-        lineart_triangle_post(rt2, rt);
+        lineart_triangle_post(tri1, tri);
+        lineart_triangle_post(tri2, tri);
 
         v_count += 2;
         t_count += 2;
@@ -1149,10 +1149,10 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
   *r_e_count = e_count;
   *r_t_count = t_count;
 
-#undef INCREASE_RL
-#undef SELECT_RL
-#undef RELINK_RL
-#undef REMOVE_TRIANGLE_RL
+#undef INCREASE_EDGE
+#undef SELECT_EDGE
+#undef RELINK_EDGE
+#undef REMOVE_TRIANGLE_EDGE
 }
 
 /**
@@ -1163,7 +1163,7 @@ static void lineart_triangle_cull_single(LineartRenderBuffer *rb,
  */
 static void lineart_main_cull_triangles(LineartRenderBuffer *rb, bool clip_far)
 {
-  LineartTriangle *rt;
+  LineartTriangle *tri;
   LineartElementLinkNode *v_eln, *t_eln, *e_eln;
   double(*vp)[4] = rb->view_projection;
   int i;
@@ -1219,25 +1219,25 @@ static void lineart_main_cull_triangles(LineartRenderBuffer *rb, bool clip_far)
   in0 = 0, in1 = 0, in2 = 0; \
   if (clip_far) { \
     /* Point outside far plane. */ \
-    if (rt->v[0]->fbcoord[use_w] > clip_end) { \
+    if (tri->v[0]->fbcoord[use_w] > clip_end) { \
       in0 = 1; \
     } \
-    if (rt->v[1]->fbcoord[use_w] > clip_end) { \
+    if (tri->v[1]->fbcoord[use_w] > clip_end) { \
       in1 = 1; \
     } \
-    if (rt->v[2]->fbcoord[use_w] > clip_end) { \
+    if (tri->v[2]->fbcoord[use_w] > clip_end) { \
       in2 = 1; \
     } \
   } \
   else { \
     /* Point inside near plane. */ \
-    if (rt->v[0]->fbcoord[use_w] < clip_start) { \
+    if (tri->v[0]->fbcoord[use_w] < clip_start) { \
       in0 = 1; \
     } \
-    if (rt->v[1]->fbcoord[use_w] < clip_start) { \
+    if (tri->v[1]->fbcoord[use_w] < clip_start) { \
       in1 = 1; \
     } \
-    if (rt->v[2]->fbcoord[use_w] < clip_start) { \
+    if (tri->v[2]->fbcoord[use_w] < clip_start) { \
       in2 = 1; \
     } \
   }
@@ -1259,12 +1259,12 @@ static void lineart_main_cull_triangles(LineartRenderBuffer *rb, bool clip_far)
     ob = reln->object_ref;
     for (i = 0; i < reln->element_count; i++) {
       /* Select the triangle in the array. */
-      rt = (void *)(((uchar *)reln->pointer) + rb->triangle_size * i);
+      tri = (void *)(((uchar *)reln->pointer) + rb->triangle_size * i);
 
       LRT_CULL_DECIDE_INSIDE
       LRT_CULL_ENSURE_MEMORY
       lineart_triangle_cull_single(rb,
-                                   rt,
+                                   tri,
                                    in0,
                                    in1,
                                    in2,
@@ -1299,20 +1299,20 @@ static void lineart_main_free_adjacent_data(LineartRenderBuffer *rb)
     MEM_freeN(ld->data);
   }
   LISTBASE_FOREACH (LineartElementLinkNode *, reln, &rb->triangle_buffer_pointers) {
-    LineartTriangle *rt = reln->pointer;
+    LineartTriangle *tri = reln->pointer;
     int i;
     for (i = 0; i < reln->element_count; i++) {
-      /* See definition of rt->intersecting_verts and the usage in
+      /* See definition of tri->intersecting_verts and the usage in
        * lineart_geometry_object_load() for detailed. */
-      rt->intersecting_verts = NULL;
-      rt = (LineartTriangle *)(((uchar *)rt) + rb->triangle_size);
+      tri->intersecting_verts = NULL;
+      tri = (LineartTriangle *)(((uchar *)tri) + rb->triangle_size);
     }
   }
 }
 
 static void lineart_main_perspective_division(LineartRenderBuffer *rb)
 {
-  LineartVert *rv;
+  LineartVert *vt;
   int i;
 
   if (!rb->cam_is_persp) {
@@ -1320,18 +1320,18 @@ static void lineart_main_perspective_division(LineartRenderBuffer *rb)
   }
 
   LISTBASE_FOREACH (LineartElementLinkNode *, reln, &rb->vertex_buffer_pointers) {
-    rv = reln->pointer;
+    vt = reln->pointer;
     for (i = 0; i < reln->element_count; i++) {
       /* Do not divide Z, we use Z to back transform cut points in later chaining process. */
-      rv[i].fbcoord[0] /= rv[i].fbcoord[3];
-      rv[i].fbcoord[1] /= rv[i].fbcoord[3];
+      vt[i].fbcoord[0] /= vt[i].fbcoord[3];
+      vt[i].fbcoord[1] /= vt[i].fbcoord[3];
       /* Re-map z into (0-1) range, because we no longer need NDC (Normalized Device Coordinates)
        * at the moment.
        * The algorithm currently doesn't need Z for operation, we use W instead. If Z is needed in
        * the future, the line below correctly transforms it to view space coordinates. */
-      // `rv[i].fbcoord[2] = -2 * rv[i].fbcoord[2] / (far - near) - (far + near) / (far - near);
-      rv[i].fbcoord[0] -= rb->shift_x * 2;
-      rv[i].fbcoord[1] -= rb->shift_y * 2;
+      // `vt[i].fbcoord[2] = -2 * vt[i].fbcoord[2] / (far - near) - (far + near) / (far - near);
+      vt[i].fbcoord[0] -= rb->shift_x * 2;
+      vt[i].fbcoord[1] -= rb->shift_y * 2;
     }
   }
 }
@@ -1343,10 +1343,10 @@ static void lineart_vert_transform(
     BMVert *v, int index, LineartVert *RvBuf, double (*mv_mat)[4], double (*mvp_mat)[4])
 {
   double co[4];
-  LineartVert *rv = &RvBuf[index];
+  LineartVert *vt = &RvBuf[index];
   copy_v3db_v3fl(co, v->co);
-  mul_v3_m4v3_db(rv->gloc, mv_mat, co);
-  mul_v4_m4v3_db(rv->fbcoord, mvp_mat, co);
+  mul_v3_m4v3_db(vt->gloc, mv_mat, co);
+  mul_v4_m4v3_db(vt->fbcoord, mvp_mat, co);
 }
 
 /**
@@ -1381,12 +1381,12 @@ static char lineart_identify_feature_line(LineartRenderBuffer *rb,
     return LRT_EDGE_FLAG_CONTOUR;
   }
 
-  LineartTriangle *rt1, *rt2;
+  LineartTriangle *tri1, *tri2;
   LineartVert *l;
 
   /* The mesh should already be triangulated now, so we can assume each face is a triangle. */
-  rt1 = lineart_triangle_from_index(rb, rt_array, BM_elem_index_get(ll->f));
-  rt2 = lineart_triangle_from_index(rb, rt_array, BM_elem_index_get(lr->f));
+  tri1 = lineart_triangle_from_index(rb, rt_array, BM_elem_index_get(ll->f));
+  tri2 = lineart_triangle_from_index(rb, rt_array, BM_elem_index_get(lr->f));
 
   l = &rv_array[BM_elem_index_get(e->v1)];
 
@@ -1403,14 +1403,14 @@ static char lineart_identify_feature_line(LineartRenderBuffer *rb,
     view_vector = rb->view_vector;
   }
 
-  dot_1 = dot_v3v3_db(view_vector, rt1->gn);
-  dot_2 = dot_v3v3_db(view_vector, rt2->gn);
+  dot_1 = dot_v3v3_db(view_vector, tri1->gn);
+  dot_2 = dot_v3v3_db(view_vector, tri2->gn);
 
   if ((result = dot_1 * dot_2) <= 0 && (dot_1 + dot_2)) {
     return LRT_EDGE_FLAG_CONTOUR;
   }
 
-  if (rb->use_crease && (dot_v3v3_db(rt1->gn, rt2->gn) < crease_threshold)) {
+  if (rb->use_crease && (dot_v3v3_db(tri1->gn, tri2->gn) < crease_threshold)) {
     if (!no_crease) {
       return LRT_EDGE_FLAG_CREASE;
     }
@@ -1448,18 +1448,18 @@ static void lineart_add_edge_to_list(LineartRenderBuffer *rb, LineartEdge *e)
   }
 }
 
-static void lineart_triangle_adjacent_assign(LineartTriangle *rt,
-                                             LineartTriangleAdjacent *rta,
+static void lineart_triangle_adjacent_assign(LineartTriangle *tri,
+                                             LineartTriangleAdjacent *ta,
                                              LineartEdge *e)
 {
-  if (lineart_edge_match(rt, e, 0, 1)) {
-    rta->e[0] = e;
+  if (lineart_edge_match(tri, e, 0, 1)) {
+    ta->e[0] = e;
   }
-  else if (lineart_edge_match(rt, e, 1, 2)) {
-    rta->e[1] = e;
+  else if (lineart_edge_match(tri, e, 1, 2)) {
+    ta->e[1] = e;
   }
-  else if (lineart_edge_match(rt, e, 2, 0)) {
-    rta->e[2] = e;
+  else if (lineart_edge_match(tri, e, 2, 0)) {
+    ta->e[2] = e;
   }
 }
 
@@ -1477,7 +1477,7 @@ static void lineart_geometry_object_load(Depsgraph *dg,
   BMEdge *e;
   BMLoop *loop;
   LineartEdge *la_e;
-  LineartTriangle *rt;
+  LineartTriangle *tri;
   LineartTriangleAdjacent *orta;
   double new_mvp[4][4], new_mv[4][4], normal[4][4];
   float imat[4][4];
@@ -1621,39 +1621,39 @@ static void lineart_geometry_object_load(Depsgraph *dg,
      * index to come close together. */
     (*global_vindex) += bm->totvert;
 
-    rt = ort;
+    tri = ort;
     for (i = 0; i < bm->totface; i++) {
       f = BM_face_at_index(bm, i);
 
       loop = f->l_first;
-      rt->v[0] = &orv[BM_elem_index_get(loop->v)];
+      tri->v[0] = &orv[BM_elem_index_get(loop->v)];
       loop = loop->next;
-      rt->v[1] = &orv[BM_elem_index_get(loop->v)];
+      tri->v[1] = &orv[BM_elem_index_get(loop->v)];
       loop = loop->next;
-      rt->v[2] = &orv[BM_elem_index_get(loop->v)];
+      tri->v[2] = &orv[BM_elem_index_get(loop->v)];
 
       /* Transparency bit assignment. */
       Material *mat = BKE_object_material_get(ob, f->mat_nr + 1);
-      rt->transparency_mask = ((mat && (mat->lineart.flags & LRT_MATERIAL_TRANSPARENCY_ENABLED)) ?
-                                   mat->lineart.transparency_mask :
-                                   0);
+      tri->transparency_mask = ((mat && (mat->lineart.flags & LRT_MATERIAL_TRANSPARENCY_ENABLED)) ?
+                                    mat->lineart.transparency_mask :
+                                    0);
 
       double gn[3];
       copy_v3db_v3fl(gn, f->no);
-      mul_v3_mat3_m4v3_db(rt->gn, normal, gn);
-      normalize_v3_db(rt->gn);
+      mul_v3_mat3_m4v3_db(tri->gn, normal, gn);
+      normalize_v3_db(tri->gn);
 
       if (usage == OBJECT_LRT_INTERSECTION_ONLY) {
-        rt->flags |= LRT_TRIANGLE_INTERSECTION_ONLY;
+        tri->flags |= LRT_TRIANGLE_INTERSECTION_ONLY;
       }
       else if (ELEM(usage, OBJECT_LRT_NO_INTERSECTION, OBJECT_LRT_OCCLUSION_ONLY)) {
-        rt->flags |= LRT_TRIANGLE_NO_INTERSECTION;
+        tri->flags |= LRT_TRIANGLE_NO_INTERSECTION;
       }
 
       /* Re-use this field to refer to adjacent info, will be cleared after culling stage. */
-      rt->intersecting_verts = (void *)&orta[i];
+      tri->intersecting_verts = (void *)&orta[i];
 
-      rt = (LineartTriangle *)(((uchar *)rt) + rb->triangle_size);
+      tri = (LineartTriangle *)(((uchar *)tri) + rb->triangle_size);
     }
 
     /* Use BM_ELEM_TAG in f->head.hflag to store needed faces in the first iteration. */
@@ -1707,9 +1707,9 @@ static void lineart_geometry_object_load(Depsgraph *dg,
       la_e->flags = e->head.hflag;
       la_e->object_ref = orig_ob;
 
-      LineartLineSegment *rls = lineart_mem_acquire(&rb->render_data_pool,
-                                                    sizeof(LineartLineSegment));
-      BLI_addtail(&la_e->segments, rls);
+      LineartEdgeSegment *es = lineart_mem_acquire(&rb->render_data_pool,
+                                                   sizeof(LineartEdgeSegment));
+      BLI_addtail(&la_e->segments, es);
       if (ELEM(usage, OBJECT_LRT_INHERIT, OBJECT_LRT_INCLUDE, OBJECT_LRT_NO_INTERSECTION)) {
         lineart_add_edge_to_list(rb, la_e);
       }
@@ -1875,51 +1875,51 @@ static void lineart_main_load_geometries(
  * Returns the two other verts of the triangle given a vertex. Returns false if the given vertex
  * doesn't belong to this triangle.
  */
-static bool lineart_triangle_get_other_verts(const LineartTriangle *rt,
-                                             const LineartVert *rv,
+static bool lineart_triangle_get_other_verts(const LineartTriangle *tri,
+                                             const LineartVert *vt,
                                              LineartVert **l,
                                              LineartVert **r)
 {
-  if (rt->v[0] == rv) {
-    *l = rt->v[1];
-    *r = rt->v[2];
+  if (tri->v[0] == vt) {
+    *l = tri->v[1];
+    *r = tri->v[2];
     return true;
   }
-  if (rt->v[1] == rv) {
-    *l = rt->v[2];
-    *r = rt->v[0];
+  if (tri->v[1] == vt) {
+    *l = tri->v[2];
+    *r = tri->v[0];
     return true;
   }
-  if (rt->v[2] == rv) {
-    *l = rt->v[0];
-    *r = rt->v[1];
+  if (tri->v[2] == vt) {
+    *l = tri->v[0];
+    *r = tri->v[1];
     return true;
   }
   return false;
 }
 
-static bool lineart_edge_from_triangle(const LineartTriangle *rt,
+static bool lineart_edge_from_triangle(const LineartTriangle *tri,
                                        const LineartEdge *e,
                                        bool allow_overlapping_edges)
 {
   /* Normally we just determine from the pointer address. */
-  if (e->t1 == rt || e->t2 == rt) {
+  if (e->t1 == tri || e->t2 == tri) {
     return true;
   }
   /* If allows overlapping, then we compare the vertex coordinates one by one to determine if one
    * edge is from specific triangle. This is slower but can handle edge split cases very well. */
   if (allow_overlapping_edges) {
-#define LRT_TRI_SAME_POINT(rt, i, pt) \
-  ((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])) || \
-   (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, 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))) {
+#define LRT_TRI_SAME_POINT(tri, i, pt) \
+  ((LRT_DOUBLE_CLOSE_ENOUGH(tri->v[i]->gloc[0], pt->gloc[0]) && \
+    LRT_DOUBLE_CLOSE_ENOUGH(tri->v[i]->gloc[1], pt->gloc[1]) && \
+    LRT_DOUBLE_CLOSE_ENOUGH(tri->v[i]->gloc[2], pt->gloc[2])) || \
+   (LRT_DOUBLE_CLOSE_ENOUGH(tri->v[i]->gloc[0], pt->gloc[0]) && \
+    LRT_DOUBLE_CLOSE_ENOUGH(tri->v[i]->gloc[1], pt->gloc[1]) && \
+    LRT_DOUBLE_CLOSE_ENOUGH(tri->v[i]->gloc[2], pt->gloc[2])))
+    if ((LRT_TRI_SAME_POINT(tri, 0, e->v1) || LRT_TRI_SAME_POINT(tri, 1, e->v1) ||
+         LRT_TRI_SAME_POINT(tri, 2, e->v1)) &&
+        (LRT_TRI_SAME_POINT(tri, 0, e->v2) || LRT_TRI_SAME_POINT(tri, 1, e->v2) ||
+         LRT_TRI_SAME_POINT(tri, 2, e->v2))) {
       return true;
     }
 #undef LRT_TRI_SAME_POINT
@@ -1961,7 +1961,7 @@ static bool lineart_edge_from_triangle(const LineartTriangle *rt,
  * in ratio from `e->v1` to `e->v2`. The line is later cut with these two values.
  */
 static bool lineart_triangle_edge_image_space_occlusion(SpinLock *UNUSED(spl),
-                                                        const LineartTriangle *rt,
+                                                        const LineartTriangle *tri,
                                                         const LineartEdge *e,
                                                         const double *override_camera_loc,
                                                         const bool override_cam_is_persp,
@@ -1988,8 +1988,8 @@ static bool lineart_triangle_edge_image_space_occlusion(SpinLock *UNUSED(spl),
   double gloc[4], trans[4];
   double cut = -1;
 
-  double *LFBC = e->v1->fbcoord, *RFBC = e->v2->fbcoord, *FBC0 = rt->v[0]->fbcoord,
-         *FBC1 = rt->v[1]->fbcoord, *FBC2 = rt->v[2]->fbcoord;
+  double *LFBC = e->v1->fbcoord, *RFBC = e->v2->fbcoord, *FBC0 = tri->v[0]->fbcoord,
+         *FBC1 = tri->v[1]->fbcoord, *FBC2 = tri->v[2]->fbcoord;
 
   /* Overlapping not possible, return early. */
   if ((MAX3(FBC0[0], FBC1[0], FBC2[0]) < MIN2(LFBC[0], RFBC[0])) ||
@@ -2001,7 +2001,7 @@ static bool lineart_triangle_edge_image_space_occlusion(SpinLock *UNUSED(spl),
   }
 
   /* If the the line is one of the edge in the triangle, then it's not occluded. */
-  if (lineart_edge_from_triangle(rt, e, allow_overlapping_edges)) {
+  if (lineart_edge_from_triangle(tri, e, allow_overlapping_edges)) {
     return false;
   }
 
@@ -2013,8 +2013,8 @@ static bool lineart_triangle_edge_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, e->v1->gloc, rt->v[0]->gloc);
-  sub_v3_v3v3_db(Rv, e->v2->gloc, rt->v[0]->gloc);
+  sub_v3_v3v3_db(Lv, e->v1->gloc, tri->v[0]->gloc);
+  sub_v3_v3v3_db(Rv, e->v2->gloc, tri->v[0]->gloc);
 
   copy_v3_v3_db(Cv, camera_dir);
 
@@ -2025,12 +2025,12 @@ static bool lineart_triangle_edge_image_space_occlusion(SpinLock *UNUSED(spl),
     copy_v4_v4_db(vd4, override_camera_loc);
   }
   if (override_cam_is_persp) {
-    sub_v3_v3v3_db(Cv, vd4, rt->v[0]->gloc);
+    sub_v3_v3v3_db(Cv, vd4, tri->v[0]->gloc);
   }
 
-  dot_l = dot_v3v3_db(Lv, rt->gn);
-  dot_r = dot_v3v3_db(Rv, rt->gn);
-  dot_f = dot_v3v3_db(Cv, rt->gn);
+  dot_l = dot_v3v3_db(Lv, tri->gn);
+  dot_r = dot_v3v3_db(Rv, tri->gn);
+  dot_f = dot_v3v3_db(Cv, tri->gn);
 
   if (!dot_f) {
     return false;
@@ -2271,17 +2271,17 @@ static LineartVert *lineart_triangle_share_point(const LineartTriangle *l,
 /**
  * To save time and prevent overlapping lines when computing intersection lines.
  */
-static bool lineart_vert_already_intersected_2v(LineartVertIntersection *rv,
+static bool lineart_vert_already_intersected_2v(LineartVertIntersection *vt,
                                                 LineartVertIntersection *v1,
                                                 LineartVertIntersection *v2)
 {
-  return ((rv->isec1 == v1->base.index && rv->isec2 == v2->base.index) ||
-          (rv->isec2 == v2->base.index && rv->isec1 == v1->base.index));
+  return ((vt->isec1 == v1->base.index && vt->isec2 == v2->base.index) ||
+          (vt->isec2 == v2->base.index && vt->isec1 == v1->base.index));
 }
 
-static void lineart_vert_set_intersection_2v(LineartVert *rv, LineartVert *v1, LineartVert *v2)
+static void lineart_vert_set_intersection_2v(LineartVert *vt, LineartVert *v1, LineartVert *v2)
 {
-  LineartVertIntersection *irv = (LineartVertIntersection *)rv;
+  LineartVertIntersection *irv = (LineartVertIntersection *)vt;
   irv->isec1 = v1->index;
   irv->isec2 = v2->index;
 }
@@ -2294,7 +2294,7 @@ static void lineart_vert_set_intersection_2v(LineartVert *rv, LineartVert *v1, L
 static LineartVert *lineart_triangle_2v_intersection_test(LineartRenderBuffer *rb,
                                                           LineartVert *v1,
                                                           LineartVert *v2,
-                                                          LineartTriangle *rt,
+                                                          LineartTriangle *tri,
                                                           LineartTriangle *testing,
                                                           LineartVert *last)
 {
@@ -2306,11 +2306,11 @@ static LineartVert *lineart_triangle_2v_intersection_test(LineartRenderBuffer *r
   LineartVert *l = v1, *r = v2;
 
   for (LinkNode *ln = (void *)testing->intersecting_verts; ln; ln = ln->next) {
-    LineartVertIntersection *rv = ln->link;
-    if (rv->intersecting_with == rt &&
+    LineartVertIntersection *vt = ln->link;
+    if (vt->intersecting_with == tri &&
         lineart_vert_already_intersected_2v(
-            rv, (LineartVertIntersection *)l, (LineartVertIntersection *)r)) {
-      return (LineartVert *)rv;
+            vt, (LineartVertIntersection *)l, (LineartVertIntersection *)r)) {
+      return (LineartVert *)vt;
     }
   }
 
@@ -2360,7 +2360,7 @@ static LineartVert *lineart_triangle_2v_intersection_test(LineartRenderBuffer *r
  * Test if two triangles intersect. Generates one intersection line if the check succeeds.
  */
 static LineartEdge *lineart_triangle_intersect(LineartRenderBuffer *rb,
-                                               LineartTriangle *rt,
+                                               LineartTriangle *tri,
                                                LineartTriangle *testing)
 {
   LineartVert *v1 = 0, *v2 = 0;
@@ -2379,14 +2379,14 @@ static LineartEdge *lineart_triangle_intersect(LineartRenderBuffer *rb,
   ZMax = rb->far_clip;
   ZMin = rb->near_clip;
   copy_v3_v3_db(cl, rb->camera_pos);
-  LineartVert *share = lineart_triangle_share_point(testing, rt);
+  LineartVert *share = lineart_triangle_share_point(testing, tri);
 
   if (share) {
     /* If triangles have sharing points like `abc` and `acd`, then we only need to detect `bc`
      * against `acd` or `cd` against `abc`. */
 
     LineartVert *new_share;
-    lineart_triangle_get_other_verts(rt, share, &sv1, &sv2);
+    lineart_triangle_get_other_verts(tri, share, &sv1, &sv2);
 
     v1 = new_share = lineart_mem_acquire(&rb->render_data_pool, (sizeof(LineartVertIntersection)));
 
@@ -2394,47 +2394,47 @@ static LineartEdge *lineart_triangle_intersect(LineartRenderBuffer *rb,
 
     copy_v3_v3_db(new_share->gloc, share->gloc);
 
-    v2 = lineart_triangle_2v_intersection_test(rb, sv1, sv2, rt, testing, 0);
+    v2 = lineart_triangle_2v_intersection_test(rb, sv1, sv2, tri, testing, 0);
 
     if (v2 == NULL) {
       lineart_triangle_get_other_verts(testing, share, &sv1, &sv2);
-      v2 = lineart_triangle_2v_intersection_test(rb, sv1, sv2, testing, rt, 0);
+      v2 = lineart_triangle_2v_intersection_test(rb, sv1, sv2, testing, tri, 0);
       if (v2 == NULL) {
         return 0;
       }
       lineart_prepend_pool(&testing->intersecting_verts, &rb->render_data_pool, new_share);
     }
     else {
-      lineart_prepend_pool(&rt->intersecting_verts, &rb->render_data_pool, new_share);
+      lineart_prepend_pool(&tri->intersecting_verts, &rb->render_data_pool, new_share);
     }
   }
   else {
     /* If not sharing any points, then we need to try all the possibilities. */
 
-    E0T = lineart_triangle_2v_intersection_test(rb, rt->v[0], rt->v[1], rt, testing, 0);
+    E0T = lineart_triangle_2v_intersection_test(rb, tri->v[0], tri->v[1], tri, testing, 0);
     if (E0T && (!(*next))) {
       (*next) = E0T;
-      lineart_vert_set_intersection_2v((*next), rt->v[0], rt->v[1]);
+      lineart_vert_set_intersection_2v((*next), tri->v[0], tri->v[1]);
       next = &v2;
     }
-    E1T = lineart_triangle_2v_intersection_test(rb, rt->v[1], rt->v[2], rt, testing, v1);
+    E1T = lineart_triangle_2v_intersection_test(rb, tri->v[1], tri->v[2], tri, testing, v1);
     if (E1T && (!(*next))) {
       (*next) = E1T;
-      lineart_vert_set_intersection_2v((*next), rt->v[1], rt->v[2]);
+      lineart_vert_set_intersection_2v((*next), tri->v[1], tri->v[2]);
       next = &v2;
     }
     if (!(*next)) {
-      E2T = lineart_triangle_2v_intersection_test(rb, rt->v[2], rt->v[0], rt, testing, v1);
+      E2T = lineart_triangle_2v_intersection_test(rb, tri->v[2], tri->v[0], tri, testing, v1);
     }
     if (E2T && (!(*next))) {
       (*next) = E2T;
-      lineart_vert_set_intersection_2v((*next), rt->v[2], rt->v[0]);
+      lineart_vert_set_intersection_2v((*next), tri->v[2], tri->v[0]);
       next = &v2;
     }
 
     if (!(*next)) {
       TE0 = lineart_triangle_2v_intersection_test(
-          rb, testing->v[0], testing->v[1], testing, rt, v1);
+          rb, testing->v[0], testing->v[1], testing, tri, v1);
     }
     if (TE0 && (!(*next))) {
       (*next) = TE0;
@@ -2443,7 +2443,7 @@ static LineartEdge *lineart_triangle_intersect(LineartRenderBuffer *rb,
     }
     if (!(*next)) {
       TE1 = lineart_triangle_2v_intersection_test(
-          rb, testing->v[1], testing->v[2], testing, rt, v1);
+          rb, testing->v[1], testing->v[2], testing, tri, v1);
     }
     if (TE1 && (!(*next))) {
       (*next) = TE1;
@@ -2452,7 +2452,7 @@ static LineartEdge *lineart_triangle_intersect(LineartRenderBuffer *rb,
     }
     if (!(*next)) {
       TE2 = lineart_triangle_2v_intersection_test(
-          rb, testing->v[2], testing->v[0], testing, rt, v1);
+          rb, testing->v[2], testing->v[0], testing, tri, v1);
     }
     if (TE2 && (!(*next))) {
       (*next) = TE2;
@@ -2484,17 +2484,17 @@ static LineartEdge *lineart_triangle_intersect(LineartRenderBuffer *rb,
   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 *)v1)->intersecting_with = rt;
+  ((LineartVertIntersection *)v1)->intersecting_with = tri;
   ((LineartVertIntersection *)v2)->intersecting_with = testing;
 
   result = lineart_mem_acquire(&rb->render_data_pool, sizeof(LineartEdge));
   result->v1 = v1;
   result->v2 = v2;
-  result->t1 = rt;
+  result->t1 = tri;
   result->t2 = testing;
 
-  LineartLineSegment *rls = lineart_mem_acquire(&rb->render_data_pool, sizeof(LineartLineSegment));
-  BLI_addtail(&result->segments, rls);
+  LineartEdgeSegment *es = lineart_mem_acquire(&rb->render_data_pool, sizeof(LineartEdgeSegment));
+  BLI_addtail(&result->segments, es);
   /* Don't need to OR flags right now, just a type mark. */
   result->flags = LRT_EDGE_FLAG_INTERSECTION;
   lineart_prepend_edge_direct(&rb->intersection_lines, result);
@@ -2502,7 +2502,7 @@ static LineartEdge *lineart_triangle_intersect(LineartRenderBuffer *rb,
   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(
+        lineart_bounding_area_link_edge(
             rb, &rb->initial_bounding_areas[row * LRT_BA_ROWS + col], result);
       }
     }
@@ -2514,23 +2514,23 @@ static LineartEdge *lineart_triangle_intersect(LineartRenderBuffer *rb,
 }
 
 static void lineart_triangle_intersect_in_bounding_area(LineartRenderBuffer *rb,
-                                                        LineartTriangle *rt,
+                                                        LineartTriangle *tri,
                                                         LineartBoundingArea *ba)
 {
   /* Testing_triangle->testing[0] is used to store pairing triangle reference.
    * See definition of LineartTriangleThread for more info. */
   LineartTriangle *testing_triangle;
-  LineartTriangleThread *rtt;
+  LineartTriangleThread *tt;
   LinkData *lip, *next_lip;
 
-  double *G0 = rt->v[0]->gloc, *G1 = rt->v[1]->gloc, *G2 = rt->v[2]->gloc;
+  double *G0 = tri->v[0]->gloc, *G1 = tri->v[1]->gloc, *G2 = tri->v[2]->gloc;
 
   /* If this is not the smallest subdiv bounding area.*/
   if (ba->child) {
-    lineart_triangle_intersect_in_bounding_area(rb, rt, &ba->child[0]);
-    lineart_triangle_intersect_in_bounding_area(rb, rt, &ba->child[1]);
-    lineart_triangle_intersect_in_bounding_area(rb, rt, &ba->child[2]);
-    lineart_triangle_intersect_in_bounding_area(rb, rt, &ba->child[3]);
+    lineart_triangle_intersect_in_bounding_area(rb, tri, &ba->child[0]);
+    lineart_triangle_intersect_in_bounding_area(rb, tri, &ba->child[1]);
+    lineart_triangle_intersect_in_bounding_area(rb, tri, &ba->child[2]);
+    lineart_triangle_intersect_in_bounding_area(rb, tri, &ba->child[3]);
     return;
   }
 
@@ -2538,16 +2538,16 @@ static void lineart_triangle_intersect_in_bounding_area(LineartRenderBuffer *rb,
   for (lip = ba->linked_triangles.first; lip; lip = next_lip) {
     next_lip = lip->next;
     testing_triangle = lip->data;
-    rtt = (LineartTriangleThread *)testing_triangle;
+    tt = (LineartTriangleThread *)testing_triangle;
 
-    if (testing_triangle == rt || rtt->testing_e[0] == (LineartEdge *)rt) {
+    if (testing_triangle == tri || tt->testing_e[0] == (LineartEdge *)tri) {
       continue;
     }
-    rtt->testing_e[0] = (LineartEdge *)rt;
+    tt->testing_e[0] = (LineartEdge *)tri;
 
     if ((testing_triangle->flags & LRT_TRIANGLE_NO_INTERSECTION) ||
         ((testing_triangle->flags & LRT_TRIANGLE_INTERSECTION_ONLY) &&
-         (rt->flags & LRT_TRIANGLE_INTERSECTION_ONLY))) {
+         (tri->flags & LRT_TRIANGLE_INTERSECTION_ONLY))) {
       continue;
     }
 
@@ -2561,12 +2561,12 @@ static void lineart_triangle_intersect_in_bounding_area(LineartRenderBuffer *rb,
         (MAX3(G0[0], G1[0], G2[0]) < MIN3(RG0[0], RG1[0], RG2[0])) ||
         (MIN3(G0[1], G1[1], G2[1]) > MAX3(RG0[1], RG1[1], RG2[1])) ||
         (MAX3(G0[1], G1[1], G2[1]) < MIN3(RG0[1], RG1[1], RG2[1])) ||
-        lineart_triangle_share_edge(rt, testing_triangle)) {
+        lineart_triangle_share_edge(tri, testing_triangle)) {
       continue;
     }
 
     /* If we do need to compute intersection, then finally do it. */
-    lineart_triangle_intersect(rb, rt, testing_triangle);
+    lineart_triangle_intersect(rb, tri, testing_triangle);
   }
 }
 
@@ -2925,7 +2925,7 @@ static void lineart_bounding_area_split(LineartRenderBuffer *rb,
 {
   LineartBoundingArea *ba = lineart_mem_acquire(&rb->render_data_pool,
                                                 sizeof(LineartBoundingArea) * 4);
-  LineartTriangle *rt;
+  LineartTriangle *tri;
   LineartEdge *e;
 
   ba[0].l = root->cx;
@@ -2960,35 +2960,35 @@ static void lineart_bounding_area_split(LineartRenderBuffer *rb,
 
   lineart_bounding_areas_connect_new(rb, root);
 
-  while ((rt = lineart_list_pop_pointer_no_free(&root->linked_triangles)) != NULL) {
+  while ((tri = lineart_list_pop_pointer_no_free(&root->linked_triangles)) != NULL) {
     LineartBoundingArea *cba = root->child;
     double b[4];
-    b[0] = MIN3(rt->v[0]->fbcoord[0], rt->v[1]->fbcoord[0], rt->v[2]->fbcoord[0]);
-    b[1] = MAX3(rt->v[0]->fbcoord[0], rt->v[1]->fbcoord[0], rt->v[2]->fbcoord[0]);
-    b[2] = MAX3(rt->v[0]->fbcoord[1], rt->v[1]->fbcoord[1], rt->v[2]->fbcoord[1]);
-    b[3] = MIN3(rt->v[0]->fbcoord[1], rt->v[1]->fbcoord[1], rt->v[2]->fbcoord[1]);
+    b[0] = MIN3(tri->v[0]->fbcoord[0], tri->v[1]->fbcoord[0], tri->v[2]->fbcoord[0]);
+    b[1] = MAX3(tri->v[0]->fbcoord[0], tri->v[1]->fbcoord[0], tri->v[2]->fbcoord[0]);
+    b[2] = MAX3(tri->v[0]->fbcoord[1], tri->v[1]->fbcoord[1], tri->v[2]->fbcoord[1]);
+    b[3] = MIN3(tri->v[0]->fbcoord[1], tri->v[1]->fbcoord[1], tri->v[2]->fbcoord[1]);
     if (LRT_BOUND_AREA_CROSSES(b, &cba[0].l)) {
-      lineart_bounding_area_link_triangle(rb, &cba[0], rt, b, 0, recursive_level + 1, false);
+      lineart_bounding_area_link_triangle(rb, &cba[0], tri, b, 0, recursive_level + 1, false);
     }
     if (LRT_BOUND_AREA_CROSSES(b, &cba[1].l)) {
-      lineart_bounding_area_link_triangle(rb, &cba[1], rt, b, 0, recursive_level + 1, false);
+      lineart_bounding_area_link_triangle(rb, &cba[1], tri, b, 0, recursive_level + 1, false);
     }
     if (LRT_BOUND_AREA_CROSSES(b, &cba[2].l)) {
-      lineart_bounding_area_link_triangle(rb, &cba[2], rt, b, 0, recursive_level + 1, false);
+      lineart_bounding_area_link_triangle(rb, &cba[2], tri, b, 0, recursive_level + 1, false);
     }
     if (LRT_BOUND_AREA_CROSSES(b, &cba[3].l)) {
-      lineart_bounding_area_link_triangle(rb, &cba[3], rt, b, 0, recursive_level + 1, false);
+      lineart_bounding_area_link_triangle(rb, &cba[3], tri, b, 0, recursive_level + 1, false);
     }
   }
 
-  while ((e = lineart_list_pop_pointer_no_free(&root->linked_lines)) != NULL) {
-    lineart_bounding_area_link_line(rb, root, e);
+  while ((e = lineart_list_pop_pointer_no_free(&root->linked_edges)) != NULL) {
+    lineart_bounding_area_link_edge(rb, root, e);
   }
 
   rb->bounding_area_count += 3;
 }
 
-static bool lineart_bounding_area_line_intersect(LineartRenderBuffer *UNUSED(fb),
+static bool lineart_bounding_area_edge_intersect(LineartRenderBuffer *UNUSED(fb),
                                                  const double l[2],
                                                  const double r[2],
                                                  LineartBoundingArea *ba)
@@ -3032,11 +3032,11 @@ static bool lineart_bounding_area_line_intersect(LineartRenderBuffer *UNUSED(fb)
 }
 
 static bool lineart_bounding_area_triangle_intersect(LineartRenderBuffer *fb,
-                                                     LineartTriangle *rt,
+                                                     LineartTriangle *tri,
                                                      LineartBoundingArea *ba)
 {
   double p1[2], p2[2], p3[2], p4[2];
-  double *FBC1 = rt->v[0]->fbcoord, *FBC2 = rt->v[1]->fbcoord, *FBC3 = rt->v[2]->fbcoord;
+  double *FBC1 = tri->v[0]->fbcoord, *FBC2 = tri->v[1]->fbcoord, *FBC3 = tri->v[2]->fbcoord;
 
   p3[0] = p1[0] = (double)ba->l;
   p2[1] = p1[1] = (double)ba->b;
@@ -3056,9 +3056,9 @@ static bool lineart_bounding_area_triangle_intersect(LineartRenderBuffer *fb,
     return true;
   }
 
-  if ((lineart_bounding_area_line_intersect(fb, FBC1, FBC2, ba)) ||
-      (lineart_bounding_area_line_intersect(fb, FBC2, FBC3, ba)) ||
-      (lineart_bounding_area_line_intersect(fb, FBC3, FBC1, ba))) {
+  if ((lineart_bounding_area_edge_intersect(fb, FBC1, FBC2, ba)) ||
+      (lineart_bounding_area_edge_intersect(fb, FBC2, FBC3, ba)) ||
+      (lineart_bounding_area_edge_intersect(fb, FBC3, FBC1, ba))) {
     return true;
   }
 
@@ -3071,17 +3071,17 @@ static bool lineart_bounding_area_triangle_intersect(LineartRenderBuffer *fb,
  */
 static void lineart_bounding_area_link_triangle(LineartRenderBuffer *rb,
                                                 LineartBoundingArea *root_ba,
-                                                LineartTriangle *rt,
+                                                LineartTriangle *tri,
                                                 double *LRUB,
                                                 int recursive,
                                                 int recursive_level,
                                                 bool do_intersection)
 {
-  if (!lineart_bounding_area_triangle_intersect(rb, rt, root_ba)) {
+  if (!lineart_bounding_area_triangle_intersect(rb, tri, root_ba)) {
     return;
   }
   if (root_ba->child == NULL) {
-    lineart_list_append_pointer_pool(&root_ba->linked_triangles, &rb->render_data_pool, rt);
+    lineart_list_append_pointer_pool(&root_ba->linked_triangles, &rb->render_data_pool, tri);
     root_ba->triangle_count++;
     /* If splitting doesn't improve triangle separation, then shouldn't allow splitting anymore.
      * Here we use recursive limit. This is especially useful in orthographic render,
@@ -3091,7 +3091,7 @@ static void lineart_bounding_area_link_triangle(LineartRenderBuffer *rb,
       lineart_bounding_area_split(rb, root_ba, recursive_level);
     }
     if (recursive && do_intersection && rb->use_intersections) {
-      lineart_triangle_intersect_in_bounding_area(rb, rt, root_ba);
+      lineart_triangle_intersect_in_bounding_area(rb, tri, root_ba);
     }
   }
   else {
@@ -3099,54 +3099,54 @@ static void lineart_bounding_area_link_triangle(LineartRenderBuffer *rb,
     double *B1 = LRUB;
     double b[4];
     if (!LRUB) {
-      b[0] = MIN3(rt->v[0]->fbcoord[0], rt->v[1]->fbcoord[0], rt->v[2]->fbcoord[0]);
-      b[1] = MAX3(rt->v[0]->fbcoord[0], rt->v[1]->fbcoord[0], rt->v[2]->fbcoord[0]);
-      b[2] = MAX3(rt->v[0]->fbcoord[1], rt->v[1]->fbcoord[1], rt->v[2]->fbcoord[1]);
-      b[3] = MIN3(rt->v[0]->fbcoord[1], rt->v[1]->fbcoord[1], rt->v[2]->fbcoord[1]);
+      b[0] = MIN3(tri->v[0]->fbcoord[0], tri->v[1]->fbcoord[0], tri->v[2]->fbcoord[0]);
+      b[1] = MAX3(tri->v[0]->fbcoord[0], tri->v[1]->fbcoord[0], tri->v[2]->fbcoord[0]);
+      b[2] = MAX3(tri->v[0]->fbcoord[1], tri->v[1]->fbcoord[1], tri->v[2]->fbcoord[1]);
+      b[3] = MIN3(tri->v[0]->fbcoord[1], tri->v[1]->fbcoord[1], tri->v[2]->fbcoord[1]);
       B1 = b;
     }
     if (LRT_BOUND_AREA_CROSSES(B1, &ba[0].l)) {
       lineart_bounding_area_link_triangle(
-          rb, &ba[0], rt, B1, recursive, recursive_level + 1, do_intersection);
+          rb, &ba[0], tri, B1, recursive, recursive_level + 1, do_intersection);
     }
     if (LRT_BOUND_AREA_CROSSES(B1, &ba[1].l)) {
       lineart_bounding_area_link_triangle(
-          rb, &ba[1], rt, B1, recursive, recursive_level + 1, do_intersection);
+          rb, &ba[1], tri, B1, recursive, recursive_level + 1, do_intersection);
     }
     if (LRT_BOUND_AREA_CROSSES(B1, &ba[2].l)) {
       lineart_bounding_area_link_triangle(
-          rb, &ba[2], rt, B1, recursive, recursive_level + 1, do_intersection);
+          rb, &ba[2], tri, B1, recursive, recursive_level + 1, do_intersection);
     }
     if (LRT_BOUND_AREA_CROSSES(B1, &ba[3].l)) {
       lineart_bounding_area_link_triangle(
-          rb, &ba[3], rt, B1, recursive, recursive_level + 1, do_intersection);
+          rb, &ba[3], tri, B1, recursive, recursive_level + 1, do_intersection);
     }
   }
 }
 
-static void lineart_bounding_area_link_line(LineartRenderBuffer *rb,
+static void lineart_bounding_area_link_edge(LineartRenderBuffer *rb,
                                             LineartBoundingArea *root_ba,
                                             LineartEdge *e)
 {
   if (root_ba->child == NULL) {
-    lineart_list_append_pointer_pool(&root_ba->linked_lines, &rb->render_data_pool, e);
+    lineart_list_append_pointer_pool(&root_ba->linked_edges, &rb->render_data_pool, e);
   }
   else {
-    if (lineart_bounding_area_line_intersect(
+    if (lineart_bounding_area_edge_intersect(
             rb, e->v1->fbcoord, e->v2->fbcoord, &root_ba->child[0])) {
-      lineart_bounding_area_link_line(rb, &root_ba->child[0], e);
+      lineart_bounding_area_link_edge(rb, &root_ba->child[0], e);
     }
-    if (lineart_bounding_area_line_intersect(
+    if (lineart_bounding_area_edge_intersect(
             rb, e->v1->fbcoord, e->v2->fbcoord, &root_ba->child[1])) {
-      lineart_bounding_area_link_line(rb, &root_ba->child[1], e);
+      lineart_bounding_area_link_edge(rb, &root_ba->child[1], e);
     }
-    if (lineart_bounding_area_line_intersect(
+    if (lineart_bounding_area_edge_intersect(
             rb, e->v1->fbcoord, e->v2->fbcoord, &root_ba->child[2])) {
-      lineart_bounding_area_link_line(rb, &root_ba->child[2], e);
+      lineart_bounding_area_link_edge(rb, &root_ba->child[2], e);
     }
-    if (lineart_bounding_area_line_intersect(
+    if (lineart_bounding_area_edge_intersect(
             rb, e->v1->fbcoord, e->v2->fbcoord, &root_ba->child[3])) {
-      lineart_bounding_area_link_line(rb, &root_ba->child[3], e);
+      lineart_bounding_area_link_edge(rb, &root_ba->child[3], e);
     }
   }
 }
@@ -3162,7 +3162,7 @@ static void lineart_main_link_lines(LineartRenderBuffer *rb)
     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(
+          lineart_bounding_area_link_edge(
               rb, &rb->initial_bounding_areas[row * LRT_BA_ROWS + col], e);
         }
       }
@@ -3172,7 +3172,7 @@ static void lineart_main_link_lines(LineartRenderBuffer *rb)
 }
 
 static bool lineart_get_triangle_bounding_areas(LineartRenderBuffer *rb,
-                                                LineartTriangle *rt,
+                                                LineartTriangle *tri,
                                                 int *rowbegin,
                                                 int *rowend,
                                                 int *colbegin,
@@ -3181,14 +3181,14 @@ static bool lineart_get_triangle_bounding_areas(LineartRenderBuffer *rb,
   double sp_w = rb->width_per_tile, sp_h = rb->height_per_tile;
   double b[4];
 
-  if (!rt->v[0] || !rt->v[1] || !rt->v[2]) {
+  if (!tri->v[0] || !tri->v[1] || !tri->v[2]) {
     return false;
   }
 
-  b[0] = MIN3(rt->v[0]->fbcoord[0], rt->v[1]->fbcoord[0], rt->v[2]->fbcoord[0]);
-  b[1] = MAX3(rt->v[0]->fbcoord[0], rt->v[1]->fbcoord[0], rt->v[2]->fbcoord[0]);
-  b[2] = MIN3(rt->v[0]->fbcoord[1], rt->v[1]->fbcoord[1], rt->v[2]->fbcoord[1]);
-  b[3] = MAX3(rt->v[0]->fbcoord[1], rt->v[1]->fbcoord[1], rt->v[2]->fbcoord[1]);
+  b[0] = MIN3(tri->v[0]->fbcoord[0], tri->v[1]->fbcoord[0], tri->v[2]->fbcoord[0]);
+  b[1] = MAX3(tri->v[0]->fbcoord[0], tri->v[1]->fbcoord[0], tri->v[2]->fbcoord[0]);
+  b[2] = MIN3(tri->v[0]->fbcoord[1], tri->v[1]->fbcoord[1], tri->v[2]->fbcoord[1]);
+  b[3] = MAX3(tri->v[0]->fbcoord[1], tri->v[1]->fbcoord[1], tri->v[2]->fbcoord[1]);
 
   if (b[0] > 1 || b[1] < -1 || b[2] > 1 || b[3] < -1) {
     return false;
@@ -3355,33 +3355,33 @@ LineartBoundingArea *MOD_lineart_get_bounding_area(LineartRenderBuffer *rb, doub
  */
 static void lineart_main_add_triangles(LineartRenderBuffer *rb)
 {
-  LineartTriangle *rt;
+  LineartTriangle *tri;
   int i, lim;
   int x1, x2, y1, y2;
   int r, co;
 
   LISTBASE_FOREACH (LineartElementLinkNode *, reln, &rb->triangle_buffer_pointers) {
-    rt = reln->pointer;
+    tri = reln->pointer;
     lim = reln->element_count;
     for (i = 0; i < lim; i++) {
-      if ((rt->flags & LRT_CULL_USED) || (rt->flags & LRT_CULL_DISCARD)) {
-        rt = (void *)(((uchar *)rt) + rb->triangle_size);
+      if ((tri->flags & LRT_CULL_USED) || (tri->flags & LRT_CULL_DISCARD)) {
+        tri = (void *)(((uchar *)tri) + rb->triangle_size);
         continue;
       }
-      if (lineart_get_triangle_bounding_areas(rb, rt, &y1, &y2, &x1, &x2)) {
+      if (lineart_get_triangle_bounding_areas(rb, tri, &y1, &y2, &x1, &x2)) {
         for (co = x1; co <= x2; co++) {
           for (r = y1; r <= y2; r++) {
             lineart_bounding_area_link_triangle(rb,
                                                 &rb->initial_bounding_areas[r * LRT_BA_ROWS + co],
-                                                rt,
+                                                tri,
                                                 0,
                                                 1,
                                                 0,
-                                                (!(rt->flags & LRT_TRIANGLE_NO_INTERSECTION)));
+                                                (!(tri->flags & LRT_TRIANGLE_NO_INTERSECTION)));
           }
         }
       } /* Else throw away. */
-      rt = (void *)(((uchar *)rt) + rb->triangle_size);
+      tri = (void *)(((uchar *)tri) + rb->triangle_size);
     }
   }
 }
@@ -3817,52 +3817,52 @@ static void lineart_gpencil_generate(LineartRenderBuffer *rb,
   bool invert_input = modifier_flags & LRT_GPENCIL_INVERT_SOURCE_VGROUP;
   bool match_output = modifier_flags & LRT_GPENCIL_MATCH_OUTPUT_VGROUP;
 
-  LISTBASE_FOREACH (LineartLineChain *, rlc, &rb->chains) {
+  LISTBASE_FOREACH (LineartEdgeChain *, ec, &rb->chains) {
 
-    if (rlc->picked) {
+    if (ec->picked) {
       continue;
     }
-    if (!(rlc->type & (types & enabled_types))) {
+    if (!(ec->type & (types & enabled_types))) {
       continue;
     }
-    if (rlc->level > level_end || rlc->level < level_start) {
+    if (ec->level > level_end || ec->level < level_start) {
       continue;
     }
-    if (orig_ob && orig_ob != rlc->object_ref) {
+    if (orig_ob && orig_ob != ec->object_ref) {
       continue;
     }
-    if (orig_col && rlc->object_ref) {
-      if (!BKE_collection_has_object_recursive_instanced(orig_col, (Object *)rlc->object_ref)) {
+    if (orig_col && ec->object_ref) {
+      if (!BKE_collection_has_object_recursive_instanced(orig_col, (Object *)ec->object_ref)) {
         continue;
       }
     }
     if (transparency_flags & LRT_GPENCIL_TRANSPARENCY_ENABLE) {
       if (transparency_flags & LRT_GPENCIL_TRANSPARENCY_MATCH) {
-        if (rlc->transparency_mask != transparency_mask) {
+        if (ec->transparency_mask != transparency_mask) {
           continue;
         }
       }
       else {
-        if (!(rlc->transparency_mask & transparency_mask)) {
+        if (!(ec->transparency_mask & transparency_mask)) {
           continue;
         }
       }
     }
 
     /* Preserved: If we ever do asynchronous generation, this picked flag should be set here. */
-    // rlc->picked = 1;
+    // ec->picked = 1;
 
     int array_idx = 0;
-    int count = MOD_lineart_chain_count(rlc);
+    int count = MOD_lineart_chain_count(ec);
     bGPDstroke *gps = BKE_gpencil_stroke_add(gpf, color_idx, count, thickness, false);
 
     float *stroke_data = MEM_callocN(sizeof(float) * count * GP_PRIM_DATABUF_SIZE,
                                      "line art add stroke");
 
-    LISTBASE_FOREACH (LineartLineChainItem *, rlci, &rlc->chain) {
-      stroke_data[array_idx] = rlci->gpos[0];
-      stroke_data[array_idx + 1] = rlci->gpos[1];
-      stroke_data[array_idx + 2] = rlci->gpos[2];
+    LISTBASE_FOREACH (LineartEdgeChainItem *, eci, &ec->chain) {
+      stroke_data[array_idx] = eci->gpos[0];
+      stroke_data[array_idx + 1] = eci->gpos[1];
+      stroke_data[array_idx + 2] = eci->gpos[2];
       mul_m4_v3(gp_obmat_inverse, &stroke_data[array_idx]);
       stroke_data[array_idx + 3] = 1;       /* thickness. */
       stroke_data[array_idx + 4] = opacity; /* hardness?. */
@@ -3876,7 +3876,7 @@ static void lineart_gpencil_generate(LineartRenderBuffer *rb,
     MEM_freeN(stroke_data);
 
     if (source_vgname && vgname) {
-      Object *eval_ob = DEG_get_evaluated_object(depsgraph, rlc->object_ref);
+      Object *eval_ob = DEG_get_evaluated_object(depsgraph, ec->object_ref);
       int gpdg = -1;
       if ((match_output || (gpdg = BKE_object_defgroup_name_index(gpencil_object, vgname)) >= 0)) {
         if (eval_ob && eval_ob->type == OB_MESH) {
@@ -3892,8 +3892,8 @@ static void lineart_gpencil_generate(LineartRenderBuffer *rb,
                   }
                 }
                 int sindex = 0, vindex;
-                LISTBASE_FOREACH (LineartLineChainItem *, rlci, &rlc->chain) {
-                  vindex = rlci->index;
+                LISTBASE_FOREACH (LineartEdgeChainItem *, eci, &ec->chain) {
+                  vindex = eci->index;
                   if (vindex >= me->totvert) {
                     break;
                   }