Merge branch 'master' into blender2.8
[blender.git] / source / blender / blenkernel / intern / crazyspace.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2005 Blender Foundation.
19  * All rights reserved.
20  *
21  *
22  * Contributor(s): Blender Foundation,
23  *                 Sergey Sharybin
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/blenkernel/intern/crazyspace.c
29  *  \ingroup bke
30  */
31
32
33 #include "MEM_guardedalloc.h"
34
35 #include "DNA_scene_types.h"
36 #include "DNA_object_types.h"
37 #include "DNA_modifier_types.h"
38 #include "DNA_mesh_types.h"
39 #include "DNA_meshdata_types.h"
40
41 #include "BLI_utildefines.h"
42 #include "BLI_linklist.h"
43 #include "BLI_math.h"
44
45 #include "BKE_crazyspace.h"
46 #include "BKE_DerivedMesh.h"
47 #include "BKE_modifier.h"
48 #include "BKE_multires.h"
49 #include "BKE_mesh.h"
50 #include "BKE_editmesh.h"
51 #include "BKE_library.h"
52
53 #include "DEG_depsgraph_query.h"
54
55 BLI_INLINE void tan_calc_quat_v3(
56         float r_quat[4],
57         const float co_1[3], const float co_2[3], const float co_3[3])
58 {
59         float vec_u[3], vec_v[3];
60         float nor[3];
61
62         sub_v3_v3v3(vec_u, co_1, co_2);
63         sub_v3_v3v3(vec_v, co_1, co_3);
64
65         cross_v3_v3v3(nor, vec_u, vec_v);
66
67         if (normalize_v3(nor) > FLT_EPSILON) {
68                 const float zero_vec[3] = {0.0f};
69                 tri_to_quat_ex(r_quat, zero_vec, vec_u, vec_v, nor);
70         }
71         else {
72                 unit_qt(r_quat);
73         }
74 }
75
76 static void set_crazy_vertex_quat(
77         float r_quat[4],
78         const float co_1[3], const float co_2[3], const float co_3[3],
79         const float vd_1[3], const float vd_2[3], const float vd_3[3])
80 {
81         float q1[4], q2[4];
82
83         tan_calc_quat_v3(q1, co_1, co_2, co_3);
84         tan_calc_quat_v3(q2, vd_1, vd_2, vd_3);
85
86         sub_qt_qtqt(r_quat, q2, q1);
87 }
88
89 static int modifiers_disable_subsurf_temporary(Object *ob)
90 {
91         ModifierData *md;
92         int disabled = 0;
93
94         for (md = ob->modifiers.first; md; md = md->next)
95                 if (md->type == eModifierType_Subsurf)
96                         if (md->mode & eModifierMode_OnCage) {
97                                 md->mode ^= eModifierMode_DisableTemporary;
98                                 disabled = 1;
99                         }
100
101         return disabled;
102 }
103
104 /* disable subsurf temporal, get mapped cos, and enable it */
105 float (*BKE_crazyspace_get_mapped_editverts(
106            struct Depsgraph *depsgraph, Scene *scene, Object *obedit))[3]
107 {
108         Mesh *me = obedit->data;
109         Mesh *me_eval;
110         float (*vertexcos)[3];
111         int nverts = me->edit_btmesh->bm->totvert;
112
113         /* disable subsurf temporal, get mapped cos, and enable it */
114         if (modifiers_disable_subsurf_temporary(obedit)) {
115                 /* need to make new derivemesh */
116                 makeDerivedMesh(depsgraph, scene, obedit, me->edit_btmesh, CD_MASK_BAREMESH, false);
117         }
118
119         /* now get the cage */
120         vertexcos = MEM_mallocN(sizeof(*vertexcos) * nverts, "vertexcos map");
121
122         me_eval = editbmesh_get_eval_cage_from_orig(depsgraph, scene, obedit, me->edit_btmesh, CD_MASK_BAREMESH);
123
124         mesh_get_mapped_verts_coords(me_eval, vertexcos, nverts);
125
126         /* set back the flag, no new cage needs to be built, transform does it */
127         modifiers_disable_subsurf_temporary(obedit);
128
129         return vertexcos;
130 }
131
132 void BKE_crazyspace_set_quats_editmesh(BMEditMesh *em, float (*origcos)[3], float (*mappedcos)[3], 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                         {
157                                 continue;
158                         }
159
160                         if (!BM_elem_flag_test(l_iter->v, BM_ELEM_TAG)) {
161                                 const float *co_prev, *co_curr, *co_next;  /* orig */
162                                 const float *vd_prev, *vd_curr, *vd_next;  /* deform */
163
164                                 const int i_prev = BM_elem_index_get(l_iter->prev->v);
165                                 const int i_curr = BM_elem_index_get(l_iter->v);
166                                 const int i_next = BM_elem_index_get(l_iter->next->v);
167
168                                 /* retrieve mapped coordinates */
169                                 vd_prev = mappedcos[i_prev];
170                                 vd_curr = mappedcos[i_curr];
171                                 vd_next = mappedcos[i_next];
172
173                                 if (origcos) {
174                                         co_prev = origcos[i_prev];
175                                         co_curr = origcos[i_curr];
176                                         co_next = origcos[i_next];
177                                 }
178                                 else {
179                                         co_prev = l_iter->prev->v->co;
180                                         co_curr = l_iter->v->co;
181                                         co_next = l_iter->next->v->co;
182                                 }
183
184                                 set_crazy_vertex_quat(quats[i_curr],
185                                                       co_curr, co_next, co_prev,
186                                                       vd_curr, vd_next, vd_prev);
187
188                                 BM_elem_flag_enable(l_iter->v, BM_ELEM_TAG);
189                         }
190                 } while ((l_iter = l_iter->next) != l_first);
191         }
192 }
193
194 void BKE_crazyspace_set_quats_mesh(Mesh *me, float (*origcos)[3], float (*mappedcos)[3], 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(quats[ml_curr->v],
240                                                       co_curr, co_next, co_prev,
241                                                       vd_curr, vd_next, vd_prev);
242
243                                 mvert[ml_curr->v].flag |= ME_VERT_TMP_TAG;
244                         }
245
246                         ml_prev = ml_curr;
247                         ml_curr = ml_next;
248                         ml_next++;
249                 }
250         }
251 }
252
253 /** returns an array of deform matrices for crazyspace correction, and the
254  * number of modifiers left */
255 int BKE_crazyspace_get_first_deform_matrices_editbmesh(
256         struct Depsgraph *depsgraph, Scene *scene, Object *ob, BMEditMesh *em,
257         float (**deformmats)[3][3], float (**deformcos)[3])
258 {
259         ModifierData *md;
260         Mesh *me;
261         int i, a, numleft = 0, numVerts = 0;
262         int cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1);
263         float (*defmats)[3][3] = NULL, (*deformedVerts)[3] = NULL;
264         VirtualModifierData virtualModifierData;
265         ModifierEvalContext mectx = {depsgraph, ob, 0};
266
267         modifiers_clearErrors(ob);
268
269         me = NULL;
270         md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
271
272         /* compute the deformation matrices and coordinates for the first
273          * modifiers with on cage editing that are enabled and support computing
274          * deform matrices */
275         for (i = 0; md && i <= cageIndex; i++, md = md->next) {
276                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
277
278                 if (!editbmesh_modifier_is_enabled(scene, md, me != NULL))
279                         continue;
280
281                 if (mti->type == eModifierTypeType_OnlyDeform && mti->deformMatricesEM) {
282                         if (!defmats) {
283                                 const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
284                                 CustomDataMask data_mask = CD_MASK_BAREMESH;
285                                 CDMaskLink *datamasks = modifiers_calcDataMasks(scene, ob, md, data_mask, required_mode, NULL, 0);
286                                 data_mask = datamasks->mask;
287                                 BLI_linklist_free((LinkNode *)datamasks, NULL);
288
289                                 me = BKE_mesh_from_editmesh_with_coords_thin_wrap(em, data_mask, NULL);
290                                 deformedVerts = editbmesh_get_vertex_cos(em, &numVerts);
291                                 defmats = MEM_mallocN(sizeof(*defmats) * numVerts, "defmats");
292
293                                 for (a = 0; a < numVerts; a++)
294                                         unit_m3(defmats[a]);
295                         }
296                         mti->deformMatricesEM(md, &mectx, em, me, deformedVerts, defmats, numVerts);
297                 }
298                 else
299                         break;
300         }
301
302         for (; md && i <= cageIndex; md = md->next, i++)
303                 if (editbmesh_modifier_is_enabled(scene, md, me != NULL) && modifier_isCorrectableDeformed(md))
304                         numleft++;
305
306         if (me) {
307                 BKE_id_free(NULL, me);
308         }
309
310         *deformmats = defmats;
311         *deformcos = deformedVerts;
312
313         return numleft;
314 }
315
316 int BKE_sculpt_get_first_deform_matrices(
317         struct Depsgraph *depsgraph, Scene *scene,
318         Object *object, float (**deformmats)[3][3], float (**deformcos)[3])
319 {
320         ModifierData *md;
321         Mesh *me_eval;
322         int a, numVerts = 0;
323         float (*defmats)[3][3] = NULL, (*deformedVerts)[3] = NULL;
324         int numleft = 0;
325         VirtualModifierData virtualModifierData;
326         Object *object_eval = DEG_get_evaluated_object(depsgraph, object);
327         MultiresModifierData *mmd = get_multires_modifier(scene, object_eval, 0);
328         const bool has_multires = mmd != NULL && mmd->sculptlvl > 0;
329         const ModifierEvalContext mectx = {depsgraph, object_eval, 0};
330
331         if (has_multires) {
332                 *deformmats = NULL;
333                 *deformcos = NULL;
334                 return numleft;
335         }
336
337         me_eval = NULL;
338         md = modifiers_getVirtualModifierList(object_eval, &virtualModifierData);
339
340         for (; md; md = md->next) {
341                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
342
343                 if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) continue;
344
345                 if (mti->type == eModifierTypeType_OnlyDeform) {
346                         if (!defmats) {
347                                 /* NOTE: Need to start with original undeformed mesh. */
348                                 Mesh *me = object->data;
349                                 me_eval = BKE_mesh_copy_for_eval(me, true);
350                                 deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
351                                 defmats = MEM_callocN(sizeof(*defmats) * numVerts, "defmats");
352
353                                 for (a = 0; a < numVerts; a++)
354                                         unit_m3(defmats[a]);
355                         }
356
357                         if (mti->deformMatrices) {
358                                 mti->deformMatrices(md, &mectx, me_eval, deformedVerts, defmats, numVerts);
359                         }
360                         else break;
361                 }
362         }
363
364         for (; md; md = md->next) {
365                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
366
367                 if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) continue;
368
369                 if (mti->type == eModifierTypeType_OnlyDeform)
370                         numleft++;
371         }
372
373         if (me_eval) {
374                 BKE_id_free(NULL, me_eval);
375         }
376
377         *deformmats = defmats;
378         *deformcos = deformedVerts;
379
380         return numleft;
381 }
382
383 void BKE_crazyspace_build_sculpt(
384         struct Depsgraph *depsgraph, Scene *scene, Object *object,
385         float (**deformmats)[3][3], float (**deformcos)[3])
386 {
387         int totleft = BKE_sculpt_get_first_deform_matrices(depsgraph, scene, object, deformmats, deformcos);
388
389         if (totleft) {
390                 /* there are deformation modifier which doesn't support deformation matrices
391                  * calculation. Need additional crazyspace correction */
392
393                 float (*deformedVerts)[3] = *deformcos;
394                 float (*origVerts)[3] = MEM_dupallocN(deformedVerts);
395                 float (*quats)[4];
396                 int i, deformed = 0;
397                 VirtualModifierData virtualModifierData;
398                 Object *object_eval = DEG_get_evaluated_object(depsgraph, object);
399                 ModifierData *md = modifiers_getVirtualModifierList(object_eval, &virtualModifierData);
400                 const ModifierEvalContext mectx = {depsgraph, object_eval, 0};
401                 Mesh *mesh = (Mesh *)object->data;
402
403                 for (; md; md = md->next) {
404                         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
405
406                         if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) continue;
407
408                         if (mti->type == eModifierTypeType_OnlyDeform) {
409                                 /* skip leading modifiers which have been already
410                                  * handled in sculpt_get_first_deform_matrices */
411                                 if (mti->deformMatrices && !deformed)
412                                         continue;
413
414                                 mti->deformVerts(md, &mectx, NULL, deformedVerts, mesh->totvert);
415                                 deformed = 1;
416                         }
417                 }
418
419                 quats = MEM_mallocN(mesh->totvert * sizeof(*quats), "crazy quats");
420
421                 BKE_crazyspace_set_quats_mesh(mesh, origVerts, deformedVerts, quats);
422
423                 for (i = 0; i < mesh->totvert; i++) {
424                         float qmat[3][3], tmat[3][3];
425
426                         quat_to_mat3(qmat, quats[i]);
427                         mul_m3_m3m3(tmat, qmat, (*deformmats)[i]);
428                         copy_m3_m3((*deformmats)[i], tmat);
429                 }
430
431                 MEM_freeN(origVerts);
432                 MEM_freeN(quats);
433         }
434
435         if (*deformmats == NULL) {
436                 int a, numVerts;
437                 Mesh *mesh = (Mesh *)object->data;
438
439                 *deformcos = BKE_mesh_vertexCos_get(mesh, &numVerts);
440                 *deformmats = MEM_callocN(sizeof(*(*deformmats)) * numVerts, "defmats");
441
442                 for (a = 0; a < numVerts; a++)
443                         unit_m3((*deformmats)[a]);
444         }
445 }