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