Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / gpencil / gpencil_armature.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) 2018, Blender Foundation
17  * This is a new part of Blender
18  * Operators for dealing with armatures and GP datablocks
19  */
20
21 /** \file
22  * \ingroup edgpencil
23  */
24
25 #include <stdio.h>
26 #include <string.h>
27 #include <stdlib.h>
28 #include <stddef.h>
29 #include <math.h>
30
31 #include "MEM_guardedalloc.h"
32
33 #include "BLI_blenlib.h"
34 #include "BLI_utildefines.h"
35 #include "BLI_math.h"
36
37 #include "BLT_translation.h"
38
39 #include "DNA_armature_types.h"
40 #include "DNA_gpencil_types.h"
41 #include "DNA_meshdata_types.h"
42 #include "DNA_scene_types.h"
43
44 #include "BKE_main.h"
45 #include "BKE_action.h"
46 #include "BKE_armature.h"
47 #include "BKE_context.h"
48 #include "BKE_deform.h"
49 #include "BKE_gpencil.h"
50 #include "BKE_gpencil_modifier.h"
51 #include "BKE_object_deform.h"
52 #include "BKE_report.h"
53
54 #include "WM_api.h"
55 #include "WM_types.h"
56
57 #include "RNA_access.h"
58 #include "RNA_define.h"
59 #include "RNA_enum_types.h"
60
61 #include "ED_gpencil.h"
62 #include "ED_object.h"
63 #include "ED_mesh.h"
64
65 #include "DEG_depsgraph.h"
66 #include "DEG_depsgraph_query.h"
67
68 #include "gpencil_intern.h"
69
70 enum {
71   GP_ARMATURE_NAME = 0,
72   GP_ARMATURE_AUTO = 1,
73 };
74
75 #define DEFAULT_RATIO 0.10f
76 #define DEFAULT_DECAY 0.8f
77
78 static int gpencil_bone_looper(Object *ob,
79                                Bone *bone,
80                                void *data,
81                                int (*bone_func)(Object *, Bone *, void *))
82 {
83   /* We want to apply the function bone_func to every bone
84    * in an armature -- feed bone_looper the first bone and
85    * a pointer to the bone_func and watch it go!. The int count
86    * can be useful for counting bones with a certain property
87    * (e.g. skinnable)
88    */
89   int count = 0;
90
91   if (bone) {
92     /* only do bone_func if the bone is non null */
93     count += bone_func(ob, bone, data);
94
95     /* try to execute bone_func for the first child */
96     count += gpencil_bone_looper(ob, bone->childbase.first, data, bone_func);
97
98     /* try to execute bone_func for the next bone at this
99      * depth of the recursion.
100      */
101     count += gpencil_bone_looper(ob, bone->next, data, bone_func);
102   }
103
104   return count;
105 }
106
107 static int gpencil_bone_skinnable_cb(Object *UNUSED(ob), Bone *bone, void *datap)
108 {
109   /* Bones that are deforming
110    * are regarded to be "skinnable" and are eligible for
111    * auto-skinning.
112    *
113    * This function performs 2 functions:
114    *
115    *   a) It returns 1 if the bone is skinnable.
116    *      If we loop over all bones with this
117    *      function, we can count the number of
118    *      skinnable bones.
119    *   b) If the pointer data is non null,
120    *      it is treated like a handle to a
121    *      bone pointer -- the bone pointer
122    *      is set to point at this bone, and
123    *      the pointer the handle points to
124    *      is incremented to point to the
125    *      next member of an array of pointers
126    *      to bones. This way we can loop using
127    *      this function to construct an array of
128    *      pointers to bones that point to all
129    *      skinnable bones.
130    */
131   Bone ***hbone;
132   int a, segments;
133   struct {
134     Object *armob;
135     void *list;
136     int heat;
137   } *data = datap;
138
139   if (!(bone->flag & BONE_HIDDEN_P)) {
140     if (!(bone->flag & BONE_NO_DEFORM)) {
141       if (data->heat && data->armob->pose &&
142           BKE_pose_channel_find_name(data->armob->pose, bone->name)) {
143         segments = bone->segments;
144       }
145       else {
146         segments = 1;
147       }
148
149       if (data->list != NULL) {
150         hbone = (Bone ***)&data->list;
151
152         for (a = 0; a < segments; a++) {
153           **hbone = bone;
154           (*hbone)++;
155         }
156       }
157       return segments;
158     }
159   }
160   return 0;
161 }
162
163 static int vgroup_add_unique_bone_cb(Object *ob, Bone *bone, void *UNUSED(ptr))
164 {
165   /* This group creates a vertex group to ob that has the
166    * same name as bone (provided the bone is skinnable).
167    * If such a vertex group already exist the routine exits.
168    */
169   if (!(bone->flag & BONE_NO_DEFORM)) {
170     if (!defgroup_find_name(ob, bone->name)) {
171       BKE_object_defgroup_add_name(ob, bone->name);
172       return 1;
173     }
174   }
175   return 0;
176 }
177
178 static int dgroup_skinnable_cb(Object *ob, Bone *bone, void *datap)
179 {
180   /* Bones that are deforming
181    * are regarded to be "skinnable" and are eligible for
182    * auto-skinning.
183    *
184    * This function performs 2 functions:
185    *
186    *   a) If the bone is skinnable, it creates
187    *      a vertex group for ob that has
188    *      the name of the skinnable bone
189    *      (if one doesn't exist already).
190    *   b) If the pointer data is non null,
191    *      it is treated like a handle to a
192    *      bDeformGroup pointer -- the
193    *      bDeformGroup pointer is set to point
194    *      to the deform group with the bone's
195    *      name, and the pointer the handle
196    *      points to is incremented to point to the
197    *      next member of an array of pointers
198    *      to bDeformGroups. This way we can loop using
199    *      this function to construct an array of
200    *      pointers to bDeformGroups, all with names
201    *      of skinnable bones.
202    */
203   bDeformGroup ***hgroup, *defgroup = NULL;
204   int a, segments;
205   struct {
206     Object *armob;
207     void *list;
208     int heat;
209   } *data = datap;
210   bArmature *arm = data->armob->data;
211
212   if (!(bone->flag & BONE_HIDDEN_P)) {
213     if (!(bone->flag & BONE_NO_DEFORM)) {
214       if (data->heat && data->armob->pose &&
215           BKE_pose_channel_find_name(data->armob->pose, bone->name)) {
216         segments = bone->segments;
217       }
218       else {
219         segments = 1;
220       }
221
222       if (arm->layer & bone->layer) {
223         if (!(defgroup = defgroup_find_name(ob, bone->name))) {
224           defgroup = BKE_object_defgroup_add_name(ob, bone->name);
225         }
226         else if (defgroup->flag & DG_LOCK_WEIGHT) {
227           /* In case vgroup already exists and is locked, do not modify it here. See T43814. */
228           defgroup = NULL;
229         }
230       }
231
232       if (data->list != NULL) {
233         hgroup = (bDeformGroup ***)&data->list;
234
235         for (a = 0; a < segments; a++) {
236           **hgroup = defgroup;
237           (*hgroup)++;
238         }
239       }
240       return segments;
241     }
242   }
243   return 0;
244 }
245
246 /* get weight value depending of distance and decay value */
247 static float get_weight(float dist, float decay_rad, float dif_rad)
248 {
249   float weight = 1.0f;
250   if (dist < decay_rad) {
251     weight = 1.0f;
252   }
253   else {
254     weight = interpf(0.0f, 0.9f, (dist - decay_rad) / dif_rad);
255   }
256
257   return weight;
258 }
259
260 /* This functions implements the automatic computation of vertex group weights */
261 static void gpencil_add_verts_to_dgroups(
262     const bContext *C, Object *ob, Object *ob_arm, const float ratio, const float decay)
263 {
264   bArmature *arm = ob_arm->data;
265   Bone **bonelist, *bone;
266   bDeformGroup **dgrouplist;
267   bPoseChannel *pchan;
268   bGPdata *gpd = (bGPdata *)ob->data;
269   const bool is_multiedit = (bool)GPENCIL_MULTIEDIT_SESSIONS_ON(gpd);
270
271   Mat4 bbone_array[MAX_BBONE_SUBDIV], *bbone = NULL;
272   float(*root)[3], (*tip)[3], (*verts)[3];
273   float *radsqr;
274   int *selected;
275   float weight;
276   int numbones, i, j, segments = 0;
277   struct {
278     Object *armob;
279     void *list;
280     int heat;
281   } looper_data;
282
283   looper_data.armob = ob_arm;
284   looper_data.heat = true;
285   looper_data.list = NULL;
286
287   /* count the number of skinnable bones */
288   numbones = gpencil_bone_looper(ob, arm->bonebase.first, &looper_data, gpencil_bone_skinnable_cb);
289
290   if (numbones == 0) {
291     return;
292   }
293
294   /* create an array of pointer to bones that are skinnable
295    * and fill it with all of the skinnable bones */
296   bonelist = MEM_callocN(numbones * sizeof(Bone *), "bonelist");
297   looper_data.list = bonelist;
298   gpencil_bone_looper(ob, arm->bonebase.first, &looper_data, gpencil_bone_skinnable_cb);
299
300   /* create an array of pointers to the deform groups that
301    * correspond to the skinnable bones (creating them
302    * as necessary. */
303   dgrouplist = MEM_callocN(numbones * sizeof(bDeformGroup *), "dgrouplist");
304
305   looper_data.list = dgrouplist;
306   gpencil_bone_looper(ob, arm->bonebase.first, &looper_data, dgroup_skinnable_cb);
307
308   /* create an array of root and tip positions transformed into
309    * global coords */
310   root = MEM_callocN(numbones * sizeof(float) * 3, "root");
311   tip = MEM_callocN(numbones * sizeof(float) * 3, "tip");
312   selected = MEM_callocN(numbones * sizeof(int), "selected");
313   radsqr = MEM_callocN(numbones * sizeof(float), "radsqr");
314
315   for (j = 0; j < numbones; j++) {
316     bone = bonelist[j];
317
318     /* handle bbone */
319     if (segments == 0) {
320       segments = 1;
321       bbone = NULL;
322
323       if ((ob_arm->pose) && (pchan = BKE_pose_channel_find_name(ob_arm->pose, bone->name))) {
324         if (bone->segments > 1) {
325           segments = bone->segments;
326           BKE_pchan_bbone_spline_setup(pchan, true, false, bbone_array);
327           bbone = bbone_array;
328         }
329       }
330     }
331
332     segments--;
333
334     /* compute root and tip */
335     if (bbone) {
336       mul_v3_m4v3(root[j], bone->arm_mat, bbone[segments].mat[3]);
337       if ((segments + 1) < bone->segments) {
338         mul_v3_m4v3(tip[j], bone->arm_mat, bbone[segments + 1].mat[3]);
339       }
340       else {
341         copy_v3_v3(tip[j], bone->arm_tail);
342       }
343     }
344     else {
345       copy_v3_v3(root[j], bone->arm_head);
346       copy_v3_v3(tip[j], bone->arm_tail);
347     }
348
349     mul_m4_v3(ob_arm->obmat, root[j]);
350     mul_m4_v3(ob_arm->obmat, tip[j]);
351
352     selected[j] = 1;
353
354     /* calculate radius squared */
355     radsqr[j] = len_squared_v3v3(root[j], tip[j]) * ratio;
356   }
357
358   /* loop all strokes */
359   for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
360     bGPDframe *init_gpf = gpl->actframe;
361     bGPDspoint *pt = NULL;
362
363     if (is_multiedit) {
364       init_gpf = gpl->frames.first;
365     }
366
367     for (bGPDframe *gpf = init_gpf; gpf; gpf = gpf->next) {
368       if ((gpf == gpl->actframe) || ((gpf->flag & GP_FRAME_SELECT) && (is_multiedit))) {
369
370         if (gpf == NULL) {
371           continue;
372         }
373
374         for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
375           /* skip strokes that are invalid for current view */
376           if (ED_gpencil_stroke_can_use(C, gps) == false) {
377             continue;
378           }
379
380           BKE_gpencil_dvert_ensure(gps);
381
382           /* create verts array */
383           verts = MEM_callocN(gps->totpoints * sizeof(*verts), __func__);
384
385           /* transform stroke points to global space */
386           for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
387             copy_v3_v3(verts[i], &pt->x);
388             mul_m4_v3(ob->obmat, verts[i]);
389           }
390
391           /* loop groups and assign weight */
392           for (j = 0; j < numbones; j++) {
393             int def_nr = BLI_findindex(&ob->defbase, dgrouplist[j]);
394             if (def_nr < 0) {
395               continue;
396             }
397
398             float decay_rad = radsqr[j] - (radsqr[j] * decay);
399             float dif_rad = radsqr[j] - decay_rad;
400
401             for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
402               MDeformVert *dvert = &gps->dvert[i];
403               float dist = dist_squared_to_line_segment_v3(verts[i], root[j], tip[j]);
404               if (dist > radsqr[j]) {
405                 /* if not in cylinder, check if inside extreme spheres */
406                 weight = 0.0f;
407                 dist = len_squared_v3v3(root[j], verts[i]);
408                 if (dist < radsqr[j]) {
409                   weight = get_weight(dist, decay_rad, dif_rad);
410                 }
411                 else {
412                   dist = len_squared_v3v3(tip[j], verts[i]);
413                   if (dist < radsqr[j]) {
414                     weight = get_weight(dist, decay_rad, dif_rad);
415                   }
416                 }
417               }
418               else {
419                 /* inside bone cylinder */
420                 weight = get_weight(dist, decay_rad, dif_rad);
421               }
422
423               /* assign weight */
424               MDeformWeight *dw = defvert_verify_index(dvert, def_nr);
425               if (dw) {
426                 dw->weight = weight;
427               }
428             }
429           }
430           MEM_SAFE_FREE(verts);
431         }
432       }
433
434       /* if not multiedit, exit loop*/
435       if (!is_multiedit) {
436         break;
437       }
438     }
439   }
440
441   /* free the memory allocated */
442   MEM_SAFE_FREE(bonelist);
443   MEM_SAFE_FREE(dgrouplist);
444   MEM_SAFE_FREE(root);
445   MEM_SAFE_FREE(tip);
446   MEM_SAFE_FREE(radsqr);
447   MEM_SAFE_FREE(selected);
448 }
449
450 static void gpencil_object_vgroup_calc_from_armature(const bContext *C,
451                                                      Object *ob,
452                                                      Object *ob_arm,
453                                                      const int mode,
454                                                      const float ratio,
455                                                      const float decay)
456 {
457   /* Lets try to create some vertex groups
458    * based on the bones of the parent armature.
459    */
460   bArmature *arm = ob_arm->data;
461
462   /* always create groups */
463   const int defbase_tot = BLI_listbase_count(&ob->defbase);
464   int defbase_add;
465   /* Traverse the bone list, trying to create empty vertex
466    * groups corresponding to the bone.
467    */
468   defbase_add = gpencil_bone_looper(ob, arm->bonebase.first, NULL, vgroup_add_unique_bone_cb);
469
470   if (defbase_add) {
471     /* its possible there are DWeight's outside the range of the current
472      * objects deform groups, in this case the new groups wont be empty */
473     ED_vgroup_data_clamp_range(ob->data, defbase_tot);
474   }
475
476   if (mode == GP_ARMATURE_AUTO) {
477     /* Traverse the bone list, trying to fill vertex groups
478      * with the corresponding vertice weights for which the
479      * bone is closest.
480      */
481     gpencil_add_verts_to_dgroups(C, ob, ob_arm, ratio, decay);
482   }
483 }
484
485 bool ED_gpencil_add_armature_weights(
486     const bContext *C, ReportList *reports, Object *ob, Object *ob_arm, int mode)
487 {
488   Main *bmain = CTX_data_main(C);
489   Scene *scene = CTX_data_scene(C);
490
491   if (ob == NULL) {
492     return false;
493   }
494
495   /* if no armature modifier, add a new one */
496   GpencilModifierData *md = BKE_gpencil_modifiers_findByType(ob, eGpencilModifierType_Armature);
497   if (md == NULL) {
498     md = ED_object_gpencil_modifier_add(
499         reports, bmain, scene, ob, "Armature", eGpencilModifierType_Armature);
500     if (md == NULL) {
501       BKE_report(reports, RPT_ERROR, "Unable to add a new Armature modifier to object");
502       return false;
503     }
504     DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
505   }
506
507   /* verify armature */
508   ArmatureGpencilModifierData *mmd = (ArmatureGpencilModifierData *)md;
509   if (mmd->object == NULL) {
510     mmd->object = ob_arm;
511   }
512   else {
513     if (ob_arm != mmd->object) {
514       BKE_report(reports,
515                  RPT_ERROR,
516                  "The existing Armature modifier is already using a different Armature object");
517       return false;
518     }
519   }
520
521   /* add weights */
522   gpencil_object_vgroup_calc_from_armature(C, ob, ob_arm, mode, DEFAULT_RATIO, DEFAULT_DECAY);
523
524   return true;
525 }
526 /* ***************** Generate armature weights ************************** */
527 static bool gpencil_generate_weights_poll(bContext *C)
528 {
529   Object *ob = CTX_data_active_object(C);
530
531   if (ob == NULL) {
532     return false;
533   }
534
535   if (ob->type != OB_GPENCIL) {
536     return false;
537   }
538
539   ViewLayer *view_layer = CTX_data_view_layer(C);
540   bGPdata *gpd = (bGPdata *)ob->data;
541
542   if (BLI_listbase_count(&gpd->layers) == 0) {
543     return false;
544   }
545
546   /* need some armature in the view layer */
547   for (Base *base = view_layer->object_bases.first; base; base = base->next) {
548     if (base->object->type == OB_ARMATURE) {
549       return true;
550     }
551   }
552
553   return false;
554 }
555
556 static int gpencil_generate_weights_exec(bContext *C, wmOperator *op)
557 {
558   Depsgraph *depsgraph = CTX_data_depsgraph(C);
559   ViewLayer *view_layer = CTX_data_view_layer(C);
560   Object *ob = CTX_data_active_object(C);
561   Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
562   bGPdata *gpd = (bGPdata *)ob->data;
563   Object *ob_arm = NULL;
564
565   const int mode = RNA_enum_get(op->ptr, "mode");
566   const float ratio = RNA_float_get(op->ptr, "ratio");
567   const float decay = RNA_float_get(op->ptr, "decay");
568
569   /* sanity checks */
570   if (ELEM(NULL, ob, gpd)) {
571     return OPERATOR_CANCELLED;
572   }
573
574   /* get armature */
575   const int arm_idx = RNA_enum_get(op->ptr, "armature");
576   if (arm_idx > 0) {
577     Base *base = BLI_findlink(&view_layer->object_bases, arm_idx - 1);
578     ob_arm = base->object;
579   }
580   else {
581     /* get armature from modifier */
582     GpencilModifierData *md = BKE_gpencil_modifiers_findByType(ob_eval,
583                                                                eGpencilModifierType_Armature);
584     if (md == NULL) {
585       BKE_report(op->reports, RPT_ERROR, "The grease pencil object need an Armature modifier");
586       return OPERATOR_CANCELLED;
587     }
588
589     ArmatureGpencilModifierData *mmd = (ArmatureGpencilModifierData *)md;
590     if (mmd->object == NULL) {
591       BKE_report(op->reports, RPT_ERROR, "Armature modifier is not valid or wrong defined");
592       return OPERATOR_CANCELLED;
593     }
594
595     ob_arm = mmd->object;
596   }
597
598   if (ob_arm == NULL) {
599     BKE_report(op->reports, RPT_ERROR, "No Armature object in the view layer");
600     return OPERATOR_CANCELLED;
601   }
602
603   gpencil_object_vgroup_calc_from_armature(C, ob, ob_arm, mode, ratio, decay);
604
605   /* notifiers */
606   DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
607   WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
608
609   return OPERATOR_FINISHED;
610 }
611
612 /* Dynamically populate an enum of Armatures */
613 static const EnumPropertyItem *gpencil_armatures_enum_itemf(bContext *C,
614                                                             PointerRNA *UNUSED(ptr),
615                                                             PropertyRNA *UNUSED(prop),
616                                                             bool *r_free)
617 {
618   ViewLayer *view_layer = CTX_data_view_layer(C);
619   EnumPropertyItem *item = NULL, item_tmp = {0};
620   int totitem = 0;
621   int i = 0;
622
623   if (C == NULL) {
624     return DummyRNA_DEFAULT_items;
625   }
626
627   /* add default */
628   item_tmp.identifier = "DEFAULT";
629   item_tmp.name = "Default";
630   item_tmp.value = 0;
631   RNA_enum_item_add(&item, &totitem, &item_tmp);
632   i++;
633
634   for (Base *base = view_layer->object_bases.first; base; base = base->next) {
635     Object *ob = base->object;
636     if (ob->type == OB_ARMATURE) {
637       item_tmp.identifier = item_tmp.name = ob->id.name + 2;
638       item_tmp.value = i;
639       RNA_enum_item_add(&item, &totitem, &item_tmp);
640     }
641     i++;
642   }
643
644   RNA_enum_item_end(&item, &totitem);
645   *r_free = true;
646
647   return item;
648 }
649
650 void GPENCIL_OT_generate_weights(wmOperatorType *ot)
651 {
652   static const EnumPropertyItem mode_type[] = {
653       {GP_ARMATURE_NAME, "NAME", 0, "Empty Groups", ""},
654       {GP_ARMATURE_AUTO, "AUTO", 0, "Automatic Weights", ""},
655       {0, NULL, 0, NULL, NULL},
656   };
657
658   PropertyRNA *prop;
659
660   /* identifiers */
661   ot->name = "Generate Automatic Weights";
662   ot->idname = "GPENCIL_OT_generate_weights";
663   ot->description = "Generate automatic weights for armatures (requires armature modifier)";
664
665   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
666
667   /* callbacks */
668   ot->exec = gpencil_generate_weights_exec;
669   ot->poll = gpencil_generate_weights_poll;
670
671   ot->prop = RNA_def_enum(ot->srna, "mode", mode_type, 0, "Mode", "");
672
673   prop = RNA_def_enum(
674       ot->srna, "armature", DummyRNA_DEFAULT_items, 0, "Armature", "Armature to use");
675   RNA_def_enum_funcs(prop, gpencil_armatures_enum_itemf);
676
677   RNA_def_float(ot->srna,
678                 "ratio",
679                 DEFAULT_RATIO,
680                 0.0f,
681                 2.0f,
682                 "Ratio",
683                 "Ratio between bone length and influence radius",
684                 0.001f,
685                 1.0f);
686
687   RNA_def_float(ot->srna,
688                 "decay",
689                 DEFAULT_DECAY,
690                 0.0f,
691                 1.0f,
692                 "Decay",
693                 "Factor to reduce influence depending of distance to bone axis",
694                 0.0f,
695                 1.0f);
696 }