d2ffbbcf27b61eb2194b3653d313bb20f5df825d
[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
52 BLI_INLINE void tan_calc_quat_v3(
53         float r_quat[4],
54         const float co_1[3], const float co_2[3], const float co_3[3])
55 {
56         float vec_u[3], vec_v[3];
57         float nor[3];
58
59         sub_v3_v3v3(vec_u, co_1, co_2);
60         sub_v3_v3v3(vec_v, co_1, co_3);
61
62         cross_v3_v3v3(nor, vec_u, vec_v);
63
64         if (normalize_v3(nor) > FLT_EPSILON) {
65                 const float zero_vec[3] = {0.0f};
66                 tri_to_quat_ex(r_quat, zero_vec, vec_u, vec_v, nor);
67         }
68         else {
69                 unit_qt(r_quat);
70         }
71 }
72
73 static void set_crazy_vertex_quat(
74         float r_quat[4],
75         const float co_1[3], const float co_2[3], const float co_3[3],
76         const float vd_1[3], const float vd_2[3], const float vd_3[3])
77 {
78         float q1[4], q2[4];
79
80         tan_calc_quat_v3(q1, co_1, co_2, co_3);
81         tan_calc_quat_v3(q2, vd_1, vd_2, vd_3);
82
83         sub_qt_qtqt(r_quat, q2, q1);
84 }
85
86 static int modifiers_disable_subsurf_temporary(Object *ob)
87 {
88         ModifierData *md;
89         int disabled = 0;
90
91         for (md = ob->modifiers.first; md; md = md->next)
92                 if (md->type == eModifierType_Subsurf)
93                         if (md->mode & eModifierMode_OnCage) {
94                                 md->mode ^= eModifierMode_DisableTemporary;
95                                 disabled = 1;
96                         }
97
98         return disabled;
99 }
100
101 /* disable subsurf temporal, get mapped cos, and enable it */
102 float (*BKE_crazyspace_get_mapped_editverts(
103            const struct EvaluationContext *eval_ctx, Scene *scene, Object *obedit))[3]
104 {
105         Mesh *me = obedit->data;
106         DerivedMesh *dm;
107         float (*vertexcos)[3];
108         int nverts = me->edit_btmesh->bm->totvert;
109
110         /* disable subsurf temporal, get mapped cos, and enable it */
111         if (modifiers_disable_subsurf_temporary(obedit)) {
112                 /* need to make new derivemesh */
113                 makeDerivedMesh(eval_ctx, scene, obedit, me->edit_btmesh, CD_MASK_BAREMESH, false);
114         }
115
116         /* now get the cage */
117         vertexcos = MEM_mallocN(sizeof(*vertexcos) * nverts, "vertexcos map");
118
119         dm = editbmesh_get_derived_cage(eval_ctx, scene, obedit, me->edit_btmesh, CD_MASK_BAREMESH);
120
121         mesh_get_mapped_verts_coords(dm, vertexcos, nverts);
122
123         dm->release(dm);
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, float (*origcos)[3], float (*mappedcos)[3], float (*quats)[4],
132                                    const bool use_select)
133 {
134         BMFace *f;
135         BMIter iter;
136         int index;
137
138         {
139                 BMVert *v;
140                 BM_ITER_MESH_INDEX (v, &iter, em->bm, BM_VERTS_OF_MESH, index) {
141                         BM_elem_flag_disable(v, BM_ELEM_TAG);
142                         BM_elem_index_set(v, index);  /* set_inline */
143                 }
144                 em->bm->elem_index_dirty &= ~BM_VERT;
145         }
146
147         BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
148                 BMLoop *l_iter, *l_first;
149
150                 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
151                 do {
152                         if (BM_elem_flag_test(l_iter->v, BM_ELEM_HIDDEN) ||
153                             BM_elem_flag_test(l_iter->v, BM_ELEM_TAG) ||
154                             (use_select && !BM_elem_flag_test(l_iter->v, BM_ELEM_SELECT)))
155                         {
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],
184                                                       co_curr, co_next, co_prev,
185                                                       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, float (*origcos)[3], float (*mappedcos)[3], float (*quats)[4])
194 {
195         int i;
196         MVert *mvert;
197         MLoop *mloop;
198         MPoly *mp;
199
200         mvert = me->mvert;
201         for (i = 0; i < me->totvert; i++, mvert++)
202                 mvert->flag &= ~ME_VERT_TMP_TAG;
203
204         /* first store two sets of tangent vectors in vertices, we derive it just from the face-edges */
205         mvert = me->mvert;
206         mp = me->mpoly;
207         mloop = me->mloop;
208
209         for (i = 0; i < me->totpoly; i++, mp++) {
210                 MLoop *ml_prev, *ml_curr, *ml_next;
211                 int j;
212
213                 ml_next = &mloop[mp->loopstart];
214                 ml_curr = &ml_next[mp->totloop - 1];
215                 ml_prev = &ml_next[mp->totloop - 2];
216
217                 for (j = 0; j < mp->totloop; j++) {
218                         if ((mvert[ml_curr->v].flag & ME_VERT_TMP_TAG) == 0) {
219                                 const float *co_prev, *co_curr, *co_next;  /* orig */
220                                 const float *vd_prev, *vd_curr, *vd_next;  /* deform */
221
222                                 /* retrieve mapped coordinates */
223                                 vd_prev = mappedcos[ml_prev->v];
224                                 vd_curr = mappedcos[ml_curr->v];
225                                 vd_next = mappedcos[ml_next->v];
226
227                                 if (origcos) {
228                                         co_prev = origcos[ml_prev->v];
229                                         co_curr = origcos[ml_curr->v];
230                                         co_next = origcos[ml_next->v];
231                                 }
232                                 else {
233                                         co_prev = mvert[ml_prev->v].co;
234                                         co_curr = mvert[ml_curr->v].co;
235                                         co_next = mvert[ml_next->v].co;
236                                 }
237
238                                 set_crazy_vertex_quat(quats[ml_curr->v],
239                                                       co_curr, co_next, co_prev,
240                                                       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(
255         const struct EvaluationContext *eval_ctx, Scene *scene, Object *ob, BMEditMesh *em,
256         float (**deformmats)[3][3], float (**deformcos)[3])
257 {
258         ModifierData *md;
259         DerivedMesh *dm;
260         int i, a, numleft = 0, numVerts = 0;
261         int cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1);
262         float (*defmats)[3][3] = NULL, (*deformedVerts)[3] = NULL;
263         VirtualModifierData virtualModifierData;
264
265         modifiers_clearErrors(ob);
266
267         dm = NULL;
268         md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
269
270         /* compute the deformation matrices and coordinates for the first
271          * modifiers with on cage editing that are enabled and support computing
272          * deform matrices */
273         for (i = 0; md && i <= cageIndex; i++, md = md->next) {
274                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
275
276                 if (!editbmesh_modifier_is_enabled(scene, md, dm))
277                         continue;
278
279                 if (mti->type == eModifierTypeType_OnlyDeform && mti->deformMatricesEM) {
280                         if (!defmats) {
281                                 const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
282                                 CustomDataMask data_mask = CD_MASK_BAREMESH;
283                                 CDMaskLink *datamasks = modifiers_calcDataMasks(scene, ob, md, data_mask, required_mode, NULL, 0);
284                                 data_mask = datamasks->mask;
285                                 BLI_linklist_free((LinkNode *)datamasks, NULL);
286
287                                 dm = getEditDerivedBMesh(em, ob, data_mask, NULL);
288                                 deformedVerts = editbmesh_get_vertex_cos(em, &numVerts);
289                                 defmats = MEM_mallocN(sizeof(*defmats) * numVerts, "defmats");
290
291                                 for (a = 0; a < numVerts; a++)
292                                         unit_m3(defmats[a]);
293                         }
294
295                         mti->deformMatricesEM(md, eval_ctx, ob, em, dm, deformedVerts, defmats,
296                                               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, dm) && modifier_isCorrectableDeformed(md))
304                         numleft++;
305
306         if (dm)
307                 dm->release(dm);
308
309         *deformmats = defmats;
310         *deformcos = deformedVerts;
311
312         return numleft;
313 }
314
315 int BKE_sculpt_get_first_deform_matrices(
316         const struct EvaluationContext *eval_ctx, Scene *scene,
317         Object *ob, float (**deformmats)[3][3], float (**deformcos)[3])
318 {
319         ModifierData *md;
320         DerivedMesh *dm;
321         int a, numVerts = 0;
322         float (*defmats)[3][3] = NULL, (*deformedVerts)[3] = NULL;
323         MultiresModifierData *mmd = get_multires_modifier(scene, ob, 0);
324         const bool has_multires = mmd != NULL && mmd->sculptlvl > 0;
325         int numleft = 0;
326         VirtualModifierData virtualModifierData;
327
328         if (has_multires) {
329                 *deformmats = NULL;
330                 *deformcos = NULL;
331                 return numleft;
332         }
333
334         dm = NULL;
335         md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
336
337         for (; md; md = md->next) {
338                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
339
340                 if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) continue;
341
342                 if (mti->type == eModifierTypeType_OnlyDeform) {
343                         if (!defmats) {
344                                 Mesh *me = (Mesh *)ob->data;
345                                 dm = mesh_create_derived(me, NULL);
346                                 deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
347                                 defmats = MEM_callocN(sizeof(*defmats) * numVerts, "defmats");
348
349                                 for (a = 0; a < numVerts; a++)
350                                         unit_m3(defmats[a]);
351                         }
352
353                         if (mti->deformMatrices) mti->deformMatrices(md, eval_ctx, ob, dm, deformedVerts, defmats, numVerts);
354                         else break;
355                 }
356         }
357
358         for (; md; md = md->next) {
359                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
360
361                 if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) continue;
362
363                 if (mti->type == eModifierTypeType_OnlyDeform)
364                         numleft++;
365         }
366
367         if (dm)
368                 dm->release(dm);
369
370         *deformmats = defmats;
371         *deformcos = deformedVerts;
372
373         return numleft;
374 }
375
376 void BKE_crazyspace_build_sculpt(const struct EvaluationContext *eval_ctx, Scene *scene, Object *ob, float (**deformmats)[3][3], float (**deformcos)[3])
377 {
378         int totleft = BKE_sculpt_get_first_deform_matrices(eval_ctx, scene, ob, deformmats, deformcos);
379
380         if (totleft) {
381                 /* there are deformation modifier which doesn't support deformation matrices
382                  * calculation. Need additional crazyspace correction */
383
384                 float (*deformedVerts)[3] = *deformcos;
385                 float (*origVerts)[3] = MEM_dupallocN(deformedVerts);
386                 float (*quats)[4];
387                 int i, deformed = 0;
388                 VirtualModifierData virtualModifierData;
389                 ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
390                 Mesh *me = (Mesh *)ob->data;
391
392                 for (; md; md = md->next) {
393                         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
394
395                         if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) continue;
396
397                         if (mti->type == eModifierTypeType_OnlyDeform) {
398                                 /* skip leading modifiers which have been already
399                                  * handled in sculpt_get_first_deform_matrices */
400                                 if (mti->deformMatrices && !deformed)
401                                         continue;
402
403                                 mti->deformVerts(md, eval_ctx, ob, NULL, deformedVerts, me->totvert, 0);
404                                 deformed = 1;
405                         }
406                 }
407
408                 quats = MEM_mallocN(me->totvert * sizeof(*quats), "crazy quats");
409
410                 BKE_crazyspace_set_quats_mesh(me, origVerts, deformedVerts, quats);
411
412                 for (i = 0; i < me->totvert; i++) {
413                         float qmat[3][3], tmat[3][3];
414
415                         quat_to_mat3(qmat, quats[i]);
416                         mul_m3_m3m3(tmat, qmat, (*deformmats)[i]);
417                         copy_m3_m3((*deformmats)[i], tmat);
418                 }
419
420                 MEM_freeN(origVerts);
421                 MEM_freeN(quats);
422         }
423
424         if (*deformmats == NULL) {
425                 int a, numVerts;
426                 Mesh *me = (Mesh *)ob->data;
427
428                 *deformcos = BKE_mesh_vertexCos_get(me, &numVerts);
429                 *deformmats = MEM_callocN(sizeof(*(*deformmats)) * numVerts, "defmats");
430
431                 for (a = 0; a < numVerts; a++)
432                         unit_m3((*deformmats)[a]);
433         }
434 }