Merge branch 'master' into greasepencil-object
[blender.git] / source / blender / blenkernel / intern / gpencil_modifier.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2017, Blender Foundation
17  * This is a new part of Blender
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <stdio.h>
25
26 #include "MEM_guardedalloc.h"
27
28 #include "BLI_blenlib.h"
29 #include "BLI_utildefines.h"
30 #include "BLI_math_vector.h"
31 #include "BLI_string_utils.h"
32
33 #include "BLT_translation.h"
34
35 #include "DNA_meshdata_types.h"
36 #include "DNA_scene_types.h"
37 #include "DNA_object_types.h"
38 #include "DNA_gpencil_types.h"
39 #include "DNA_gpencil_modifier_types.h"
40
41 #include "BKE_library.h"
42 #include "BKE_library_query.h"
43 #include "BKE_gpencil.h"
44 #include "BKE_lattice.h"
45 #include "BKE_gpencil_modifier.h"
46 #include "BKE_object.h"
47
48 #include "DEG_depsgraph.h"
49 #include "DEG_depsgraph_query.h"
50
51 #include "MOD_gpencil_modifiertypes.h"
52
53 static GpencilModifierTypeInfo *modifier_gpencil_types[NUM_GREASEPENCIL_MODIFIER_TYPES] = {NULL};
54
55 /* *************************************************** */
56 /* Geometry Utilities */
57
58 /* calculate stroke normal using some points */
59 void BKE_gpencil_stroke_normal(const bGPDstroke *gps, float r_normal[3])
60 {
61   if (gps->totpoints < 3) {
62     zero_v3(r_normal);
63     return;
64   }
65
66   bGPDspoint *points = gps->points;
67   int totpoints = gps->totpoints;
68
69   const bGPDspoint *pt0 = &points[0];
70   const bGPDspoint *pt1 = &points[1];
71   const bGPDspoint *pt3 = &points[(int)(totpoints * 0.75)];
72
73   float vec1[3];
74   float vec2[3];
75
76   /* initial vector (p0 -> p1) */
77   sub_v3_v3v3(vec1, &pt1->x, &pt0->x);
78
79   /* point vector at 3/4 */
80   sub_v3_v3v3(vec2, &pt3->x, &pt0->x);
81
82   /* vector orthogonal to polygon plane */
83   cross_v3_v3v3(r_normal, vec1, vec2);
84
85   /* Normalize vector */
86   normalize_v3(r_normal);
87 }
88
89 /* Get points of stroke always flat to view not affected by camera view or view position */
90 static void gpencil_stroke_project_2d(const bGPDspoint *points, int totpoints, vec2f *points2d)
91 {
92   const bGPDspoint *pt0 = &points[0];
93   const bGPDspoint *pt1 = &points[1];
94   const bGPDspoint *pt3 = &points[(int)(totpoints * 0.75)];
95
96   float locx[3];
97   float locy[3];
98   float loc3[3];
99   float normal[3];
100
101   /* local X axis (p0 -> p1) */
102   sub_v3_v3v3(locx, &pt1->x, &pt0->x);
103
104   /* point vector at 3/4 */
105   sub_v3_v3v3(loc3, &pt3->x, &pt0->x);
106
107   /* vector orthogonal to polygon plane */
108   cross_v3_v3v3(normal, locx, loc3);
109
110   /* local Y axis (cross to normal/x axis) */
111   cross_v3_v3v3(locy, normal, locx);
112
113   /* Normalize vectors */
114   normalize_v3(locx);
115   normalize_v3(locy);
116
117   /* Get all points in local space */
118   for (int i = 0; i < totpoints; i++) {
119     const bGPDspoint *pt = &points[i];
120     float loc[3];
121
122     /* Get local space using first point as origin */
123     sub_v3_v3v3(loc, &pt->x, &pt0->x);
124
125     vec2f *point = &points2d[i];
126     point->x = dot_v3v3(loc, locx);
127     point->y = dot_v3v3(loc, locy);
128   }
129 }
130
131 /* Stroke Simplify ------------------------------------- */
132
133 /* Reduce a series of points to a simplified version, but
134  * maintains the general shape of the series
135  *
136  * Ramer - Douglas - Peucker algorithm
137  * by http ://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm
138  */
139 static void gpencil_rdp_stroke(bGPDstroke *gps, vec2f *points2d, float epsilon)
140 {
141   vec2f *old_points2d = points2d;
142   int totpoints = gps->totpoints;
143   char *marked = NULL;
144   char work;
145
146   int start = 1;
147   int end = gps->totpoints - 2;
148
149   marked = MEM_callocN(totpoints, "GP marked array");
150   marked[start] = 1;
151   marked[end] = 1;
152
153   work = 1;
154   int totmarked = 0;
155   /* while still reducing */
156   while (work) {
157     int ls, le;
158     work = 0;
159
160     ls = start;
161     le = start + 1;
162
163     /* while not over interval */
164     while (ls < end) {
165       int max_i = 0;
166       float v1[2];
167       /* divided to get more control */
168       float max_dist = epsilon / 10.0f;
169
170       /* find the next marked point */
171       while (marked[le] == 0) {
172         le++;
173       }
174
175       /* perpendicular vector to ls-le */
176       v1[1] = old_points2d[le].x - old_points2d[ls].x;
177       v1[0] = old_points2d[ls].y - old_points2d[le].y;
178
179       for (int i = ls + 1; i < le; i++) {
180         float mul;
181         float dist;
182         float v2[2];
183
184         v2[0] = old_points2d[i].x - old_points2d[ls].x;
185         v2[1] = old_points2d[i].y - old_points2d[ls].y;
186
187         if (v2[0] == 0 && v2[1] == 0) {
188           continue;
189         }
190
191         mul = (float)(v1[0] * v2[0] + v1[1] * v2[1]) / (float)(v2[0] * v2[0] + v2[1] * v2[1]);
192
193         dist = mul * mul * (v2[0] * v2[0] + v2[1] * v2[1]);
194
195         if (dist > max_dist) {
196           max_dist = dist;
197           max_i = i;
198         }
199       }
200
201       if (max_i != 0) {
202         work = 1;
203         marked[max_i] = 1;
204         totmarked++;
205       }
206
207       ls = le;
208       le = ls + 1;
209     }
210   }
211
212   /* adding points marked */
213   bGPDspoint *old_points = MEM_dupallocN(gps->points);
214   MDeformVert *old_dvert = NULL;
215   MDeformVert *dvert_src = NULL;
216
217   if (gps->dvert != NULL) {
218     old_dvert = MEM_dupallocN(gps->dvert);
219   }
220   /* resize gps */
221   gps->flag |= GP_STROKE_RECALC_GEOMETRY;
222   gps->tot_triangles = 0;
223
224   int j = 0;
225   for (int i = 0; i < totpoints; i++) {
226     bGPDspoint *pt_src = &old_points[i];
227     bGPDspoint *pt = &gps->points[j];
228
229     if ((marked[i]) || (i == 0) || (i == totpoints - 1)) {
230       memcpy(pt, pt_src, sizeof(bGPDspoint));
231       if (gps->dvert != NULL) {
232         dvert_src = &old_dvert[i];
233         MDeformVert *dvert = &gps->dvert[j];
234         memcpy(dvert, dvert_src, sizeof(MDeformVert));
235         if (dvert_src->dw) {
236           memcpy(dvert->dw, dvert_src->dw, sizeof(MDeformWeight));
237         }
238       }
239       j++;
240     }
241     else {
242       if (gps->dvert != NULL) {
243         dvert_src = &old_dvert[i];
244         BKE_gpencil_free_point_weights(dvert_src);
245       }
246     }
247   }
248
249   gps->totpoints = j;
250
251   MEM_SAFE_FREE(old_points);
252   MEM_SAFE_FREE(old_dvert);
253   MEM_SAFE_FREE(marked);
254 }
255
256 /* Simplify stroke using Ramer-Douglas-Peucker algorithm */
257 void BKE_gpencil_simplify_stroke(bGPDstroke *gps, float factor)
258 {
259   /* first create temp data and convert points to 2D */
260   vec2f *points2d = MEM_mallocN(sizeof(vec2f) * gps->totpoints, "GP Stroke temp 2d points");
261
262   gpencil_stroke_project_2d(gps->points, gps->totpoints, points2d);
263
264   gpencil_rdp_stroke(gps, points2d, factor);
265
266   MEM_SAFE_FREE(points2d);
267 }
268
269 /* Simplify alternate vertex of stroke except extremes */
270 void BKE_gpencil_simplify_fixed(bGPDstroke *gps)
271 {
272   if (gps->totpoints < 5) {
273     return;
274   }
275
276   /* save points */
277   bGPDspoint *old_points = MEM_dupallocN(gps->points);
278   MDeformVert *old_dvert = NULL;
279   MDeformVert *dvert_src = NULL;
280
281   if (gps->dvert != NULL) {
282     old_dvert = MEM_dupallocN(gps->dvert);
283   }
284
285   /* resize gps */
286   int newtot = (gps->totpoints - 2) / 2;
287   if (((gps->totpoints - 2) % 2) > 0) {
288     newtot++;
289   }
290   newtot += 2;
291
292   gps->points = MEM_recallocN(gps->points, sizeof(*gps->points) * newtot);
293   if (gps->dvert != NULL) {
294     gps->dvert = MEM_recallocN(gps->dvert, sizeof(*gps->dvert) * newtot);
295   }
296   gps->flag |= GP_STROKE_RECALC_GEOMETRY;
297   gps->tot_triangles = 0;
298
299   int j = 0;
300   for (int i = 0; i < gps->totpoints; i++) {
301     bGPDspoint *pt_src = &old_points[i];
302     bGPDspoint *pt = &gps->points[j];
303
304     if ((i == 0) || (i == gps->totpoints - 1) || ((i % 2) > 0.0)) {
305       memcpy(pt, pt_src, sizeof(bGPDspoint));
306       if (gps->dvert != NULL) {
307         dvert_src = &old_dvert[i];
308         MDeformVert *dvert = &gps->dvert[j];
309         memcpy(dvert, dvert_src, sizeof(MDeformVert));
310         if (dvert_src->dw) {
311           memcpy(dvert->dw, dvert_src->dw, sizeof(MDeformWeight));
312         }
313       }
314       j++;
315     }
316     else {
317       if (gps->dvert != NULL) {
318         dvert_src = &old_dvert[i];
319         BKE_gpencil_free_point_weights(dvert_src);
320       }
321     }
322   }
323
324   gps->totpoints = j;
325
326   MEM_SAFE_FREE(old_points);
327   MEM_SAFE_FREE(old_dvert);
328 }
329
330 /* *************************************************** */
331 /* Modifier Utilities */
332
333 /* Lattice Modifier ---------------------------------- */
334 /* Usually, evaluation of the lattice modifier is self-contained.
335  * However, since GP's modifiers operate on a per-stroke basis,
336  * we need to these two extra functions that called before/after
337  * each loop over all the geometry being evaluated.
338  */
339
340 /* init lattice deform data */
341 void BKE_gpencil_lattice_init(Object *ob)
342 {
343   GpencilModifierData *md;
344   for (md = ob->greasepencil_modifiers.first; md; md = md->next) {
345     if (md->type == eGpencilModifierType_Lattice) {
346       LatticeGpencilModifierData *mmd = (LatticeGpencilModifierData *)md;
347       Object *latob = NULL;
348
349       latob = mmd->object;
350       if ((!latob) || (latob->type != OB_LATTICE)) {
351         return;
352       }
353       if (mmd->cache_data) {
354         end_latt_deform((struct LatticeDeformData *)mmd->cache_data);
355       }
356
357       /* init deform data */
358       mmd->cache_data = (struct LatticeDeformData *)init_latt_deform(latob, ob);
359     }
360   }
361 }
362
363 /* clear lattice deform data */
364 void BKE_gpencil_lattice_clear(Object *ob)
365 {
366   GpencilModifierData *md;
367   for (md = ob->greasepencil_modifiers.first; md; md = md->next) {
368     if (md->type == eGpencilModifierType_Lattice) {
369       LatticeGpencilModifierData *mmd = (LatticeGpencilModifierData *)md;
370       if ((mmd) && (mmd->cache_data)) {
371         end_latt_deform((struct LatticeDeformData *)mmd->cache_data);
372         mmd->cache_data = NULL;
373       }
374     }
375   }
376 }
377
378 /* *************************************************** */
379 /* Modifier Methods - Evaluation Loops, etc. */
380
381 /* check if exist geometry modifiers */
382 bool BKE_gpencil_has_geometry_modifiers(Object *ob)
383 {
384   GpencilModifierData *md;
385   for (md = ob->greasepencil_modifiers.first; md; md = md->next) {
386     const GpencilModifierTypeInfo *mti = BKE_gpencil_modifierType_getInfo(md->type);
387
388     if (mti && mti->generateStrokes) {
389       return true;
390     }
391   }
392   return false;
393 }
394
395 /* check if exist time modifiers */
396 bool BKE_gpencil_has_time_modifiers(Object *ob)
397 {
398   GpencilModifierData *md;
399   for (md = ob->greasepencil_modifiers.first; md; md = md->next) {
400     const GpencilModifierTypeInfo *mti = BKE_gpencil_modifierType_getInfo(md->type);
401
402     if (mti && mti->remapTime) {
403       return true;
404     }
405   }
406   return false;
407 }
408
409 /* apply stroke modifiers */
410 void BKE_gpencil_stroke_modifiers(Depsgraph *depsgraph,
411                                   Object *ob,
412                                   bGPDlayer *gpl,
413                                   bGPDframe *UNUSED(gpf),
414                                   bGPDstroke *gps,
415                                   bool is_render)
416 {
417   GpencilModifierData *md;
418   bGPdata *gpd = ob->data;
419   const bool is_edit = GPENCIL_ANY_EDIT_MODE(gpd);
420
421   for (md = ob->greasepencil_modifiers.first; md; md = md->next) {
422     if (GPENCIL_MODIFIER_ACTIVE(md, is_render)) {
423       const GpencilModifierTypeInfo *mti = BKE_gpencil_modifierType_getInfo(md->type);
424
425       if ((GPENCIL_MODIFIER_EDIT(md, is_edit)) && (!is_render)) {
426         continue;
427       }
428
429       if (mti && mti->deformStroke) {
430         mti->deformStroke(md, depsgraph, ob, gpl, gps);
431         /* subdivide allways requires update */
432         if (md->type == eGpencilModifierType_Subdiv) {
433           gps->flag |= GP_STROKE_RECALC_GEOMETRY;
434         }
435         /* some modifiers could require a recalc of fill triangulation data */
436         else if (gpd->flag & GP_DATA_STROKE_FORCE_RECALC) {
437           if (ELEM(md->type,
438                    eGpencilModifierType_Armature,
439                    eGpencilModifierType_Hook,
440                    eGpencilModifierType_Lattice,
441                    eGpencilModifierType_Offset)) {
442
443             gps->flag |= GP_STROKE_RECALC_GEOMETRY;
444           }
445         }
446       }
447     }
448   }
449 }
450
451 /* apply stroke geometry modifiers */
452 void BKE_gpencil_geometry_modifiers(
453     Depsgraph *depsgraph, Object *ob, bGPDlayer *gpl, bGPDframe *gpf, bool is_render)
454 {
455   GpencilModifierData *md;
456   bGPdata *gpd = ob->data;
457   const bool is_edit = GPENCIL_ANY_EDIT_MODE(gpd);
458
459   for (md = ob->greasepencil_modifiers.first; md; md = md->next) {
460     if (GPENCIL_MODIFIER_ACTIVE(md, is_render)) {
461       const GpencilModifierTypeInfo *mti = BKE_gpencil_modifierType_getInfo(md->type);
462
463       if ((GPENCIL_MODIFIER_EDIT(md, is_edit)) && (!is_render)) {
464         continue;
465       }
466
467       if (mti->generateStrokes) {
468         mti->generateStrokes(md, depsgraph, ob, gpl, gpf);
469       }
470     }
471   }
472 }
473
474 /* apply time modifiers */
475 int BKE_gpencil_time_modifier(
476     Depsgraph *depsgraph, Scene *scene, Object *ob, bGPDlayer *gpl, int cfra, bool is_render)
477 {
478   GpencilModifierData *md;
479   bGPdata *gpd = ob->data;
480   const bool is_edit = GPENCIL_ANY_EDIT_MODE(gpd);
481   int nfra = cfra;
482
483   for (md = ob->greasepencil_modifiers.first; md; md = md->next) {
484     if (GPENCIL_MODIFIER_ACTIVE(md, is_render)) {
485       const GpencilModifierTypeInfo *mti = BKE_gpencil_modifierType_getInfo(md->type);
486
487       if ((GPENCIL_MODIFIER_EDIT(md, is_edit)) && (!is_render)) {
488         continue;
489       }
490
491       if (mti->remapTime) {
492         nfra = mti->remapTime(md, depsgraph, scene, ob, gpl, cfra);
493         /* if the frame number changed, don't evaluate more and return */
494         if (nfra != cfra) {
495           return nfra;
496         }
497       }
498     }
499   }
500
501   /* if no time modifier, return original frame number */
502   return nfra;
503 }
504 /* *************************************************** */
505
506 void BKE_gpencil_eval_geometry(Depsgraph *depsgraph, bGPdata *gpd)
507 {
508   DEG_debug_print_eval(depsgraph, __func__, gpd->id.name, gpd);
509   int ctime = (int)DEG_get_ctime(depsgraph);
510
511   /* update active frame */
512   for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
513     gpl->actframe = BKE_gpencil_layer_getframe(gpl, ctime, GP_GETFRAME_USE_PREV);
514   }
515
516   /* TODO: Move "derived_gpf" logic here from DRW_gpencil_populate_datablock()?
517    * This would be better than inventing our own logic for this stuff...
518    */
519
520   /* TODO: Move the following code to "BKE_gpencil_eval_done()" (marked as an exit node)
521    * later when there's more happening here. For now, let's just keep this in here to avoid
522    * needing to have one more node slowing down evaluation...
523    */
524   if (DEG_is_active(depsgraph)) {
525     bGPdata *gpd_orig = (bGPdata *)DEG_get_original_id(&gpd->id);
526
527     /* sync "actframe" changes back to main-db too,
528      * so that editing tools work with copy-on-write
529      * when the current frame changes
530      */
531     for (bGPDlayer *gpl = gpd_orig->layers.first; gpl; gpl = gpl->next) {
532       gpl->actframe = BKE_gpencil_layer_getframe(gpl, ctime, GP_GETFRAME_USE_PREV);
533     }
534   }
535 }
536
537 void BKE_gpencil_modifier_init(void)
538 {
539   /* Initialize modifier types */
540   gpencil_modifier_type_init(modifier_gpencil_types); /* MOD_gpencil_util.c */
541 }
542
543 GpencilModifierData *BKE_gpencil_modifier_new(int type)
544 {
545   const GpencilModifierTypeInfo *mti = BKE_gpencil_modifierType_getInfo(type);
546   GpencilModifierData *md = MEM_callocN(mti->struct_size, mti->struct_name);
547
548   /* note, this name must be made unique later */
549   BLI_strncpy(md->name, DATA_(mti->name), sizeof(md->name));
550
551   md->type = type;
552   md->mode = eGpencilModifierMode_Realtime | eGpencilModifierMode_Render |
553              eGpencilModifierMode_Expanded;
554   md->flag = eGpencilModifierFlag_StaticOverride_Local;
555
556   if (mti->flags & eGpencilModifierTypeFlag_EnableInEditmode) {
557     md->mode |= eGpencilModifierMode_Editmode;
558   }
559
560   if (mti->initData) {
561     mti->initData(md);
562   }
563
564   return md;
565 }
566
567 static void modifier_free_data_id_us_cb(void *UNUSED(userData),
568                                         Object *UNUSED(ob),
569                                         ID **idpoin,
570                                         int cb_flag)
571 {
572   ID *id = *idpoin;
573   if (id != NULL && (cb_flag & IDWALK_CB_USER) != 0) {
574     id_us_min(id);
575   }
576 }
577
578 void BKE_gpencil_modifier_free_ex(GpencilModifierData *md, const int flag)
579 {
580   const GpencilModifierTypeInfo *mti = BKE_gpencil_modifierType_getInfo(md->type);
581
582   if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
583     if (mti->foreachIDLink) {
584       mti->foreachIDLink(md, NULL, modifier_free_data_id_us_cb, NULL);
585     }
586     else if (mti->foreachObjectLink) {
587       mti->foreachObjectLink(
588           md, NULL, (GreasePencilObjectWalkFunc)modifier_free_data_id_us_cb, NULL);
589     }
590   }
591
592   if (mti->freeData) {
593     mti->freeData(md);
594   }
595   if (md->error) {
596     MEM_freeN(md->error);
597   }
598
599   MEM_freeN(md);
600 }
601
602 void BKE_gpencil_modifier_free(GpencilModifierData *md)
603 {
604   BKE_gpencil_modifier_free_ex(md, 0);
605 }
606
607 /* check unique name */
608 bool BKE_gpencil_modifier_unique_name(ListBase *modifiers, GpencilModifierData *gmd)
609 {
610   if (modifiers && gmd) {
611     const GpencilModifierTypeInfo *gmti = BKE_gpencil_modifierType_getInfo(gmd->type);
612     return BLI_uniquename(modifiers,
613                           gmd,
614                           DATA_(gmti->name),
615                           '.',
616                           offsetof(GpencilModifierData, name),
617                           sizeof(gmd->name));
618   }
619   return false;
620 }
621
622 bool BKE_gpencil_modifier_dependsOnTime(GpencilModifierData *md)
623 {
624   const GpencilModifierTypeInfo *mti = BKE_gpencil_modifierType_getInfo(md->type);
625
626   return mti->dependsOnTime && mti->dependsOnTime(md);
627 }
628
629 const GpencilModifierTypeInfo *BKE_gpencil_modifierType_getInfo(GpencilModifierType type)
630 {
631   /* type unsigned, no need to check < 0 */
632   if (type < NUM_GREASEPENCIL_MODIFIER_TYPES && modifier_gpencil_types[type]->name[0] != '\0') {
633     return modifier_gpencil_types[type];
634   }
635   else {
636     return NULL;
637   }
638 }
639
640 void BKE_gpencil_modifier_copyData_generic(const GpencilModifierData *md_src,
641                                            GpencilModifierData *md_dst)
642 {
643   const GpencilModifierTypeInfo *mti = BKE_gpencil_modifierType_getInfo(md_src->type);
644
645   /* md_dst may have already be fully initialized with some extra allocated data,
646    * we need to free it now to avoid memleak. */
647   if (mti->freeData) {
648     mti->freeData(md_dst);
649   }
650
651   const size_t data_size = sizeof(GpencilModifierData);
652   const char *md_src_data = ((const char *)md_src) + data_size;
653   char *md_dst_data = ((char *)md_dst) + data_size;
654   BLI_assert(data_size <= (size_t)mti->struct_size);
655   memcpy(md_dst_data, md_src_data, (size_t)mti->struct_size - data_size);
656 }
657
658 static void gpencil_modifier_copy_data_id_us_cb(void *UNUSED(userData),
659                                                 Object *UNUSED(ob),
660                                                 ID **idpoin,
661                                                 int cb_flag)
662 {
663   ID *id = *idpoin;
664   if (id != NULL && (cb_flag & IDWALK_CB_USER) != 0) {
665     id_us_plus(id);
666   }
667 }
668
669 void BKE_gpencil_modifier_copyData_ex(GpencilModifierData *md,
670                                       GpencilModifierData *target,
671                                       const int flag)
672 {
673   const GpencilModifierTypeInfo *mti = BKE_gpencil_modifierType_getInfo(md->type);
674
675   target->mode = md->mode;
676   target->flag = md->flag;
677
678   if (mti->copyData) {
679     mti->copyData(md, target);
680   }
681
682   if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
683     if (mti->foreachIDLink) {
684       mti->foreachIDLink(target, NULL, gpencil_modifier_copy_data_id_us_cb, NULL);
685     }
686     else if (mti->foreachObjectLink) {
687       mti->foreachObjectLink(
688           target, NULL, (GreasePencilObjectWalkFunc)gpencil_modifier_copy_data_id_us_cb, NULL);
689     }
690   }
691 }
692
693 void BKE_gpencil_modifier_copyData(GpencilModifierData *md, GpencilModifierData *target)
694 {
695   BKE_gpencil_modifier_copyData_ex(md, target, 0);
696 }
697
698 GpencilModifierData *BKE_gpencil_modifiers_findByType(Object *ob, GpencilModifierType type)
699 {
700   GpencilModifierData *md = ob->greasepencil_modifiers.first;
701
702   for (; md; md = md->next) {
703     if (md->type == type) {
704       break;
705     }
706   }
707
708   return md;
709 }
710
711 void BKE_gpencil_modifiers_foreachIDLink(Object *ob, GreasePencilIDWalkFunc walk, void *userData)
712 {
713   GpencilModifierData *md = ob->greasepencil_modifiers.first;
714
715   for (; md; md = md->next) {
716     const GpencilModifierTypeInfo *mti = BKE_gpencil_modifierType_getInfo(md->type);
717
718     if (mti->foreachIDLink) {
719       mti->foreachIDLink(md, ob, walk, userData);
720     }
721     else if (mti->foreachObjectLink) {
722       /* each Object can masquerade as an ID, so this should be OK */
723       GreasePencilObjectWalkFunc fp = (GreasePencilObjectWalkFunc)walk;
724       mti->foreachObjectLink(md, ob, fp, userData);
725     }
726   }
727 }
728
729 void BKE_gpencil_modifiers_foreachTexLink(Object *ob, GreasePencilTexWalkFunc walk, void *userData)
730 {
731   GpencilModifierData *md = ob->greasepencil_modifiers.first;
732
733   for (; md; md = md->next) {
734     const GpencilModifierTypeInfo *mti = BKE_gpencil_modifierType_getInfo(md->type);
735
736     if (mti->foreachTexLink) {
737       mti->foreachTexLink(md, ob, walk, userData);
738     }
739   }
740 }
741
742 GpencilModifierData *BKE_gpencil_modifiers_findByName(Object *ob, const char *name)
743 {
744   return BLI_findstring(&(ob->greasepencil_modifiers), name, offsetof(GpencilModifierData, name));
745 }
746
747 void BKE_gpencil_subdivide(bGPDstroke *gps, int level, int flag)
748 {
749   bGPDspoint *temp_points;
750   MDeformVert *temp_dverts = NULL;
751   MDeformVert *dvert = NULL;
752   MDeformVert *dvert_final = NULL;
753   MDeformVert *dvert_next = NULL;
754   int totnewpoints, oldtotpoints;
755   int i2;
756
757   for (int s = 0; s < level; s++) {
758     totnewpoints = gps->totpoints - 1;
759     /* duplicate points in a temp area */
760     temp_points = MEM_dupallocN(gps->points);
761     oldtotpoints = gps->totpoints;
762
763     /* resize the points arrays */
764     gps->totpoints += totnewpoints;
765     gps->points = MEM_recallocN(gps->points, sizeof(*gps->points) * gps->totpoints);
766     if (gps->dvert != NULL) {
767       temp_dverts = MEM_dupallocN(gps->dvert);
768       gps->dvert = MEM_recallocN(gps->dvert, sizeof(*gps->dvert) * gps->totpoints);
769     }
770     gps->flag |= GP_STROKE_RECALC_GEOMETRY;
771     gps->tot_triangles = 0;
772
773     /* move points from last to first to new place */
774     i2 = gps->totpoints - 1;
775     for (int i = oldtotpoints - 1; i > 0; i--) {
776       bGPDspoint *pt = &temp_points[i];
777       bGPDspoint *pt_final = &gps->points[i2];
778
779       copy_v3_v3(&pt_final->x, &pt->x);
780       pt_final->pressure = pt->pressure;
781       pt_final->strength = pt->strength;
782       pt_final->time = pt->time;
783       pt_final->flag = pt->flag;
784       pt_final->runtime.pt_orig = pt->runtime.pt_orig;
785
786       if (gps->dvert != NULL) {
787         dvert = &temp_dverts[i];
788         dvert_final = &gps->dvert[i2];
789         dvert_final->totweight = dvert->totweight;
790         dvert_final->dw = dvert->dw;
791       }
792       i2 -= 2;
793     }
794     /* interpolate mid points */
795     i2 = 1;
796     for (int i = 0; i < oldtotpoints - 1; i++) {
797       bGPDspoint *pt = &temp_points[i];
798       bGPDspoint *next = &temp_points[i + 1];
799       bGPDspoint *pt_final = &gps->points[i2];
800
801       /* add a half way point */
802       interp_v3_v3v3(&pt_final->x, &pt->x, &next->x, 0.5f);
803       pt_final->pressure = interpf(pt->pressure, next->pressure, 0.5f);
804       pt_final->strength = interpf(pt->strength, next->strength, 0.5f);
805       CLAMP(pt_final->strength, GPENCIL_STRENGTH_MIN, 1.0f);
806       pt_final->time = interpf(pt->time, next->time, 0.5f);
807       pt_final->runtime.pt_orig = NULL;
808
809       if (gps->dvert != NULL) {
810         dvert = &temp_dverts[i];
811         dvert_next = &temp_dverts[i + 1];
812         dvert_final = &gps->dvert[i2];
813
814         dvert_final->totweight = dvert->totweight;
815         dvert_final->dw = MEM_dupallocN(dvert->dw);
816
817         /* interpolate weight values */
818         for (int d = 0; d < dvert->totweight; d++) {
819           MDeformWeight *dw_a = &dvert->dw[d];
820           if (dvert_next->totweight > d) {
821             MDeformWeight *dw_b = &dvert_next->dw[d];
822             MDeformWeight *dw_final = &dvert_final->dw[d];
823             dw_final->weight = interpf(dw_a->weight, dw_b->weight, 0.5f);
824           }
825         }
826       }
827
828       i2 += 2;
829     }
830
831     MEM_SAFE_FREE(temp_points);
832     MEM_SAFE_FREE(temp_dverts);
833
834     /* move points to smooth stroke (not simple flag )*/
835     if ((flag & GP_SUBDIV_SIMPLE) == 0) {
836       /* duplicate points in a temp area with the new subdivide data */
837       temp_points = MEM_dupallocN(gps->points);
838
839       /* extreme points are not changed */
840       for (int i = 0; i < gps->totpoints - 2; i++) {
841         bGPDspoint *pt = &temp_points[i];
842         bGPDspoint *next = &temp_points[i + 1];
843         bGPDspoint *pt_final = &gps->points[i + 1];
844
845         /* move point */
846         interp_v3_v3v3(&pt_final->x, &pt->x, &next->x, 0.5f);
847       }
848       /* free temp memory */
849       MEM_SAFE_FREE(temp_points);
850     }
851   }
852 }
853
854 /* Copy frame but do not assign new memory */
855 static void gpencil_copy_frame(bGPDframe *gpf, bGPDframe *derived_gpf)
856 {
857   derived_gpf->prev = gpf->prev;
858   derived_gpf->next = gpf->next;
859   derived_gpf->framenum = gpf->framenum;
860   derived_gpf->flag = gpf->flag;
861   derived_gpf->key_type = gpf->key_type;
862   derived_gpf->runtime = gpf->runtime;
863   copy_m4_m4(derived_gpf->runtime.viewmatrix, gpf->runtime.viewmatrix);
864
865   /* copy strokes */
866   BLI_listbase_clear(&derived_gpf->strokes);
867   for (bGPDstroke *gps_src = gpf->strokes.first; gps_src; gps_src = gps_src->next) {
868     /* make copy of source stroke */
869     bGPDstroke *gps_dst = BKE_gpencil_stroke_duplicate(gps_src);
870
871     /* Save original pointers for using in edit and select operators. */
872     gps_dst->runtime.gps_orig = gps_src;
873     for (int i = 0; i < gps_src->totpoints; i++) {
874       bGPDspoint *pt_dst = &gps_dst->points[i];
875       pt_dst->runtime.pt_orig = &gps_src->points[i];
876     }
877
878     BLI_addtail(&derived_gpf->strokes, gps_dst);
879   }
880 }
881
882 /* Ensure there is a derived frame */
883 static void gpencil_ensure_derived_frame(
884     int idx, Object *ob, bGPDlayer *gpl, bGPDframe *gpf, bGPDframe **derived_gpf)
885 {
886   /* create derived frames array data or expand */
887   bGPDframe *derived_frames = ob->runtime.derived_frames;
888   *derived_gpf = &derived_frames[idx];
889
890   /* if derived frame create a new one */
891   if (*derived_gpf != NULL) {
892     /* first clear temp data */
893     BKE_gpencil_free_frame_runtime_data(*derived_gpf);
894   }
895   /* copy data (do not assign new memory)*/
896   gpencil_copy_frame(gpf, *derived_gpf);
897 }
898
899 /* Calculate gpencil modifiers */
900 void BKE_gpencil_modifiers_calc(Depsgraph *depsgraph, Scene *scene, Object *ob)
901 {
902   /* use original data to set reference pointers to original data */
903   Object *ob_orig = DEG_get_original_object(ob);
904   bGPdata *gpd = (bGPdata *)ob_orig->data;
905   const bool is_multiedit = (bool)GPENCIL_MULTIEDIT_SESSIONS_ON(gpd);
906   const bool simplify_modif = GP_SIMPLIFY_MODIF(scene, false);
907   const bool is_render = (bool)(DEG_get_mode(depsgraph) == DAG_EVAL_RENDER);
908   const bool time_remap = BKE_gpencil_has_time_modifiers(ob);
909   int cfra_eval = (int)DEG_get_ctime(depsgraph);
910
911   /* Create array of derived frames equal to number of layers. */
912   ob->runtime.tot_layers = BLI_listbase_count(&gpd->layers);
913   CLAMP_MIN(ob->runtime.tot_layers, 1);
914   if (ob->runtime.derived_frames == NULL) {
915     ob->runtime.derived_frames = MEM_callocN(sizeof(struct bGPDframe) * ob->runtime.tot_layers,
916                                              __func__);
917   }
918   else {
919     ob->runtime.derived_frames = MEM_reallocN(ob->runtime.derived_frames,
920                                               sizeof(struct bGPDframe) * ob->runtime.tot_layers);
921   }
922
923   /* Init general modifiers data. */
924   if (ob->greasepencil_modifiers.first) {
925     BKE_gpencil_lattice_init(ob);
926   }
927
928   /* *****************************************************************
929    * Loop all layers, duplicate data and apply modifiers.
930    *
931    * ******************************************************************/
932   int idx = 0;
933   for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
934     /* Remap frame (Time modifier) */
935     int remap_cfra = cfra_eval;
936     if ((time_remap) && (!simplify_modif)) {
937       remap_cfra = BKE_gpencil_time_modifier(depsgraph, scene, ob, gpl, cfra_eval, is_render);
938     }
939     bGPDframe *gpf = BKE_gpencil_layer_getframe(gpl, remap_cfra, GP_GETFRAME_USE_PREV);
940
941     if (gpf == NULL) {
942       idx++;
943       continue;
944     }
945
946     /* Create a duplicate data set of stroke to modify. */
947     bGPDframe *derived_gpf = NULL;
948     gpencil_ensure_derived_frame(idx, ob, gpl, gpf, &derived_gpf);
949
950     /* Skip all if some disable flag is enabled. */
951     if ((ob->greasepencil_modifiers.first == NULL) || (is_multiedit) || (simplify_modif)) {
952       idx++;
953       continue;
954     }
955
956     /* Apply geometry modifiers (create new geometry). */
957     if (BKE_gpencil_has_geometry_modifiers(ob)) {
958       BKE_gpencil_geometry_modifiers(depsgraph, ob, gpl, derived_gpf, is_render);
959     }
960
961     /* Loop all strokes and deform them. */
962     for (bGPDstroke *gps = derived_gpf->strokes.first; gps; gps = gps->next) {
963       /* Apply modifiers that only deform geometry */
964       BKE_gpencil_stroke_modifiers(depsgraph, ob, gpl, derived_gpf, gps, is_render);
965     }
966
967     idx++;
968   }
969
970   /* Clear any lattice data. */
971   if (ob->greasepencil_modifiers.first) {
972     BKE_gpencil_lattice_clear(ob);
973   }
974 }