Cleanup: style, use braces for blenkernel
[blender.git] / source / blender / blenkernel / intern / crazyspace.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) 2005 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include "MEM_guardedalloc.h"
25
26 #include "DNA_scene_types.h"
27 #include "DNA_object_types.h"
28 #include "DNA_modifier_types.h"
29 #include "DNA_mesh_types.h"
30 #include "DNA_meshdata_types.h"
31
32 #include "BLI_utildefines.h"
33 #include "BLI_linklist.h"
34 #include "BLI_math.h"
35
36 #include "BKE_crazyspace.h"
37 #include "BKE_DerivedMesh.h"
38 #include "BKE_modifier.h"
39 #include "BKE_multires.h"
40 #include "BKE_mesh.h"
41 #include "BKE_editmesh.h"
42 #include "BKE_library.h"
43
44 #include "DEG_depsgraph_query.h"
45
46 BLI_INLINE void tan_calc_quat_v3(float r_quat[4],
47                                  const float co_1[3],
48                                  const float co_2[3],
49                                  const float co_3[3])
50 {
51   float vec_u[3], vec_v[3];
52   float nor[3];
53
54   sub_v3_v3v3(vec_u, co_1, co_2);
55   sub_v3_v3v3(vec_v, co_1, co_3);
56
57   cross_v3_v3v3(nor, vec_u, vec_v);
58
59   if (normalize_v3(nor) > FLT_EPSILON) {
60     const float zero_vec[3] = {0.0f};
61     tri_to_quat_ex(r_quat, zero_vec, vec_u, vec_v, nor);
62   }
63   else {
64     unit_qt(r_quat);
65   }
66 }
67
68 static void set_crazy_vertex_quat(float r_quat[4],
69                                   const float co_1[3],
70                                   const float co_2[3],
71                                   const float co_3[3],
72                                   const float vd_1[3],
73                                   const float vd_2[3],
74                                   const float vd_3[3])
75 {
76   float q1[4], q2[4];
77
78   tan_calc_quat_v3(q1, co_1, co_2, co_3);
79   tan_calc_quat_v3(q2, vd_1, vd_2, vd_3);
80
81   sub_qt_qtqt(r_quat, q2, q1);
82 }
83
84 static int modifiers_disable_subsurf_temporary(Object *ob)
85 {
86   ModifierData *md;
87   int disabled = 0;
88
89   for (md = ob->modifiers.first; md; md = md->next) {
90     if (md->type == eModifierType_Subsurf) {
91       if (md->mode & eModifierMode_OnCage) {
92         md->mode ^= eModifierMode_DisableTemporary;
93         disabled = 1;
94       }
95     }
96   }
97
98   return disabled;
99 }
100
101 /* disable subsurf temporal, get mapped cos, and enable it */
102 float (*BKE_crazyspace_get_mapped_editverts(struct Depsgraph *depsgraph,
103                                             Scene *scene,
104                                             Object *obedit))[3]
105 {
106   Mesh *me = obedit->data;
107   Mesh *me_eval;
108   float(*vertexcos)[3];
109   int nverts = me->edit_mesh->bm->totvert;
110
111   /* disable subsurf temporal, get mapped cos, and enable it */
112   if (modifiers_disable_subsurf_temporary(obedit)) {
113     /* need to make new derivemesh */
114     makeDerivedMesh(depsgraph, scene, obedit, me->edit_mesh, &CD_MASK_BAREMESH);
115   }
116
117   /* now get the cage */
118   vertexcos = MEM_mallocN(sizeof(*vertexcos) * nverts, "vertexcos map");
119
120   me_eval = editbmesh_get_eval_cage_from_orig(
121       depsgraph, scene, obedit, me->edit_mesh, &CD_MASK_BAREMESH);
122
123   mesh_get_mapped_verts_coords(me_eval, vertexcos, nverts);
124
125   /* set back the flag, no new cage needs to be built, transform does it */
126   modifiers_disable_subsurf_temporary(obedit);
127
128   return vertexcos;
129 }
130
131 void BKE_crazyspace_set_quats_editmesh(BMEditMesh *em,
132                                        float (*origcos)[3],
133                                        float (*mappedcos)[3],
134                                        float (*quats)[4],
135                                        const bool use_select)
136 {
137   BMFace *f;
138   BMIter iter;
139   int index;
140
141   {
142     BMVert *v;
143     BM_ITER_MESH_INDEX (v, &iter, em->bm, BM_VERTS_OF_MESH, index) {
144       BM_elem_flag_disable(v, BM_ELEM_TAG);
145       BM_elem_index_set(v, index); /* set_inline */
146     }
147     em->bm->elem_index_dirty &= ~BM_VERT;
148   }
149
150   BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
151     BMLoop *l_iter, *l_first;
152
153     l_iter = l_first = BM_FACE_FIRST_LOOP(f);
154     do {
155       if (BM_elem_flag_test(l_iter->v, BM_ELEM_HIDDEN) ||
156           BM_elem_flag_test(l_iter->v, BM_ELEM_TAG) ||
157           (use_select && !BM_elem_flag_test(l_iter->v, BM_ELEM_SELECT))) {
158         continue;
159       }
160
161       if (!BM_elem_flag_test(l_iter->v, BM_ELEM_TAG)) {
162         const float *co_prev, *co_curr, *co_next; /* orig */
163         const float *vd_prev, *vd_curr, *vd_next; /* deform */
164
165         const int i_prev = BM_elem_index_get(l_iter->prev->v);
166         const int i_curr = BM_elem_index_get(l_iter->v);
167         const int i_next = BM_elem_index_get(l_iter->next->v);
168
169         /* retrieve mapped coordinates */
170         vd_prev = mappedcos[i_prev];
171         vd_curr = mappedcos[i_curr];
172         vd_next = mappedcos[i_next];
173
174         if (origcos) {
175           co_prev = origcos[i_prev];
176           co_curr = origcos[i_curr];
177           co_next = origcos[i_next];
178         }
179         else {
180           co_prev = l_iter->prev->v->co;
181           co_curr = l_iter->v->co;
182           co_next = l_iter->next->v->co;
183         }
184
185         set_crazy_vertex_quat(quats[i_curr], co_curr, co_next, co_prev, vd_curr, vd_next, vd_prev);
186
187         BM_elem_flag_enable(l_iter->v, BM_ELEM_TAG);
188       }
189     } while ((l_iter = l_iter->next) != l_first);
190   }
191 }
192
193 void BKE_crazyspace_set_quats_mesh(Mesh *me,
194                                    float (*origcos)[3],
195                                    float (*mappedcos)[3],
196                                    float (*quats)[4])
197 {
198   int i;
199   MVert *mvert;
200   MLoop *mloop;
201   MPoly *mp;
202
203   mvert = me->mvert;
204   for (i = 0; i < me->totvert; i++, mvert++) {
205     mvert->flag &= ~ME_VERT_TMP_TAG;
206   }
207
208   /* first store two sets of tangent vectors in vertices, we derive it just from the face-edges */
209   mvert = me->mvert;
210   mp = me->mpoly;
211   mloop = me->mloop;
212
213   for (i = 0; i < me->totpoly; i++, mp++) {
214     MLoop *ml_prev, *ml_curr, *ml_next;
215     int j;
216
217     ml_next = &mloop[mp->loopstart];
218     ml_curr = &ml_next[mp->totloop - 1];
219     ml_prev = &ml_next[mp->totloop - 2];
220
221     for (j = 0; j < mp->totloop; j++) {
222       if ((mvert[ml_curr->v].flag & ME_VERT_TMP_TAG) == 0) {
223         const float *co_prev, *co_curr, *co_next; /* orig */
224         const float *vd_prev, *vd_curr, *vd_next; /* deform */
225
226         /* retrieve mapped coordinates */
227         vd_prev = mappedcos[ml_prev->v];
228         vd_curr = mappedcos[ml_curr->v];
229         vd_next = mappedcos[ml_next->v];
230
231         if (origcos) {
232           co_prev = origcos[ml_prev->v];
233           co_curr = origcos[ml_curr->v];
234           co_next = origcos[ml_next->v];
235         }
236         else {
237           co_prev = mvert[ml_prev->v].co;
238           co_curr = mvert[ml_curr->v].co;
239           co_next = mvert[ml_next->v].co;
240         }
241
242         set_crazy_vertex_quat(
243             quats[ml_curr->v], co_curr, co_next, co_prev, vd_curr, vd_next, vd_prev);
244
245         mvert[ml_curr->v].flag |= ME_VERT_TMP_TAG;
246       }
247
248       ml_prev = ml_curr;
249       ml_curr = ml_next;
250       ml_next++;
251     }
252   }
253 }
254
255 /** returns an array of deform matrices for crazyspace correction, and the
256  * number of modifiers left */
257 int BKE_crazyspace_get_first_deform_matrices_editbmesh(struct Depsgraph *depsgraph,
258                                                        Scene *scene,
259                                                        Object *ob,
260                                                        BMEditMesh *em,
261                                                        float (**deformmats)[3][3],
262                                                        float (**deformcos)[3])
263 {
264   ModifierData *md;
265   Mesh *me;
266   int i, a, numleft = 0, numVerts = 0;
267   int cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1);
268   float(*defmats)[3][3] = NULL, (*deformedVerts)[3] = NULL;
269   VirtualModifierData virtualModifierData;
270   ModifierEvalContext mectx = {depsgraph, ob, 0};
271
272   modifiers_clearErrors(ob);
273
274   me = NULL;
275   md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
276
277   /* compute the deformation matrices and coordinates for the first
278    * modifiers with on cage editing that are enabled and support computing
279    * deform matrices */
280   for (i = 0; md && i <= cageIndex; i++, md = md->next) {
281     const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
282
283     if (!editbmesh_modifier_is_enabled(scene, md, me != NULL)) {
284       continue;
285     }
286
287     if (mti->type == eModifierTypeType_OnlyDeform && mti->deformMatricesEM) {
288       if (!defmats) {
289         const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
290         CustomData_MeshMasks data_mask = CD_MASK_BAREMESH;
291         CDMaskLink *datamasks = modifiers_calcDataMasks(
292             scene, ob, md, &data_mask, required_mode, NULL, NULL);
293         data_mask = datamasks->mask;
294         BLI_linklist_free((LinkNode *)datamasks, NULL);
295
296         me = BKE_mesh_from_editmesh_with_coords_thin_wrap(em, &data_mask, NULL);
297         deformedVerts = editbmesh_get_vertex_cos(em, &numVerts);
298         defmats = MEM_mallocN(sizeof(*defmats) * numVerts, "defmats");
299
300         for (a = 0; a < numVerts; a++) {
301           unit_m3(defmats[a]);
302         }
303       }
304       mti->deformMatricesEM(md, &mectx, em, me, deformedVerts, defmats, numVerts);
305     }
306     else {
307       break;
308     }
309   }
310
311   for (; md && i <= cageIndex; md = md->next, i++) {
312     if (editbmesh_modifier_is_enabled(scene, md, me != NULL) &&
313         modifier_isCorrectableDeformed(md)) {
314       numleft++;
315     }
316   }
317
318   if (me) {
319     BKE_id_free(NULL, me);
320   }
321
322   *deformmats = defmats;
323   *deformcos = deformedVerts;
324
325   return numleft;
326 }
327
328 /**
329  * Crazyspace evaluation needs to have an object which has all the fields
330  * evaluated, but the mesh data being at undeformed state. This way it can
331  * re-apply modifiers and also have proper pointers to key data blocks.
332  *
333  * Similar to #BKE_object_eval_reset(), but does not modify the actual evaluated object.
334  */
335 static void crazyspace_init_object_for_eval(struct Depsgraph *depsgraph,
336                                             Object *object,
337                                             Object *object_crazy)
338 {
339   Object *object_eval = DEG_get_evaluated_object(depsgraph, object);
340   *object_crazy = *object_eval;
341   if (object_crazy->runtime.mesh_orig != NULL) {
342     object_crazy->data = object_crazy->runtime.mesh_orig;
343   }
344 }
345
346 int BKE_sculpt_get_first_deform_matrices(struct Depsgraph *depsgraph,
347                                          Scene *scene,
348                                          Object *object,
349                                          float (**deformmats)[3][3],
350                                          float (**deformcos)[3])
351 {
352   ModifierData *md;
353   Mesh *me_eval;
354   int a, numVerts = 0;
355   float(*defmats)[3][3] = NULL, (*deformedVerts)[3] = NULL;
356   int numleft = 0;
357   VirtualModifierData virtualModifierData;
358   Object object_eval;
359   crazyspace_init_object_for_eval(depsgraph, object, &object_eval);
360   MultiresModifierData *mmd = get_multires_modifier(scene, &object_eval, 0);
361   const bool has_multires = mmd != NULL && mmd->sculptlvl > 0;
362   const ModifierEvalContext mectx = {depsgraph, &object_eval, 0};
363
364   if (has_multires) {
365     *deformmats = NULL;
366     *deformcos = NULL;
367     return numleft;
368   }
369
370   me_eval = NULL;
371
372   md = modifiers_getVirtualModifierList(&object_eval, &virtualModifierData);
373
374   for (; md; md = md->next) {
375     const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
376
377     if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) {
378       continue;
379     }
380
381     if (mti->type == eModifierTypeType_OnlyDeform) {
382       if (!defmats) {
383         /* NOTE: Evaluated object si re-set to its original undeformed
384          * state. */
385         Mesh *me = object_eval.data;
386         me_eval = BKE_mesh_copy_for_eval(me, true);
387         deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
388         defmats = MEM_callocN(sizeof(*defmats) * numVerts, "defmats");
389
390         for (a = 0; a < numVerts; a++) {
391           unit_m3(defmats[a]);
392         }
393       }
394
395       if (mti->deformMatrices) {
396         mti->deformMatrices(md, &mectx, me_eval, deformedVerts, defmats, numVerts);
397       }
398       else {
399         break;
400       }
401     }
402   }
403
404   for (; md; md = md->next) {
405     const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
406
407     if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) {
408       continue;
409     }
410
411     if (mti->type == eModifierTypeType_OnlyDeform) {
412       numleft++;
413     }
414   }
415
416   if (me_eval) {
417     BKE_id_free(NULL, me_eval);
418   }
419
420   *deformmats = defmats;
421   *deformcos = deformedVerts;
422
423   return numleft;
424 }
425
426 void BKE_crazyspace_build_sculpt(struct Depsgraph *depsgraph,
427                                  Scene *scene,
428                                  Object *object,
429                                  float (**deformmats)[3][3],
430                                  float (**deformcos)[3])
431 {
432   int totleft = BKE_sculpt_get_first_deform_matrices(
433       depsgraph, scene, object, deformmats, deformcos);
434
435   if (totleft) {
436     /* there are deformation modifier which doesn't support deformation matrices
437      * calculation. Need additional crazyspace correction */
438
439     float(*deformedVerts)[3] = *deformcos;
440     float(*origVerts)[3] = MEM_dupallocN(deformedVerts);
441     float(*quats)[4];
442     int i, deformed = 0;
443     VirtualModifierData virtualModifierData;
444     Object object_eval;
445     crazyspace_init_object_for_eval(depsgraph, object, &object_eval);
446     ModifierData *md = modifiers_getVirtualModifierList(&object_eval, &virtualModifierData);
447     const ModifierEvalContext mectx = {depsgraph, &object_eval, 0};
448     Mesh *mesh = (Mesh *)object->data;
449
450     for (; md; md = md->next) {
451       const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
452
453       if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) {
454         continue;
455       }
456
457       if (mti->type == eModifierTypeType_OnlyDeform) {
458         /* skip leading modifiers which have been already
459          * handled in sculpt_get_first_deform_matrices */
460         if (mti->deformMatrices && !deformed) {
461           continue;
462         }
463
464         mti->deformVerts(md, &mectx, NULL, deformedVerts, mesh->totvert);
465         deformed = 1;
466       }
467     }
468
469     quats = MEM_mallocN(mesh->totvert * sizeof(*quats), "crazy quats");
470
471     BKE_crazyspace_set_quats_mesh(mesh, origVerts, deformedVerts, quats);
472
473     for (i = 0; i < mesh->totvert; i++) {
474       float qmat[3][3], tmat[3][3];
475
476       quat_to_mat3(qmat, quats[i]);
477       mul_m3_m3m3(tmat, qmat, (*deformmats)[i]);
478       copy_m3_m3((*deformmats)[i], tmat);
479     }
480
481     MEM_freeN(origVerts);
482     MEM_freeN(quats);
483   }
484
485   if (*deformmats == NULL) {
486     int a, numVerts;
487     Mesh *mesh = (Mesh *)object->data;
488
489     *deformcos = BKE_mesh_vertexCos_get(mesh, &numVerts);
490     *deformmats = MEM_callocN(sizeof(*(*deformmats)) * numVerts, "defmats");
491
492     for (a = 0; a < numVerts; a++) {
493       unit_m3((*deformmats)[a]);
494     }
495   }
496 }