GPencil: New Shrinkwrap modifier

his new modifier is equals to the existing mesh modifier but adapted to grease pencil.

The underlying functions used to calculate the shrink are the same used in meshes.

{F11794101}

Reviewed By: pepeland, HooglyBoogly

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

6 files changed, 146 insertions, 34 deletions

diff --git a/source/blender/blenkernel/BKE_gpencil_geom.h b/source/blender/blenkernel/BKE_gpencil_geom.h
index df6dd6eab92..4b9671c7881 100644
--- a/source/blender/blenkernel/BKE_gpencil_geom.h
+++ b/source/blender/blenkernel/BKE_gpencil_geom.h
@@ -234,8 +234,12 @@ bool BKE_gpencil_stroke_sample(struct bGPdata *gpd,
  * \param gps: Stroke to smooth
  * \param i: Point index
  * \param inf: Amount of smoothing to apply
+ * \param smooth_caps: Apply smooth to stroke extremes
  */
-bool BKE_gpencil_stroke_smooth_point(struct bGPDstroke *gps, int i, float inf);
+bool BKE_gpencil_stroke_smooth_point(struct bGPDstroke *gps,
+                                     int i,
+                                     float inf,
+                                     const bool smooth_caps);
 /**
  * Apply smooth strength to stroke point.
  * \param gps: Stroke to smooth
diff --git a/source/blender/blenkernel/BKE_gpencil_modifier.h b/source/blender/blenkernel/BKE_gpencil_modifier.h
index e7917ffa578..d850dea0c30 100644
--- a/source/blender/blenkernel/BKE_gpencil_modifier.h
+++ b/source/blender/blenkernel/BKE_gpencil_modifier.h
@@ -407,16 +407,8 @@ void BKE_gpencil_set_lineart_modifier_limits(struct GpencilModifierData *md,
 bool BKE_gpencil_is_first_lineart_in_stack(const struct Object *ob,
                                            const struct GpencilModifierData *md);
 
-/**
- * Init grease pencil lattice deform data.
- * \param ob: Grease pencil object.
- */
-void BKE_gpencil_lattice_init(struct Object *ob);
-/**
- * Clear grease pencil lattice deform data.
- * \param ob: Grease pencil object.
- */
-void BKE_gpencil_lattice_clear(struct Object *ob);
+void BKE_gpencil_cache_data_init(struct Depsgraph *depsgraph, struct Object *ob);
+void BKE_gpencil_cache_data_clear(struct Object *ob);
 
 /**
  * Calculate grease-pencil modifiers.
diff --git a/source/blender/blenkernel/BKE_shrinkwrap.h b/source/blender/blenkernel/BKE_shrinkwrap.h
index 6ab14628c29..088b270bfed 100644
--- a/source/blender/blenkernel/BKE_shrinkwrap.h
+++ b/source/blender/blenkernel/BKE_shrinkwrap.h
@@ -48,6 +48,7 @@ struct Mesh;
 struct ModifierEvalContext;
 struct Object;
 struct ShrinkwrapModifierData;
+struct ShrinkwrapGpencilModifierData;
 struct SpaceTransform;
 
 /* Information about boundary edges in the mesh. */
@@ -123,6 +124,13 @@ void shrinkwrapModifier_deform(struct ShrinkwrapModifierData *smd,
                                const int defgrp_index,
                                float (*vertexCos)[3],
                                int numVerts);
+/* Implementation of the Shrinkwrap Grease Pencil modifier. */
+void shrinkwrapGpencilModifier_deform(struct ShrinkwrapGpencilModifierData *mmd,
+                                      struct Object *ob,
+                                      struct MDeformVert *dvert,
+                                      const int defgrp_index,
+                                      float (*vertexCos)[3],
+                                      int numVerts);
 
 /**
  * Used in `editmesh_mask_extract.c` to shrink-wrap the extracted mesh to the sculpt.
diff --git a/source/blender/blenkernel/intern/gpencil_geom.cc b/source/blender/blenkernel/intern/gpencil_geom.cc
index aca85984989..84a9735ac5c 100644
--- a/source/blender/blenkernel/intern/gpencil_geom.cc
+++ b/source/blender/blenkernel/intern/gpencil_geom.cc
@@ -912,7 +912,10 @@ bool BKE_gpencil_stroke_shrink(bGPDstroke *gps, const float dist, const short mo
 
   return true;
 }
-bool BKE_gpencil_stroke_smooth_point(bGPDstroke *gps, int i, float inf)
+/**
+ * Apply smooth position to stroke point.
+ */
+bool BKE_gpencil_stroke_smooth_point(bGPDstroke *gps, int i, float inf, const bool smooth_caps)
 {
   bGPDspoint *pt = &gps->points[i];
   float sco[3] = {0.0f};
@@ -926,7 +929,7 @@ bool BKE_gpencil_stroke_smooth_point(bGPDstroke *gps, int i, float inf)
   /* Only affect endpoints by a fraction of the normal strength,
    * to prevent the stroke from shrinking too much
    */
-  if (!is_cyclic && ELEM(i, 0, gps->totpoints - 1)) {
+  if ((!smooth_caps) && (!is_cyclic && ELEM(i, 0, gps->totpoints - 1))) {
     inf *= 0.1f;
   }
 
@@ -3333,7 +3336,7 @@ void BKE_gpencil_stroke_join(bGPDstroke *gps_a,
     for (i = start; i < end; i++) {
       pt = &gps_a->points[i];
       pt->pressure += (avg_pressure - pt->pressure) * ratio;
-      BKE_gpencil_stroke_smooth_point(gps_a, i, ratio * 0.6f);
+      BKE_gpencil_stroke_smooth_point(gps_a, i, ratio * 0.6f, false);
 
       ratio += step;
       /* In the center, reverse the ratio. */
diff --git a/source/blender/blenkernel/intern/gpencil_modifier.c b/source/blender/blenkernel/intern/gpencil_modifier.c
index fb6dbc5402d..f3bd17d5ef7 100644
--- a/source/blender/blenkernel/intern/gpencil_modifier.c
+++ b/source/blender/blenkernel/intern/gpencil_modifier.c
@@ -36,6 +36,7 @@
 #include "DNA_armature_types.h"
 #include "DNA_gpencil_modifier_types.h"
 #include "DNA_gpencil_types.h"
+#include "DNA_mesh_types.h"
 #include "DNA_meshdata_types.h"
 #include "DNA_modifier_types.h"
 #include "DNA_object_types.h"
@@ -50,7 +51,9 @@
 #include "BKE_lib_id.h"
 #include "BKE_lib_query.h"
 #include "BKE_material.h"
+#include "BKE_modifier.h"
 #include "BKE_object.h"
+#include "BKE_shrinkwrap.h"
 
 #include "DEG_depsgraph.h"
 #include "DEG_depsgraph_query.h"
@@ -76,36 +79,84 @@ static GpencilVirtualModifierData virtualModifierCommonData;
  * each loop over all the geometry being evaluated.
  */
 
-void BKE_gpencil_lattice_init(Object *ob)
+/**
+ * Init grease pencil cache deform data.
+ * \param ob: Grease pencil object
+ */
+void BKE_gpencil_cache_data_init(Depsgraph *depsgraph, Object *ob)
 {
   LISTBASE_FOREACH (GpencilModifierData *, md, &ob->greasepencil_modifiers) {
-    if (md->type == eGpencilModifierType_Lattice) {
-      LatticeGpencilModifierData *mmd = (LatticeGpencilModifierData *)md;
-      Object *latob = NULL;
+    switch (md->type) {
+      case eGpencilModifierType_Lattice: {
+        LatticeGpencilModifierData *mmd = (LatticeGpencilModifierData *)md;
+        Object *latob = NULL;
+
+        latob = mmd->object;
+        if ((!latob) || (latob->type != OB_LATTICE)) {
+          return;
+        }
+        if (mmd->cache_data) {
+          BKE_lattice_deform_data_destroy(mmd->cache_data);
+        }
 
-      latob = mmd->object;
-      if ((!latob) || (latob->type != OB_LATTICE)) {
-        return;
+        /* init deform data */
+        mmd->cache_data = BKE_lattice_deform_data_create(latob, ob);
+        break;
       }
-      if (mmd->cache_data) {
-        BKE_lattice_deform_data_destroy(mmd->cache_data);
+      case eGpencilModifierType_Shrinkwrap: {
+        ShrinkwrapGpencilModifierData *mmd = (ShrinkwrapGpencilModifierData *)md;
+        ob = mmd->target;
+        if (!ob) {
+          return;
+        }
+        if (mmd->cache_data) {
+          BKE_shrinkwrap_free_tree(mmd->cache_data);
+          MEM_SAFE_FREE(mmd->cache_data);
+        }
+        Object *ob_target = DEG_get_evaluated_object(depsgraph, ob);
+        Mesh *target = BKE_modifier_get_evaluated_mesh_from_evaluated_object(ob_target, false);
+        mmd->cache_data = MEM_callocN(sizeof(ShrinkwrapTreeData), __func__);
+        if (BKE_shrinkwrap_init_tree(
+                mmd->cache_data, target, mmd->shrink_type, mmd->shrink_mode, false)) {
+        }
+        else {
+          MEM_SAFE_FREE(mmd->cache_data);
+        }
+        break;
       }
 
-      /* init deform data */
-      mmd->cache_data = BKE_lattice_deform_data_create(latob, ob);
+      default:
+        break;
     }
   }
 }
 
-void BKE_gpencil_lattice_clear(Object *ob)
+/**
+ * Clear grease pencil cache deform data.
+ * \param ob: Grease pencil object
+ */
+void BKE_gpencil_cache_data_clear(Object *ob)
 {
   LISTBASE_FOREACH (GpencilModifierData *, md, &ob->greasepencil_modifiers) {
-    if (md->type == eGpencilModifierType_Lattice) {
-      LatticeGpencilModifierData *mmd = (LatticeGpencilModifierData *)md;
-      if ((mmd) && (mmd->cache_data)) {
-        BKE_lattice_deform_data_destroy(mmd->cache_data);
-        mmd->cache_data = NULL;
+    switch (md->type) {
+      case eGpencilModifierType_Lattice: {
+        LatticeGpencilModifierData *mmd = (LatticeGpencilModifierData *)md;
+        if ((mmd) && (mmd->cache_data)) {
+          BKE_lattice_deform_data_destroy(mmd->cache_data);
+          mmd->cache_data = NULL;
+        }
+        break;
       }
+      case eGpencilModifierType_Shrinkwrap: {
+        ShrinkwrapGpencilModifierData *mmd = (ShrinkwrapGpencilModifierData *)md;
+        if ((mmd) && (mmd->cache_data)) {
+          BKE_shrinkwrap_free_tree(mmd->cache_data);
+          MEM_SAFE_FREE(mmd->cache_data);
+        }
+        break;
+      }
+      default:
+        break;
     }
   }
 }
@@ -699,7 +750,7 @@ void BKE_gpencil_modifiers_calc(Depsgraph *depsgraph, Scene *scene, Object *ob)
   }
 
   /* Init general modifiers data. */
-  BKE_gpencil_lattice_init(ob);
+  BKE_gpencil_cache_data_init(depsgraph, ob);
 
   const bool time_remap = BKE_gpencil_has_time_modifiers(ob);
   bool is_first_lineart = true;
@@ -742,8 +793,8 @@ void BKE_gpencil_modifiers_calc(Depsgraph *depsgraph, Scene *scene, Object *ob)
     }
   }
 
-  /* Clear any lattice data. */
-  BKE_gpencil_lattice_clear(ob);
+  /* Clear any cache data. */
+  BKE_gpencil_cache_data_clear(ob);
 
   MOD_lineart_clear_cache(&gpd->runtime.lineart_cache);
 }
@@ -901,6 +952,10 @@ void BKE_gpencil_modifier_blend_read_data(BlendDataReader *reader, ListBase *lb)
         gpmd->segments[i].dmd = gpmd;
       }
     }
+    if (md->type == eGpencilModifierType_Shrinkwrap) {
+      ShrinkwrapGpencilModifierData *gpmd = (ShrinkwrapGpencilModifierData *)md;
+      gpmd->cache_data = NULL;
+    }
   }
 }
 
diff --git a/source/blender/blenkernel/intern/shrinkwrap.c b/source/blender/blenkernel/intern/shrinkwrap.c
index 00a80d6e74f..7618323f488 100644
--- a/source/blender/blenkernel/intern/shrinkwrap.c
+++ b/source/blender/blenkernel/intern/shrinkwrap.c
@@ -28,6 +28,7 @@
 #include <string.h>
 #include <time.h>
 
+#include "DNA_gpencil_modifier_types.h"
 #include "DNA_mesh_types.h"
 #include "DNA_meshdata_types.h"
 #include "DNA_modifier_types.h"
@@ -1483,6 +1484,55 @@ void shrinkwrapModifier_deform(ShrinkwrapModifierData *smd,
   }
 }
 
+void shrinkwrapGpencilModifier_deform(ShrinkwrapGpencilModifierData *mmd,
+                                      Object *ob,
+                                      MDeformVert *dvert,
+                                      const int defgrp_index,
+                                      float (*vertexCos)[3],
+                                      int numVerts)
+{
+
+  ShrinkwrapCalcData calc = NULL_ShrinkwrapCalcData;
+  /* Convert gpencil struct to use the same struct and function used with meshes. */
+  ShrinkwrapModifierData smd;
+  smd.target = mmd->target;
+  smd.auxTarget = mmd->aux_target;
+  smd.keepDist = mmd->keep_dist;
+  smd.shrinkType = mmd->shrink_type;
+  smd.shrinkOpts = mmd->shrink_opts;
+  smd.shrinkMode = mmd->shrink_mode;
+  smd.projLimit = mmd->proj_limit;
+  smd.projAxis = mmd->proj_axis;
+
+  /* Configure Shrinkwrap calc data. */
+  calc.smd = &smd;
+  calc.ob = ob;
+  calc.numVerts = numVerts;
+  calc.vertexCos = vertexCos;
+  calc.dvert = dvert;
+  calc.vgroup = defgrp_index;
+  calc.invert_vgroup = (mmd->flag & GP_SHRINKWRAP_INVERT_VGROUP) != 0;
+
+  BLI_SPACE_TRANSFORM_SETUP(&calc.local2target, ob, mmd->target);
+  calc.keepDist = mmd->keep_dist;
+  calc.tree = mmd->cache_data;
+
+  switch (mmd->shrink_type) {
+    case MOD_SHRINKWRAP_NEAREST_SURFACE:
+    case MOD_SHRINKWRAP_TARGET_PROJECT:
+      TIMEIT_BENCH(shrinkwrap_calc_nearest_surface_point(&calc), gpdeform_surface);
+      break;
+
+    case MOD_SHRINKWRAP_PROJECT:
+      TIMEIT_BENCH(shrinkwrap_calc_normal_projection(&calc), gpdeform_project);
+      break;
+
+    case MOD_SHRINKWRAP_NEAREST_VERTEX:
+      TIMEIT_BENCH(shrinkwrap_calc_nearest_vertex(&calc), gpdeform_vertex);
+      break;
+  }
+}
+
 void BKE_shrinkwrap_mesh_nearest_surface_deform(struct bContext *C,
                                                 Object *ob_source,
                                                 Object *ob_target)