LineArt: Occlusion effectiveness support

This patch adds a function where you can specify occlusion effectiveness from 0 to 255 layers per face for a given mesh material.

Reviewed By: Sebastian Parborg (zeddb)

Ref D11308

1 files changed, 35 insertions, 35 deletions

diff --git a/source/blender/gpencil_modifiers/intern/lineart/lineart_chain.c b/source/blender/gpencil_modifiers/intern/lineart/lineart_chain.c
index 37ee93b5f0f..d14f0e0c7bf 100644
--- a/source/blender/gpencil_modifiers/intern/lineart/lineart_chain.c
+++ b/source/blender/gpencil_modifiers/intern/lineart/lineart_chain.c
@@ -103,7 +103,7 @@ static LineartEdgeChainItem *lineart_chain_append_point(LineartRenderBuffer *rb,
                                                         float *normal,
                                                         char type,
                                                         int level,
-                                                        unsigned char transparency_mask,
+                                                        unsigned char material_mask_bits,
                                                         size_t index)
 {
   LineartEdgeChainItem *eci;
@@ -115,7 +115,7 @@ static LineartEdgeChainItem *lineart_chain_append_point(LineartRenderBuffer *rb,
     LineartEdgeChainItem *old_rlci = ec->chain.last;
     old_rlci->line_type = type;
     old_rlci->occlusion = level;
-    old_rlci->transparency_mask = transparency_mask;
+    old_rlci->material_mask_bits = material_mask_bits;
     return old_rlci;
   }
 
@@ -127,7 +127,7 @@ static LineartEdgeChainItem *lineart_chain_append_point(LineartRenderBuffer *rb,
   copy_v3_v3(eci->normal, normal);
   eci->line_type = type & LRT_EDGE_FLAG_ALL_TYPE;
   eci->occlusion = level;
-  eci->transparency_mask = transparency_mask;
+  eci->material_mask_bits = material_mask_bits;
   BLI_addtail(&ec->chain, eci);
 
   return eci;
@@ -140,7 +140,7 @@ static LineartEdgeChainItem *lineart_chain_prepend_point(LineartRenderBuffer *rb
                                                          float *normal,
                                                          char type,
                                                          int level,
-                                                         unsigned char transparency_mask,
+                                                         unsigned char material_mask_bits,
                                                          size_t index)
 {
   LineartEdgeChainItem *eci;
@@ -157,7 +157,7 @@ static LineartEdgeChainItem *lineart_chain_prepend_point(LineartRenderBuffer *rb
   copy_v3_v3(eci->normal, normal);
   eci->line_type = type & LRT_EDGE_FLAG_ALL_TYPE;
   eci->occlusion = level;
-  eci->transparency_mask = transparency_mask;
+  eci->material_mask_bits = material_mask_bits;
   BLI_addhead(&ec->chain, eci);
 
   return eci;
@@ -228,7 +228,7 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
                                 N,
                                 e->flags,
                                 es->occlusion,
-                                es->transparency_mask,
+                                es->material_mask_bits,
                                 e->v1_obindex);
     while (ba && (new_e = lineart_line_get_connected(ba, new_vt, &new_vt, e->flags))) {
       new_e->flags |= LRT_EDGE_FLAG_CHAIN_PICKED;
@@ -263,16 +263,16 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
                                       N,
                                       new_e->flags,
                                       es->occlusion,
-                                      es->transparency_mask,
+                                      es->material_mask_bits,
                                       new_e->v1_obindex);
           last_occlusion = es->occlusion;
-          last_transparency = es->transparency_mask;
+          last_transparency = es->material_mask_bits;
         }
       }
       else if (new_vt == new_e->v2) {
         es = new_e->segments.first;
         last_occlusion = es->occlusion;
-        last_transparency = es->transparency_mask;
+        last_transparency = es->material_mask_bits;
         es = es->next;
         for (; es; es = es->next) {
           double gpos[3], lpos[3];
@@ -291,7 +291,7 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
                                       last_transparency,
                                       new_e->v2_obindex);
           last_occlusion = es->occlusion;
-          last_transparency = es->transparency_mask;
+          last_transparency = es->material_mask_bits;
         }
         VERT_COORD_TO_FLOAT(new_e->v2);
         lineart_chain_prepend_point(rb,
@@ -326,7 +326,7 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
      * of the line. */
     es = e->segments.first;
     last_occlusion = ((LineartEdgeSegment *)es)->occlusion;
-    last_transparency = ((LineartEdgeSegment *)es)->transparency_mask;
+    last_transparency = ((LineartEdgeSegment *)es)->material_mask_bits;
     for (es = es->next; es; es = es->next) {
       double gpos[3], lpos[3];
       double *lfb = e->v1->fbcoord, *rfb = e->v2->fbcoord;
@@ -341,10 +341,10 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
                                  N,
                                  e->flags,
                                  es->occlusion,
-                                 es->transparency_mask,
+                                 es->material_mask_bits,
                                  e->v1_obindex);
       last_occlusion = es->occlusion;
-      last_transparency = es->transparency_mask;
+      last_transparency = es->material_mask_bits;
     }
     VERT_COORD_TO_FLOAT(e->v2)
     lineart_chain_append_point(rb,
@@ -385,10 +385,10 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
       if (new_vt == new_e->v1) {
         es = new_e->segments.last;
         last_occlusion = es->occlusion;
-        last_transparency = es->transparency_mask;
+        last_transparency = es->material_mask_bits;
         /* Fix leading vertex occlusion. */
         eci->occlusion = last_occlusion;
-        eci->transparency_mask = last_transparency;
+        eci->material_mask_bits = 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;
@@ -396,7 +396,7 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
           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 = es->prev ? es->prev->occlusion : last_occlusion;
-          last_transparency = es->prev ? es->prev->transparency_mask : last_transparency;
+          last_transparency = es->prev ? es->prev->material_mask_bits : last_transparency;
           POS_TO_FLOAT(lpos, gpos)
           lineart_chain_append_point(rb,
                                      ec,
@@ -412,9 +412,9 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
       else if (new_vt == new_e->v2) {
         es = new_e->segments.first;
         last_occlusion = es->occlusion;
-        last_transparency = es->transparency_mask;
+        last_transparency = es->material_mask_bits;
         eci->occlusion = last_occlusion;
-        eci->transparency_mask = last_transparency;
+        eci->material_mask_bits = last_transparency;
         es = es->next;
         for (; es; es = es->next) {
           double gpos[3], lpos[3];
@@ -430,10 +430,10 @@ void MOD_lineart_chain_feature_lines(LineartRenderBuffer *rb)
                                      N,
                                      new_e->flags,
                                      es->occlusion,
-                                     es->transparency_mask,
+                                     es->material_mask_bits,
                                      new_e->v2_obindex);
           last_occlusion = es->occlusion;
-          last_transparency = es->transparency_mask;
+          last_transparency = es->material_mask_bits;
         }
         VERT_COORD_TO_FLOAT(new_e->v2)
         lineart_chain_append_point(rb,
@@ -574,12 +574,12 @@ void MOD_lineart_chain_split_for_fixed_occlusion(LineartRenderBuffer *rb)
     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;
+    unsigned char fixed_mask = first_rlci->material_mask_bits;
     ec->level = fixed_occ;
-    ec->transparency_mask = fixed_mask;
+    ec->material_mask_bits = 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 (eci->occlusion != fixed_occ || eci->material_mask_bits != fixed_mask) {
         if (next_rlci) {
           if (lineart_point_overlapping(next_rlci, eci->pos[0], eci->pos[1], 1e-5)) {
             continue;
@@ -589,7 +589,7 @@ void MOD_lineart_chain_split_for_fixed_occlusion(LineartRenderBuffer *rb)
           /* Set the same occlusion level for the end vertex, so when further connection is needed
            * the backwards occlusion info is also correct. */
           eci->occlusion = fixed_occ;
-          eci->transparency_mask = fixed_mask;
+          eci->material_mask_bits = fixed_mask;
           /* No need to split at the last point anyway. */
           break;
         }
@@ -614,9 +614,9 @@ void MOD_lineart_chain_split_for_fixed_occlusion(LineartRenderBuffer *rb)
         new_rlc->type = ec->type;
         ec = new_rlc;
         fixed_occ = eci->occlusion;
-        fixed_mask = eci->transparency_mask;
+        fixed_mask = eci->material_mask_bits;
         ec->level = fixed_occ;
-        ec->transparency_mask = fixed_mask;
+        ec->material_mask_bits = fixed_mask;
       }
     }
   }
@@ -683,7 +683,7 @@ static LineartChainRegisterEntry *lineart_chain_get_closest_cre(LineartRenderBuf
                                                                 LineartEdgeChain *ec,
                                                                 LineartEdgeChainItem *eci,
                                                                 int occlusion,
-                                                                unsigned char transparency_mask,
+                                                                unsigned char material_mask_bits,
                                                                 float dist,
                                                                 float *result_new_len,
                                                                 LineartBoundingArea *caller_ba)
@@ -712,7 +712,7 @@ static LineartChainRegisterEntry *lineart_chain_get_closest_cre(LineartRenderBuf
       continue;
     }
     if (cre->ec == ec || (!cre->ec->chain.first) || (cre->ec->level != occlusion) ||
-        (cre->ec->transparency_mask != transparency_mask)) {
+        (cre->ec->material_mask_bits != material_mask_bits)) {
       continue;
     }
     if (!rb->fuzzy_everything) {
@@ -749,7 +749,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, ec, eci, occlusion, transparency_mask, dist, &adjacent_new_len, ba); \
+          rb, sba, ec, eci, occlusion, material_mask_bits, dist, &adjacent_new_len, ba); \
       if (adjacent_new_len < dist) { \
         dist = adjacent_new_len; \
         closest_cre = adjacent_closest; \
@@ -782,7 +782,7 @@ void MOD_lineart_chain_connect(LineartRenderBuffer *rb)
   float dist = rb->chaining_image_threshold;
   float dist_l, dist_r;
   int occlusion, reverse_main;
-  unsigned char transparency_mask;
+  unsigned char material_mask_bits;
   ListBase swap = {0};
 
   if (rb->chaining_image_threshold < 0.0001) {
@@ -806,16 +806,16 @@ void MOD_lineart_chain_connect(LineartRenderBuffer *rb)
     }
 
     occlusion = ec->level;
-    transparency_mask = ec->transparency_mask;
+    material_mask_bits = ec->material_mask_bits;
 
     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, ec, rlci_l, occlusion, transparency_mask, dist, &dist_l, NULL);
+          rb, ba_l, ec, rlci_l, occlusion, material_mask_bits, dist, &dist_l, NULL);
       closest_cre_r = lineart_chain_get_closest_cre(
-          rb, ba_r, ec, rlci_r, occlusion, transparency_mask, dist, &dist_r, NULL);
+          rb, ba_r, ec, rlci_r, occlusion, material_mask_bits, dist, &dist_r, NULL);
       if (closest_cre_l && closest_cre_r) {
         if (dist_l < dist_r) {
           closest_cre = closest_cre_l;
@@ -949,12 +949,12 @@ void MOD_lineart_chain_split_angle(LineartRenderBuffer *rb, float angle_threshol
                                    eci->normal,
                                    eci->line_type,
                                    ec->level,
-                                   eci->transparency_mask,
+                                   eci->material_mask_bits,
                                    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;
+        new_rlc->material_mask_bits = ec->material_mask_bits;
         ec = new_rlc;
       }
     }